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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
982 | func0 | #include <assert.h>
#include <cmath>
| double func0(double number) {
if(number == 0){
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while(fabs(g - g2) > 1e-6){
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(fabs(func0(10) - 3.162277660168379) < 1e-9);
assert(fabs(func0(2) - 1.414213562373095) < 1e-9);
assert(fabs(func0(9) - 3.0) < 1e-9);
return 0;
}
| O2 | cpp | func0(double) [clone .part.0]:
movsd 0xe90(%rip),%xmm6
movapd %xmm0,%xmm3
movsd 0xe8c(%rip),%xmm1
movq 0xed4(%rip),%xmm5
movsd 0xe84(%rip),%xmm4
mulsd %xmm6,%xmm0
addsd %xmm0,%xmm1
movapd %xmm0,%xmm7
subsd %xmm1,%xmm7
movapd %xmm7,%xmm1
andpd %xmm5,%xmm1
comisd %xmm4,%xmm1
jbe 12b2 <_Z5func0d.part.0+0x72>
nopw 0x0(%rax,%rax,1)
movapd %xmm3,%xmm1
movapd %xmm0,%xmm2
divsd %xmm0,%xmm1
addsd %xmm0,%xmm1
movapd %xmm1,%xmm0
mulsd %xmm6,%xmm0
movapd %xmm0,%xmm1
subsd %xmm2,%xmm1
andpd %xmm5,%xmm1
comisd %xmm4,%xmm1
ja 1288 <_Z5func0d.part.0+0x48>
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0d:
endbr64
movapd xmm3, xmm0
pxor xmm0, xmm0
ucomisd xmm3, xmm0
jp short loc_12E4
jz short locret_1352
loc_12E4:
movsd xmm6, cs:qword_20B0
movapd xmm0, xmm3
movsd xmm2, cs:qword_20B8
movq xmm5, cs:qword_2110
movsd xmm4, cs:qword_20C0
mulsd xmm0, xmm6
addsd xmm2, xmm0
movapd xmm1, xmm0
subsd xmm1, xmm2
andpd xmm1, xmm5
comisd xmm1, xmm4
jbe short locret_1352
nop word ptr [rax+rax+00h]
loc_1328:
movapd xmm1, xmm3
movapd xmm2, xmm0
divsd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, xmm1
mulsd xmm0, xmm6
movapd xmm1, xmm0
subsd xmm1, xmm2
andpd xmm1, xmm5
comisd xmm1, xmm4
ja short loc_1328
locret_1352:
retn | void func0(double a1)
{
double v2; // xmm0_8
double v3; // xmm2_8
if ( a1 != 0.0 )
{
v2 = a1 * 0.5;
if ( fabs(a1 * 0.5 - (a1 * 0.5 + 1.0)) > 0.000001 )
{
do
{
v3 = v2;
v2 = (a1 / v2 + v2) * 0.5;
}
while ( fabs(v2 - v3) > 0.000001 );
}
}
} | func0:
ENDBR64
MOVAPD XMM3,XMM0
PXOR XMM0,XMM0
UCOMISD XMM3,XMM0
JP 0x001012e4
JZ 0x00101352
LAB_001012e4:
MOVSD XMM6,qword ptr [0x001020b0]
MOVAPD XMM0,XMM3
MOVSD XMM2,qword ptr [0x001020b8]
MOVQ XMM5,qword ptr [0x00102110]
MOVSD XMM4,qword ptr [0x001020c0]
MULSD XMM0,XMM6
ADDSD XMM2,XMM0
MOVAPD XMM1,XMM0
SUBSD XMM1,XMM2
ANDPD XMM1,XMM5
COMISD XMM1,XMM4
JBE 0x00101352
NOP word ptr [RAX + RAX*0x1]
LAB_00101328:
MOVAPD XMM1,XMM3
MOVAPD XMM2,XMM0
DIVSD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,XMM1
MULSD XMM0,XMM6
MOVAPD XMM1,XMM0
SUBSD XMM1,XMM2
ANDPD XMM1,XMM5
COMISD XMM1,XMM4
JA 0x00101328
LAB_00101352:
RET | /* func0(double) */
void func0(double param_1)
{
double dVar1;
double dVar2;
double dVar3;
if (param_1 != 0.0) {
dVar1 = param_1 * DAT_001020b0;
dVar3 = dVar1 - (DAT_001020b8 + dVar1);
while (DAT_001020c0 < (double)((ulong)dVar3 & DAT_00102110)) {
dVar2 = (param_1 / dVar1 + dVar1) * DAT_001020b0;
dVar3 = dVar2 - dVar1;
dVar1 = dVar2;
}
}
return;
} |
983 | func0 | #include <assert.h>
#include <cmath>
| double func0(double number) {
if(number == 0){
return 0;
}
double g = number / 2.0;
double g2 = g + 1;
while(fabs(g - g2) > 1e-6){
double n = number / g;
g2 = g;
g = (g + n) / 2;
}
return g;
}
| int main() {
assert(fabs(func0(10) - 3.162277660168379) < 1e-9);
assert(fabs(func0(2) - 1.414213562373095) < 1e-9);
assert(fabs(func0(9) - 3.0) < 1e-9);
return 0;
}
| O3 | cpp | func0(double):
endbr64
pxor %xmm7,%xmm7
movapd %xmm0,%xmm3
ucomisd %xmm7,%xmm0
jnp 1358 <_Z5func0d+0x88>
movsd 0xdee(%rip),%xmm6
movapd %xmm3,%xmm0
movsd 0xdea(%rip),%xmm1
movq 0xe42(%rip),%xmm5
movsd 0xde2(%rip),%xmm4
mulsd %xmm6,%xmm0
addsd %xmm0,%xmm1
movapd %xmm0,%xmm7
subsd %xmm1,%xmm7
movapd %xmm7,%xmm1
andpd %xmm5,%xmm1
comisd %xmm4,%xmm1
jbe 135e <_Z5func0d+0x8e>
nopl 0x0(%rax)
movapd %xmm3,%xmm1
movapd %xmm0,%xmm2
divsd %xmm0,%xmm1
addsd %xmm0,%xmm1
movapd %xmm1,%xmm0
mulsd %xmm6,%xmm0
movapd %xmm0,%xmm1
subsd %xmm2,%xmm1
andpd %xmm5,%xmm1
comisd %xmm4,%xmm1
ja 1328 <_Z5func0d+0x58>
retq
nopl 0x0(%rax,%rax,1)
jne 12e2 <_Z5func0d+0x12>
pxor %xmm0,%xmm0
retq
| _Z5func0d:
endbr64
movapd xmm3, xmm0
pxor xmm0, xmm0
ucomisd xmm3, xmm0
jp short loc_12E4
jz short locret_1352
loc_12E4:
movsd xmm6, cs:qword_20B8
movapd xmm0, xmm3
movsd xmm2, cs:qword_20C0
movq xmm5, cs:qword_2120
movsd xmm4, cs:qword_20C8
mulsd xmm0, xmm6
addsd xmm2, xmm0
movapd xmm1, xmm0
subsd xmm1, xmm2
andpd xmm1, xmm5
comisd xmm1, xmm4
jbe short locret_1352
nop word ptr [rax+rax+00h]
loc_1328:
movapd xmm1, xmm3
movapd xmm2, xmm0
divsd xmm1, xmm0
addsd xmm1, xmm0
movapd xmm0, xmm1
mulsd xmm0, xmm6
movapd xmm1, xmm0
subsd xmm1, xmm2
andpd xmm1, xmm5
comisd xmm1, xmm4
ja short loc_1328
locret_1352:
retn | void func0(double a1)
{
double v2; // xmm0_8
double v3; // xmm2_8
if ( a1 != 0.0 )
{
v2 = a1 * 0.5;
if ( fabs(a1 * 0.5 - (a1 * 0.5 + 1.0)) > 0.000001 )
{
do
{
v3 = v2;
v2 = (a1 / v2 + v2) * 0.5;
}
while ( fabs(v2 - v3) > 0.000001 );
}
}
} | func0:
ENDBR64
MOVAPD XMM3,XMM0
PXOR XMM0,XMM0
UCOMISD XMM3,XMM0
JP 0x001012e4
JZ 0x00101352
LAB_001012e4:
MOVSD XMM6,qword ptr [0x001020b8]
MOVAPD XMM0,XMM3
MOVSD XMM2,qword ptr [0x001020c0]
MOVQ XMM5,qword ptr [0x00102120]
MOVSD XMM4,qword ptr [0x001020c8]
MULSD XMM0,XMM6
ADDSD XMM2,XMM0
MOVAPD XMM1,XMM0
SUBSD XMM1,XMM2
ANDPD XMM1,XMM5
COMISD XMM1,XMM4
JBE 0x00101352
NOP word ptr [RAX + RAX*0x1]
LAB_00101328:
MOVAPD XMM1,XMM3
MOVAPD XMM2,XMM0
DIVSD XMM1,XMM0
ADDSD XMM1,XMM0
MOVAPD XMM0,XMM1
MULSD XMM0,XMM6
MOVAPD XMM1,XMM0
SUBSD XMM1,XMM2
ANDPD XMM1,XMM5
COMISD XMM1,XMM4
JA 0x00101328
LAB_00101352:
RET | /* func0(double) */
void func0(double param_1)
{
double dVar1;
double dVar2;
double dVar3;
if (param_1 != 0.0) {
dVar1 = param_1 * DAT_001020b8;
dVar3 = dVar1 - (DAT_001020c0 + dVar1);
while (DAT_001020c8 < (double)((ulong)dVar3 & DAT_00102120)) {
dVar2 = (param_1 / dVar1 + dVar1) * DAT_001020b8;
dVar3 = dVar2 - dVar1;
dVar1 = dVar2;
}
}
return;
} |
984 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| int func0(const std::string& str) {
int n = str.length();
std::vector<std::vector<int>> L(n, std::vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; ++cl) {
for (int i = 0; i < n - cl + 1; ++i) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i + 1][j - 1] + 2;
} else {
L[i][j] = std::max(L[i][j - 1], L[i + 1][j]);
}
}
}
return L[0][n - 1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 2360 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
mov %eax,-0x58(%rbp)
lea -0x69(%rbp),%rax
mov %rax,%rdi
callq 2cfe <_ZNSaISt6vectorIiSaIiEEEC1Ev>
lea -0x6a(%rbp),%rax
mov %rax,%rdi
callq 2bee <_ZNSaIiEC1Ev>
movl $0x0,-0x68(%rbp)
mov -0x58(%rbp),%eax
movslq %eax,%rsi
lea -0x6a(%rbp),%rcx
lea -0x68(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2c2e <_ZNSt6vectorIiSaIiEEC1EmRKiRKS0_>
mov -0x58(%rbp),%eax
movslq %eax,%rsi
lea -0x69(%rbp),%rcx
lea -0x30(%rbp),%rdx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2d3e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEC1EmRKS1_RKS2_>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2cb6 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x6a(%rbp),%rax
mov %rax,%rdi
callq 2c0e <_ZNSaIiED1Ev>
lea -0x69(%rbp),%rax
mov %rax,%rdi
callq 2d1e <_ZNSaISt6vectorIiSaIiEEED1Ev>
movl $0x0,-0x64(%rbp)
mov -0x64(%rbp),%eax
cmp -0x58(%rbp),%eax
jge 25b2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe9>
mov -0x64(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x64(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
movl $0x1,(%rax)
addl $0x1,-0x64(%rbp)
jmp 2576 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xad>
movl $0x2,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp -0x58(%rbp),%eax
jg 27a3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2da>
movl $0x0,-0x5c(%rbp)
mov -0x58(%rbp),%eax
sub -0x60(%rbp),%eax
cmp %eax,-0x5c(%rbp)
jg 279a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d1>
mov -0x5c(%rbp),%edx
mov -0x60(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
mov %eax,-0x54(%rbp)
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2310 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%ebx
mov -0x54(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2310 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
cmp %al,%bl
jne 262a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x161>
cmpl $0x2,-0x60(%rbp)
jne 262a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x161>
mov $0x1,%eax
jmp 262f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x166>
mov $0x0,%eax
test %al,%al
je 2666 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19d>
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
movl $0x2,(%rax)
jmpq 2791 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c8>
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2310 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%ebx
mov -0x54(%rbp),%eax
movslq %eax,%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2310 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
cmp %al,%bl
sete %al
test %al,%al
je 2701 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x238>
mov -0x5c(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
lea 0x2(%rax),%ebx
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
jmpq 2791 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c8>
mov -0x5c(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov %rax,%rbx
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov %rbx,%rsi
mov %rax,%rdi
callq 2e60 <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%ebx
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x54(%rbp),%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov %ebx,(%rax)
addl $0x1,-0x5c(%rbp)
jmpq 25cc <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x103>
addl $0x1,-0x60(%rbp)
jmpq 25b9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
lea -0x50(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 2e0e <_ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm>
mov %rax,%rdx
mov -0x58(%rbp),%eax
sub $0x1,%eax
cltq
mov %rax,%rsi
mov %rdx,%rdi
callq 2e3c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2dc6 <_ZNSt6vectorIS_IiSaIiEESaIS1_EED1Ev>
mov %ebx,%eax
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 2832 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x369>
jmp 282d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x364>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 2cb6 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
jmp 2807 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x33e>
endbr64
mov %rax,%rbx
lea -0x6a(%rbp),%rax
mov %rax,%rdi
callq 2c0e <_ZNSaIiED1Ev>
lea -0x69(%rbp),%rax
mov %rax,%rdi
callq 2d1e <_ZNSaISt6vectorIiSaIiEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23a0 <_Unwind_Resume@plt>
callq 2330 <__stack_chk_fail@plt>
add $0x78,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_88]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rbp+var_68], eax
lea rax, [rbp+var_79]
mov [rbp+var_58], rax
nop
nop
lea rax, [rbp+var_7A]
mov [rbp+var_60], rax
nop
nop
mov [rbp+var_78], 0
mov eax, [rbp+var_68]
movsxd rsi, eax
lea rcx, [rbp+var_7A]
lea rdx, [rbp+var_78]
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2EmRKiRKS0_; std::vector<int>::vector(ulong,int const&,std::allocator<int> const&)
mov eax, [rbp+var_68]
movsxd rsi, eax
lea rcx, [rbp+var_79]
lea rdx, [rbp+var_30]
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEC2EmRKS1_RKS2_; std::vector<std::vector<int>>::vector(ulong,std::vector<int> const&,std::allocator<std::vector<int>> const&)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_7A]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_79]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorIiSaIiEEED2Ev; std::__new_allocator<std::vector<int>>::~__new_allocator()
nop
mov [rbp+var_74], 0
jmp short loc_2551
loc_251F:
mov eax, [rbp+var_74]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_74]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov dword ptr [rax], 1
add [rbp+var_74], 1
loc_2551:
mov eax, [rbp+var_74]
cmp eax, [rbp+var_68]
jl short loc_251F
mov [rbp+var_70], 2
jmp loc_274A
loc_2565:
mov [rbp+var_6C], 0
jmp loc_2737
loc_2571:
mov edx, [rbp+var_6C]
mov eax, [rbp+var_70]
add eax, edx
sub eax, 1
mov [rbp+var_64], eax
mov eax, [rbp+var_6C]
movsxd rdx, eax
mov rax, [rbp+var_88]
mov rsi, rdx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx ebx, byte ptr [rax]
mov eax, [rbp+var_64]
movsxd rdx, eax
mov rax, [rbp+var_88]
mov rsi, rdx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
cmp bl, al
jnz short loc_25C6
cmp [rbp+var_70], 2
jnz short loc_25C6
mov eax, 1
jmp short loc_25CB
loc_25C6:
mov eax, 0
loc_25CB:
test al, al
jz short loc_2602
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov dword ptr [rax], 2
jmp loc_2733
loc_2602:
mov eax, [rbp+var_6C]
movsxd rdx, eax
mov rax, [rbp+var_88]
mov rsi, rdx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx ebx, byte ptr [rax]
mov eax, [rbp+var_64]
movsxd rdx, eax
mov rax, [rbp+var_88]
mov rsi, rdx
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
cmp bl, al
setz al
test al, al
jz short loc_26A3
mov eax, [rbp+var_6C]
add eax, 1
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
lea ebx, [rax+2]
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
jmp loc_2733
loc_26A3:
mov eax, [rbp+var_6C]
add eax, 1
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rbx, rax
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rsi, rbx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov ebx, [rax]
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_64]
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov [rax], ebx
loc_2733:
add [rbp+var_6C], 1
loc_2737:
mov eax, [rbp+var_68]
sub eax, [rbp+var_70]
cmp [rbp+var_6C], eax
jle loc_2571
add [rbp+var_70], 1
loc_274A:
mov eax, [rbp+var_70]
cmp eax, [rbp+var_68]
jle loc_2565
lea rax, [rbp+var_50]
mov esi, 0
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EEixEm; std::vector<std::vector<int>>::operator[](ulong)
mov rdx, rax
mov eax, [rbp+var_68]
sub eax, 1
cdqe
mov rsi, rax
mov rdi, rdx
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_27F8
jmp short loc_27F3
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp short loc_27BA
endbr64
mov rbx, rax
loc_27BA:
lea rax, [rbp+var_7A]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_79]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorIiSaIiEEED2Ev; std::__new_allocator<std::vector<int>>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_27EB
call ___stack_chk_fail
loc_27EB:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_27F3:
call ___stack_chk_fail
loc_27F8:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
long long v1; // rax
char v2; // bl
long long v4; // rax
char v5; // bl
long long v6; // rax
int v7; // ebx
long long v8; // rax
long long v9; // rax
long long v10; // rbx
long long v11; // rax
long long v12; // rax
long long v13; // rax
unsigned int v14; // ebx
char v16; // [rsp+16h] [rbp-7Ah] BYREF
char v17; // [rsp+17h] [rbp-79h] BYREF
int v18; // [rsp+18h] [rbp-78h] BYREF
int i; // [rsp+1Ch] [rbp-74h]
int j; // [rsp+20h] [rbp-70h]
int k; // [rsp+24h] [rbp-6Ch]
int v22; // [rsp+28h] [rbp-68h]
int v23; // [rsp+2Ch] [rbp-64h]
char *v24; // [rsp+30h] [rbp-60h]
char *v25; // [rsp+38h] [rbp-58h]
_BYTE v26[32]; // [rsp+40h] [rbp-50h] BYREF
_BYTE v27[24]; // [rsp+60h] [rbp-30h] BYREF
unsigned long long v28; // [rsp+78h] [rbp-18h]
v28 = __readfsqword(0x28u);
v22 = std::string::length(a1);
v25 = &v17;
v24 = &v16;
v18 = 0;
std::vector<int>::vector(v27, v22, &v18, &v16);
std::vector<std::vector<int>>::vector(v26, v22, v27, &v17);
std::vector<int>::~vector(v27);
std::__new_allocator<int>::~__new_allocator(&v16);
std::__new_allocator<std::vector<int>>::~__new_allocator(&v17);
for ( i = 0; i < v22; ++i )
{
v1 = std::vector<std::vector<int>>::operator[](v26, i);
*(_DWORD *)std::vector<int>::operator[](v1, i) = 1;
}
for ( j = 2; j <= v22; ++j )
{
for ( k = 0; k <= v22 - j; ++k )
{
v23 = k + j - 1;
v2 = *(_BYTE *)std::string::operator[](a1, k);
if ( v2 == *(_BYTE *)std::string::operator[](a1, v23) && j == 2 )
{
v4 = std::vector<std::vector<int>>::operator[](v26, k);
*(_DWORD *)std::vector<int>::operator[](v4, v23) = 2;
}
else
{
v5 = *(_BYTE *)std::string::operator[](a1, k);
if ( v5 == *(_BYTE *)std::string::operator[](a1, v23) )
{
v6 = std::vector<std::vector<int>>::operator[](v26, k + 1);
v7 = *(_DWORD *)std::vector<int>::operator[](v6, v23 - 1) + 2;
}
else
{
v9 = std::vector<std::vector<int>>::operator[](v26, k + 1);
v10 = std::vector<int>::operator[](v9, v23);
v11 = std::vector<std::vector<int>>::operator[](v26, k);
v12 = std::vector<int>::operator[](v11, v23 - 1);
v7 = *(_DWORD *)std::max<int>(v12, v10);
}
v8 = std::vector<std::vector<int>>::operator[](v26, k);
*(_DWORD *)std::vector<int>::operator[](v8, v23) = v7;
}
}
}
v13 = std::vector<std::vector<int>>::operator[](v26, 0LL);
v14 = *(_DWORD *)std::vector<int>::operator[](v13, v22 - 1);
std::vector<std::vector<int>>::~vector(v26);
return v14;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,RAX
CALL 0x00102320
MOV dword ptr [RBP + -0x68],EAX
LEA RAX,[RBP + -0x79]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
LEA RAX,[RBP + -0x7a]
MOV qword ptr [RBP + -0x60],RAX
NOP
NOP
MOV dword ptr [RBP + -0x78],0x0
MOV EAX,dword ptr [RBP + -0x68]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x7a]
LEA RDX,[RBP + -0x78]
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
LAB_001024d1:
CALL 0x00102b92
MOV EAX,dword ptr [RBP + -0x68]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x79]
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
LAB_001024eb:
CALL 0x00102c72
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00102c18
LEA RAX,[RBP + -0x7a]
MOV RDI,RAX
CALL 0x00103014
NOP
LEA RAX,[RBP + -0x79]
MOV RDI,RAX
CALL 0x00103202
NOP
MOV dword ptr [RBP + -0x74],0x0
JMP 0x00102551
LAB_0010251f:
MOV EAX,dword ptr [RBP + -0x74]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x74]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV dword ptr [RAX],0x1
ADD dword ptr [RBP + -0x74],0x1
LAB_00102551:
MOV EAX,dword ptr [RBP + -0x74]
CMP EAX,dword ptr [RBP + -0x68]
JL 0x0010251f
MOV dword ptr [RBP + -0x70],0x2
JMP 0x0010274a
LAB_00102565:
MOV dword ptr [RBP + -0x6c],0x0
JMP 0x00102737
LAB_00102571:
MOV EDX,dword ptr [RBP + -0x6c]
MOV EAX,dword ptr [RBP + -0x70]
ADD EAX,EDX
SUB EAX,0x1
MOV dword ptr [RBP + -0x64],EAX
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022d0
MOVZX EBX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x64]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022d0
MOVZX EAX,byte ptr [RAX]
CMP BL,AL
JNZ 0x001025c6
CMP dword ptr [RBP + -0x70],0x2
JNZ 0x001025c6
MOV EAX,0x1
JMP 0x001025cb
LAB_001025c6:
MOV EAX,0x0
LAB_001025cb:
TEST AL,AL
JZ 0x00102602
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV dword ptr [RAX],0x2
JMP 0x00102733
LAB_00102602:
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022d0
MOVZX EBX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x64]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001022d0
MOVZX EAX,byte ptr [RAX]
CMP BL,AL
SETZ AL
TEST AL,AL
JZ 0x001026a3
MOV EAX,dword ptr [RBP + -0x6c]
ADD EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV EAX,dword ptr [RAX]
LEA EBX,[RAX + 0x2]
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV dword ptr [RAX],EBX
JMP 0x00102733
LAB_001026a3:
MOV EAX,dword ptr [RBP + -0x6c]
ADD EAX,0x1
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00102da4
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x64]
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV dword ptr [RAX],EBX
LAB_00102733:
ADD dword ptr [RBP + -0x6c],0x1
LAB_00102737:
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,dword ptr [RBP + -0x70]
CMP dword ptr [RBP + -0x6c],EAX
JLE 0x00102571
ADD dword ptr [RBP + -0x70],0x1
LAB_0010274a:
MOV EAX,dword ptr [RBP + -0x70]
CMP EAX,dword ptr [RBP + -0x68]
JLE 0x00102565
LEA RAX,[RBP + -0x50]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00102d52
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x68]
SUB EAX,0x1
CDQE
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00102d80
MOV EBX,dword ptr [RAX]
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00102cf8
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001027f8
JMP 0x001027f3
LAB_001027f3:
CALL 0x001022f0
LAB_001027f8:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
int4 func0(string *param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
bool bVar4;
char *pcVar5;
int *piVar6;
int *piVar7;
vector<int,std::allocator<int>> *pvVar8;
int4 *puVar9;
long in_FS_OFFSET;
allocator local_82;
allocator local_81;
int local_80;
int local_7c;
int local_78;
int local_74;
int local_70;
int local_6c;
allocator *local_68;
allocator *local_60;
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
local_58 [32];
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_70 = std::string::length();
local_60 = &local_81;
local_68 = &local_82;
local_80 = 0;
/* try { // try from 001024d1 to 001024d5 has its CatchHandler @ 001027b3 */
std::vector<int,std::allocator<int>>::vector(local_38,(long)local_70,&local_80,&local_82);
/* try { // try from 001024eb to 001024ef has its CatchHandler @ 0010279e */
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::vector(local_58,(long)local_70,(vector *)local_38,&local_81);
std::vector<int,std::allocator<int>>::~vector(local_38);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_82);
std::__new_allocator<std::vector<int,std::allocator<int>>>::~__new_allocator
((__new_allocator<std::vector<int,std::allocator<int>>> *)&local_81);
for (local_7c = 0; local_7c < local_70; local_7c = local_7c + 1) {
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_7c);
puVar9 = (int4 *)std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)local_7c);
*puVar9 = 1;
}
for (local_78 = 2; local_78 <= local_70; local_78 = local_78 + 1) {
for (local_74 = 0; local_74 <= local_70 - local_78; local_74 = local_74 + 1) {
local_6c = local_78 + local_74 + -1;
pcVar5 = (char *)std::string::operator[]((ulong)param_1);
cVar1 = *pcVar5;
pcVar5 = (char *)std::string::operator[]((ulong)param_1);
if ((cVar1 == *pcVar5) && (local_78 == 2)) {
bVar4 = true;
}
else {
bVar4 = false;
}
if (bVar4) {
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_74);
puVar9 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)local_6c);
*puVar9 = 2;
}
else {
pcVar5 = (char *)std::string::operator[]((ulong)param_1);
cVar1 = *pcVar5;
pcVar5 = (char *)std::string::operator[]((ulong)param_1);
if (cVar1 == *pcVar5) {
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)(local_74 + 1));
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[]
(pvVar8,(long)(local_6c + -1));
iVar2 = *piVar6;
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_74);
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)local_6c);
*piVar6 = iVar2 + 2;
}
else {
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)(local_74 + 1));
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)local_6c);
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_74);
piVar7 = (int *)std::vector<int,std::allocator<int>>::operator[]
(pvVar8,(long)(local_6c + -1));
piVar6 = std::max<int>(piVar7,piVar6);
iVar2 = *piVar6;
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,(long)local_74);
piVar6 = (int *)std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)local_6c);
*piVar6 = iVar2;
}
}
}
}
pvVar8 = (vector<int,std::allocator<int>> *)
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::operator[](local_58,0);
puVar9 = (int4 *)
std::vector<int,std::allocator<int>>::operator[](pvVar8,(long)(local_70 + -1));
uVar3 = *puVar9;
std::
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
::~vector(local_58);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
} |
985 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| int func0(const std::string& str) {
int n = str.length();
std::vector<std::vector<int>> L(n, std::vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; ++cl) {
for (int i = 0; i < n - cl + 1; ++i) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i + 1][j - 1] + 2;
} else {
L[i][j] = std::max(L[i][j - 1], L[i + 1][j]);
}
}
}
return L[0][n - 1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rdi),%rax
mov %rax,0x8(%rsp)
movslq %eax,%rbp
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbp
ja 1379 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70>
mov %rdi,%rbx
test %rbp,%rbp
je 15f5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2ec>
lea 0x0(,%rbp,4),%r12
mov %r12,%rdi
callq 11b0 <_Znwm@plt>
mov %rax,(%rsp)
lea (%rax,%r12,1),%rdx
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 135a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x51>
lea 0x0(%rbp,%rbp,2),%rdi
shl $0x3,%rdi
callq 11b0 <_Znwm@plt>
jmp 1385 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x7c>
lea 0xc88(%rip),%rdi
callq 1150 <_ZSt20__throw_length_errorPKc@plt>
mov %rax,0x10(%rsp)
mov %r12,%r14
sar $0x2,%r14
mov %rax,%r15
jmp 13f0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe7>
callq 1130 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rdi
callq 1140 <__cxa_begin_catch@plt>
mov 0x10(%rsp),%rbx
cmp %r15,%rbx
je 14b0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a7>
mov (%rbx),%rdi
test %rdi,%rdi
je 13c2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb9>
callq 11a0 <_ZdlPv@plt>
add $0x18,%rbx
jmp 13ac <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xa3>
mov %rax,%rdi
mov %rdi,(%r15)
lea (%rdi,%r12,1),%r13
mov %r13,0x10(%r15)
mov %r12,%rdx
mov (%rsp),%rsi
callq 1180 <memcpy@plt>
mov %r13,0x8(%r15)
add $0x18,%r15
sub $0x1,%rbp
je 1430 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
movq $0x0,(%r15)
movq $0x0,0x8(%r15)
movq $0x0,0x10(%r15)
test %r14,%r14
je 1429 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x120>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r14
ja 1396 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x8d>
mov %r12,%rdi
callq 11b0 <_Znwm@plt>
jmp 13c8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xbf>
mov $0x0,%edi
jmp 13cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xc2>
cmpq $0x0,(%rsp)
je 1440 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x137>
mov (%rsp),%rdi
callq 11a0 <_ZdlPv@plt>
cmpl $0x0,0x8(%rsp)
jle 1473 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
mov 0x10(%rsp),%rax
mov 0x8(%rsp),%rcx
lea -0x1(%rcx),%edx
lea 0x4(,%rdx,4),%rcx
mov (%rax),%rdx
movl $0x1,(%rdx,%rbp,1)
add $0x18,%rax
add $0x4,%rbp
cmp %rcx,%rbp
jne 145c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x153>
cmpl $0x1,0x8(%rsp)
jle 159d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x294>
mov 0x8(%rsp),%rax
mov %eax,%r14d
lea -0x2(%rax),%r13d
add $0x3,%r13
mov $0x2,%r8d
mov $0xfffffffffffffffe,%rbp
mov $0x1,%r12d
mov %r15,0x18(%rsp)
mov 0x10(%rsp),%r15
jmpq 1574 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x26b>
callq 11d0 <__cxa_rethrow@plt>
endbr64
mov %rax,%rbx
callq 11f0 <__cxa_end_catch@plt>
mov 0x10(%rsp),%rdi
callq 11a0 <_ZdlPv@plt>
cmpq $0x0,(%rsp)
je 14db <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1d2>
mov (%rsp),%rdi
callq 11a0 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1200 <_Unwind_Resume@plt>
cmp %dl,%sil
je 1546 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x23d>
mov 0x18(%rcx),%rdx
lea (%rdx,%rax,4),%rdi
mov (%rcx),%rsi
lea (%r11,%rax,1),%edx
movslq %edx,%rdx
shl $0x2,%rdx
lea (%rsi,%rdx,1),%r9
mov (%rdi),%r12d
cmp %r12d,(%rsi,%rdx,1)
cmovge %r9,%rdi
mov (%rdi),%edx
mov %edx,(%rsi,%rax,4)
add $0x1,%rax
add $0x18,%rcx
cmp %r10,%rax
je 155f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x256>
mov (%rbx),%rdx
lea (%rdx,%rax,1),%rsi
movzbl 0x1(%rbp,%rsi,1),%esi
movzbl (%rdx,%rax,1),%edx
cmp $0x2,%r8d
jne 14e3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1da>
cmp %dl,%sil
jne 14e3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1da>
mov (%rcx),%rdx
movl $0x2,(%rdx,%rax,4)
jmp 1512 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x209>
mov (%rcx),%rsi
lea (%r11,%rax,1),%edx
movslq %edx,%rdx
mov 0x18(%rcx),%rdi
mov (%rdi,%rdx,4),%edx
add $0x2,%edx
mov %edx,(%rsi,%rax,4)
jmp 1512 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x209>
mov (%rsp),%r12
add $0x1,%r12
sub $0x1,%rbp
add $0x1,%r8
cmp %r8,%r13
je 1598 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28f>
mov %r8d,%r11d
mov %r14d,%r10d
sub %r8d,%r10d
js 1563 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x25a>
mov %r15,%rcx
mov %r10d,%r10d
add %r8,%r10
mov %r12,%rax
sub $0x2,%r11d
sub %r12d,%r11d
mov %r12,(%rsp)
jmp 151f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x216>
mov 0x18(%rsp),%r15
mov 0x8(%rsp),%eax
sub $0x1,%eax
cltq
mov 0x10(%rsp),%rbx
mov (%rbx),%rdx
mov (%rdx,%rax,4),%ebp
cmp %rbx,%r15
jne 15da <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d1>
mov 0x10(%rsp),%rdi
callq 11a0 <_ZdlPv@plt>
mov %ebp,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
add $0x18,%rbx
cmp %rbx,%r15
je 15b6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2ad>
mov (%rbx),%rdi
test %rdi,%rdi
je 15d1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c8>
callq 11a0 <_ZdlPv@plt>
jmp 15d1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c8>
endbr64
mov %rax,%rbx
jmpq 14cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c2>
movq $0x0,0x10(%rsp)
mov $0x0,%r15d
jmp 159d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x294>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov r12, [rdi+8]
movsxd rbp, r12d
mov rax, rbp
shr rax, 3Dh
jnz short loc_13AF
mov rbx, rdi
test rbp, rbp
jz loc_15BE
lea r15, ds:0[rbp*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov r13, rax
mov [rsp+78h+var_58], rax
lea rdx, [rax+r15]
mov [rsp+78h+var_48], rdx
loc_1388:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_1388
mov [rsp+78h+var_50], rdx
lea rdi, [rbp+rbp*2+0]
shl rdi, 3; unsigned __int64
call __Znwm; operator new(ulong)
jmp loc_15EA
loc_13AF:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_13CB
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_13CB:
call ___stack_chk_fail
loc_13D0:
mov rbp, rax
test r13, r13
jz short loc_13E3
mov rsi, r15; unsigned __int64
mov rdi, r13; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_13E3:
test r12d, r12d
jle loc_1544
mov r9, r14
lea eax, [r12-1]
lea rsi, ds:4[rax*4]
mov rdx, r14
mov eax, 0
loc_1404:
mov rcx, [rdx]
mov dword ptr [rcx+rax], 1
add rdx, 18h
add rax, 4
cmp rax, rsi
jnz short loc_1404
cmp r12d, 1
jle loc_1544
lea esi, [r12-2]
lea r13d, [r12+1]
mov r8d, 2
mov r10d, 4
mov [rsp+78h+var_60], r12
mov [rsp+78h+var_70], r13
mov rdi, rbp
jmp loc_1520
endbr64
mov rbx, rax
test r14, r14
jz short loc_1466
mov rsi, [rsp+arg_8]; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1466:
lea rdi, [rsp+arg_18]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_30]
sub rax, fs:28h
jz loc_15B6
call ___stack_chk_fail
loc_1489:
cmp r12b, bpl
jz short loc_14F2
mov rbp, rcx
add rbp, [rdx+18h]
mov r12, [rdx]
movsxd r13, r11d
lea r13, [r12+r13*4]
mov esi, [rbp+0]
cmp [r13+0], esi
cmovge rbp, r13
mov ebp, [rbp+0]
mov [r12+rcx], ebp
loc_14B1:
lea rbp, [rax+1]
add rdx, 18h
add rcx, 4
add r11d, 1
cmp rax, r15
jz short loc_150A
mov rax, rbp
loc_14C9:
mov rbp, [rbx]
movzx r12d, byte ptr [rbp+rax+0]
add rbp, r8
movzx ebp, byte ptr [rax+rbp-1]
cmp r8d, 2
jnz short loc_1489
cmp r12b, bpl
jnz short loc_1489
mov rbp, [rdx]
mov dword ptr [rbp+rcx+0], 2
jmp short loc_14B1
loc_14F2:
mov r13, [rdx]
movsxd rbp, r11d
mov r12, [rdx+18h]
mov ebp, [r12+rbp*4]
add ebp, 2
mov [r13+rcx+0], ebp
jmp short loc_14B1
loc_150A:
mov esi, [rsp+78h+var_74]
loc_150E:
sub esi, 1
add r10, 4
add r8, 1
cmp [rsp+78h+var_70], r8
jz short loc_153C
loc_1520:
test esi, esi
js short loc_150E
lea r11d, [r8-2]
mov r15d, esi
mov rcx, r10
mov rdx, r9
mov eax, 0
mov [rsp+78h+var_74], esi
jmp short loc_14C9
loc_153C:
mov r12, [rsp+78h+var_60]
mov rbp, rdi
loc_1544:
lea eax, [r12-1]
cdqe
mov rdx, [r14]
mov r12d, [rdx+rax*4]
cmp rbp, r14
jz short loc_157B
mov rbx, r14
jmp short loc_1565
loc_155C:
add rbx, 18h
cmp rbp, rbx
jz short loc_157B
loc_1565:
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_155C
mov rsi, [rbx+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_155C
loc_157B:
mov rsi, [rsp+78h+var_68]; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1610
mov eax, r12d
add rsp, 48h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
endbr64
mov rbx, rax
jmp loc_1466
loc_15B6:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_15BE:
mov [rsp+78h+var_58], 0
mov [rsp+78h+var_48], 0
mov [rsp+78h+var_50], 0
mov r15, rbp
mov r13d, 0
mov r14d, 0
jmp short loc_15ED
loc_15EA:
mov r14, rax
loc_15ED:
lea rax, [rbp+rbp*2+0]
shl rax, 3
mov [rsp+78h+var_68], rax
lea rdx, [rsp+78h+var_58]
mov rsi, rbp
mov rdi, r14
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
jmp loc_13D0
loc_1610:
call ___stack_chk_fail | long long func0(_QWORD *a1)
{
long long v1; // r12
unsigned long long v3; // r15
_DWORD *v4; // rax
void *v5; // r13
_DWORD *v6; // rdx
long long v7; // rbp
_QWORD *v8; // rdx
long long v9; // rax
int v10; // esi
long long v11; // r8
long long v12; // r10
long long v13; // rdi
_DWORD *v14; // rbp
_QWORD *v15; // rdx
long long v16; // rcx
int v17; // r11d
long long i; // rax
char v19; // r12
char v20; // bp
unsigned int v21; // r12d
void **v22; // rbx
_QWORD *v24; // r14
long long v25; // [rsp+8h] [rbp-70h]
long long v26; // [rsp+10h] [rbp-68h]
int v27; // [rsp+18h] [rbp-60h]
_DWORD *v28; // [rsp+20h] [rbp-58h] BYREF
_DWORD *v29; // [rsp+28h] [rbp-50h]
_DWORD *v30; // [rsp+30h] [rbp-48h]
unsigned long long v31; // [rsp+38h] [rbp-40h]
v31 = __readfsqword(0x28u);
v1 = a1[1];
if ( (unsigned long long)(int)v1 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( (_DWORD)v1 )
{
v3 = (int)v1;
v4 = (_DWORD *)operator new(v3 * 4);
v5 = v4;
v28 = v4;
v6 = &v4[v3];
v30 = &v4[v3];
do
*v4++ = 0;
while ( v4 != v6 );
v29 = v6;
v24 = (_QWORD *)operator new(24LL * (int)v1);
}
else
{
v28 = 0LL;
v30 = 0LL;
v29 = 0LL;
v3 = 0LL;
v5 = 0LL;
v24 = 0LL;
}
v26 = 24LL * (int)v1;
v7 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v24, (int)v1, &v28);
if ( v5 )
operator delete(v5, v3 * 4);
if ( (int)v1 > 0 )
{
v8 = v24;
v9 = 0LL;
do
{
*(_DWORD *)(*v8 + v9) = 1;
v8 += 3;
v9 += 4LL;
}
while ( v9 != 4LL * (unsigned int)(v1 - 1) + 4 );
if ( (int)v1 > 1 )
{
v10 = v1 - 2;
v11 = 2LL;
v12 = 4LL;
v27 = v1;
v25 = (unsigned int)(v1 + 1);
v13 = v7;
do
{
if ( v10 >= 0 )
{
v17 = v11 - 2;
v16 = v12;
v15 = v24;
for ( i = 0LL; ; ++i )
{
v19 = *(_BYTE *)(*a1 + i);
v20 = *(_BYTE *)(i + v11 + *a1 - 1);
if ( (_DWORD)v11 == 2 && v19 == v20 )
{
*(_DWORD *)(*v15 + v16) = 2;
}
else if ( v19 == v20 )
{
*(_DWORD *)(*v15 + v16) = *(_DWORD *)(v15[3] + 4LL * v17) + 2;
}
else
{
v14 = (_DWORD *)(v15[3] + v16);
if ( *(_DWORD *)(*v15 + 4LL * v17) >= *v14 )
v14 = (_DWORD *)(*v15 + 4LL * v17);
*(_DWORD *)(*v15 + v16) = *v14;
}
v15 += 3;
v16 += 4LL;
++v17;
if ( i == v10 )
break;
}
}
--v10;
v12 += 4LL;
++v11;
}
while ( v25 != v11 );
LODWORD(v1) = v27;
v7 = v13;
}
}
v21 = *(_DWORD *)(*v24 + 4LL * ((int)v1 - 1));
if ( (_QWORD *)v7 != v24 )
{
v22 = (void **)v24;
do
{
if ( *v22 )
operator delete(*v22, (_BYTE *)v22[2] - (_BYTE *)*v22);
v22 += 3;
}
while ( (void **)v7 != v22 );
}
operator delete(v24, v26);
return v21;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV R12,qword ptr [RDI + 0x8]
MOVSXD RBP,R12D
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x001013af
MOV RBX,RDI
TEST RBP,RBP
JZ 0x001015be
LEA R15,[RBP*0x4]
MOV RDI,R15
LAB_00101372:
CALL 0x001011b0
MOV R13,RAX
MOV qword ptr [RSP + 0x20],RAX
LEA RDX,[RAX + R15*0x1]
MOV qword ptr [RSP + 0x30],RDX
LAB_00101388:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101388
MOV qword ptr [RSP + 0x28],RDX
LEA RDI,[RBP + RBP*0x2]
SHL RDI,0x3
LAB_001013a5:
CALL 0x001011b0
JMP 0x001015ea
LAB_001013af:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013cb
LEA RDI,[0x102040]
LAB_001013c6:
CALL 0x00101160
LAB_001013cb:
CALL 0x001011d0
LAB_001013d0:
MOV RBP,RAX
TEST R13,R13
JZ 0x001013e3
MOV RSI,R15
MOV RDI,R13
CALL 0x001011c0
LAB_001013e3:
TEST R12D,R12D
JLE 0x00101544
MOV R9,R14
LEA EAX,[R12 + -0x1]
LEA RSI,[0x4 + RAX*0x4]
MOV RDX,R14
MOV EAX,0x0
LAB_00101404:
MOV RCX,qword ptr [RDX]
MOV dword ptr [RCX + RAX*0x1],0x1
ADD RDX,0x18
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101404
CMP R12D,0x1
JLE 0x00101544
LEA ESI,[R12 + -0x2]
LEA R13D,[R12 + 0x1]
MOV R8D,0x2
MOV R10D,0x4
MOV qword ptr [RSP + 0x18],R12
MOV qword ptr [RSP + 0x8],R13
MOV RDI,RBP
JMP 0x00101520
LAB_00101489:
CMP R12B,BPL
JZ 0x001014f2
MOV RBP,RCX
ADD RBP,qword ptr [RDX + 0x18]
MOV R12,qword ptr [RDX]
MOVSXD R13,R11D
LEA R13,[R12 + R13*0x4]
MOV ESI,dword ptr [RBP]
CMP dword ptr [R13],ESI
CMOVGE RBP,R13
MOV EBP,dword ptr [RBP]
MOV dword ptr [R12 + RCX*0x1],EBP
LAB_001014b1:
LEA RBP,[RAX + 0x1]
ADD RDX,0x18
ADD RCX,0x4
ADD R11D,0x1
CMP RAX,R15
JZ 0x0010150a
MOV RAX,RBP
LAB_001014c9:
MOV RBP,qword ptr [RBX]
MOVZX R12D,byte ptr [RBP + RAX*0x1]
ADD RBP,R8
MOVZX EBP,byte ptr [RAX + RBP*0x1 + -0x1]
CMP R8D,0x2
JNZ 0x00101489
CMP R12B,BPL
JNZ 0x00101489
MOV RBP,qword ptr [RDX]
MOV dword ptr [RBP + RCX*0x1],0x2
JMP 0x001014b1
LAB_001014f2:
MOV R13,qword ptr [RDX]
MOVSXD RBP,R11D
MOV R12,qword ptr [RDX + 0x18]
MOV EBP,dword ptr [R12 + RBP*0x4]
ADD EBP,0x2
MOV dword ptr [R13 + RCX*0x1],EBP
JMP 0x001014b1
LAB_0010150a:
MOV ESI,dword ptr [RSP + 0x4]
LAB_0010150e:
SUB ESI,0x1
ADD R10,0x4
ADD R8,0x1
CMP qword ptr [RSP + 0x8],R8
JZ 0x0010153c
LAB_00101520:
TEST ESI,ESI
JS 0x0010150e
LEA R11D,[R8 + -0x2]
MOV R15D,ESI
MOV RCX,R10
MOV RDX,R9
MOV EAX,0x0
MOV dword ptr [RSP + 0x4],ESI
JMP 0x001014c9
LAB_0010153c:
MOV R12,qword ptr [RSP + 0x18]
MOV RBP,RDI
LAB_00101544:
LEA EAX,[R12 + -0x1]
CDQE
MOV RDX,qword ptr [R14]
MOV R12D,dword ptr [RDX + RAX*0x4]
CMP RBP,R14
JZ 0x0010157b
MOV RBX,R14
JMP 0x00101565
LAB_0010155c:
ADD RBX,0x18
CMP RBP,RBX
JZ 0x0010157b
LAB_00101565:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x0010155c
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,RDI
CALL 0x001011c0
JMP 0x0010155c
LAB_0010157b:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x001011c0
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101610
MOV EAX,R12D
ADD RSP,0x48
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001015be:
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV R15,RBP
MOV R13D,0x0
MOV R14D,0x0
JMP 0x001015ed
LAB_001015ea:
MOV R14,RAX
LAB_001015ed:
LEA RAX,[RBP + RBP*0x2]
SHL RAX,0x3
MOV qword ptr [RSP + 0x10],RAX
LEA RDX,[RSP + 0x20]
MOV RSI,RBP
MOV RDI,R14
LAB_00101606:
CALL 0x001018cc
JMP 0x001013d0
LAB_00101610:
CALL 0x001011d0 | /* func0(std::string const&) */
int4 func0(string *param_1)
{
int *piVar1;
char cVar2;
char cVar3;
int4 uVar4;
void *pvVar5;
int4 *puVar6;
int4 *puVar7;
vector *pvVar8;
long lVar9;
ulong uVar10;
vector *pvVar11;
long lVar12;
vector *pvVar13;
ulong uVar14;
int *piVar15;
uint uVar16;
ulong uVar17;
int iVar18;
int iVar19;
long in_FS_OFFSET;
bool bVar20;
int4 *local_58;
int4 *local_50;
int4 *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iVar19 = (int)*(int8 *)(param_1 + 8);
uVar14 = (ulong)iVar19;
if (uVar14 >> 0x3d != 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (uVar14 == 0) {
local_58 = (int4 *)0x0;
local_48 = (int4 *)0x0;
local_50 = (int4 *)0x0;
puVar6 = (int4 *)0x0;
pvVar8 = (vector *)0x0;
uVar17 = 0;
}
else {
uVar17 = uVar14 * 4;
puVar6 = (int4 *)operator_new(uVar17);
local_50 = puVar6 + uVar14;
puVar7 = puVar6;
do {
*puVar7 = 0;
puVar7 = puVar7 + 1;
} while (puVar7 != local_50);
local_58 = puVar6;
local_48 = local_50;
/* try { // try from 001013a5 to 001013a9 has its CatchHandler @ 001015aa */
pvVar8 = (vector *)operator_new(uVar14 * 0x18);
}
/* try { // try from 00101606 to 0010160a has its CatchHandler @ 0010144d */
pvVar11 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar8,uVar14,(vector *)&local_58);
if (puVar6 != (int4 *)0x0) {
operator_delete(puVar6,uVar17);
}
if (0 < iVar19) {
lVar9 = 0;
pvVar13 = pvVar8;
do {
*(int4 *)(*(long *)pvVar13 + lVar9) = 1;
pvVar13 = pvVar13 + 0x18;
lVar9 = lVar9 + 4;
} while (lVar9 != (ulong)(iVar19 - 1) * 4 + 4);
if (1 < iVar19) {
uVar16 = iVar19 - 2;
uVar17 = 2;
lVar9 = 4;
do {
if (-1 < (int)uVar16) {
iVar18 = (int)uVar17 + -2;
uVar10 = 0;
lVar12 = lVar9;
pvVar13 = pvVar8;
do {
cVar2 = *(char *)(*(long *)param_1 + uVar10);
cVar3 = *(char *)((uVar10 - 1) + *(long *)param_1 + uVar17);
if (((int)uVar17 == 2) && (cVar2 == cVar3)) {
*(int4 *)(*(long *)pvVar13 + lVar12) = 2;
}
else if (cVar2 == cVar3) {
*(int *)(*(long *)pvVar13 + lVar12) =
*(int *)(*(long *)(pvVar13 + 0x18) + (long)iVar18 * 4) + 2;
}
else {
piVar1 = (int *)(*(long *)pvVar13 + (long)iVar18 * 4);
piVar15 = (int *)(lVar12 + *(long *)(pvVar13 + 0x18));
if (*(int *)(lVar12 + *(long *)(pvVar13 + 0x18)) <= *piVar1) {
piVar15 = piVar1;
}
*(int *)(*(long *)pvVar13 + lVar12) = *piVar15;
}
pvVar13 = pvVar13 + 0x18;
lVar12 = lVar12 + 4;
iVar18 = iVar18 + 1;
bVar20 = uVar10 != uVar16;
uVar10 = uVar10 + 1;
} while (bVar20);
}
uVar16 = uVar16 - 1;
lVar9 = lVar9 + 4;
uVar17 = uVar17 + 1;
} while (iVar19 + 1 != uVar17);
}
}
uVar4 = *(int4 *)(*(long *)pvVar8 + (long)(iVar19 + -1) * 4);
for (pvVar13 = pvVar8; pvVar11 != pvVar13; pvVar13 = pvVar13 + 0x18) {
pvVar5 = *(void **)pvVar13;
if (pvVar5 != (void *)0x0) {
operator_delete(pvVar5,*(long *)(pvVar13 + 0x10) - (long)pvVar5);
}
}
operator_delete(pvVar8,uVar14 * 0x18);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
986 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| int func0(const std::string& str) {
int n = str.length();
std::vector<std::vector<int>> L(n, std::vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; ++cl) {
for (int i = 0; i < n - cl + 1; ++i) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i + 1][j - 1] + 2;
} else {
L[i][j] = std::max(L[i][j - 1], L[i + 1][j]);
}
}
}
return L[0][n - 1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rdi),%rax
mov %rax,0x10(%rsp)
movslq %eax,%rbx
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbx
ja 1805 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b5>
test %rbx,%rbx
je 17d4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x284>
lea 0x0(,%rbx,4),%rbp
mov %rdi,%r14
mov %rbp,%rdi
callq 11d0 <_Znwm@plt>
mov %rax,%r13
lea (%rax,%rbp,1),%rdx
nopl 0x0(%rax)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 15a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x58>
lea (%rbx,%rbx,2),%rdi
shl $0x3,%rdi
callq 11d0 <_Znwm@plt>
mov %rbp,%rcx
mov %rax,0x18(%rsp)
mov %rax,%r15
sar $0x2,%rcx
mov %rcx,0x8(%rsp)
jmp 1622 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd2>
nopw 0x0(%rax,%rax,1)
movabs $0x1fffffffffffffff,%rcx
cmp %rcx,%rax
ja 1811 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2c1>
mov %rbp,%rdi
callq 11d0 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%rbp,1),%r12
mov %rdi,(%r15)
mov %rbp,%rdx
mov %r13,%rsi
mov %r12,0x10(%r15)
add $0x18,%r15
callq 11a0 <memcpy@plt>
mov %r12,-0x10(%r15)
sub $0x1,%rbx
je 1650 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov 0x8(%rsp),%rax
movq $0x0,(%r15)
movq $0x0,0x8(%r15)
movq $0x0,0x10(%r15)
test %rax,%rax
jne 15e0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x90>
xor %edi,%edi
jmp 15fe <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xae>
nopw 0x0(%rax,%rax,1)
mov %r13,%rdi
callq 11c0 <_ZdlPv@plt>
mov 0x10(%rsp),%eax
test %eax,%eax
jle 17f4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2a4>
mov 0x10(%rsp),%ecx
mov 0x18(%rsp),%rax
lea -0x1(%rcx),%edx
mov %edx,0x8(%rsp)
lea 0x4(,%rdx,4),%rcx
nopl 0x0(%rax)
mov (%rax),%rdx
add $0x18,%rax
movl $0x1,(%rdx,%rbx,1)
add $0x4,%rbx
cmp %rcx,%rbx
jne 1680 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
cmpl $0x1,0x10(%rsp)
jle 1772 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x222>
mov 0x10(%rsp),%rax
mov %r15,0x10(%rsp)
mov $0x2,%r9d
mov $0xfffffffe,%r13d
mov 0x18(%rsp),%r15
lea -0x2(%rax),%r12d
mov %eax,%ebp
add $0x3,%r12
nopw 0x0(%rax,%rax,1)
mov %ebp,%esi
sub %r9d,%esi
js 1760 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x210>
mov (%r14),%rax
mov %r13d,%r11d
mov %esi,%esi
lea -0x4(,%r9,4),%rcx
lea 0x18(%r15),%rdx
sub %eax,%r11d
lea 0x1(%rax,%rsi,1),%rbx
add %r9d,%r11d
jmp 172a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1da>
nopl 0x0(%rax)
mov (%rdx),%rdi
lea (%r11,%rax,1),%r10d
movslq %r10d,%r10
mov (%rdi,%rcx,1),%edi
cmp %edi,(%rsi,%r10,4)
cmovge (%rsi,%r10,4),%edi
mov %edi,(%r8)
add $0x1,%rax
add $0x4,%rcx
add $0x18,%rdx
cmp %rax,%rbx
je 1760 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x210>
mov -0x18(%rdx),%rsi
movzbl -0x1(%r9,%rax,1),%edi
lea (%rsi,%rcx,1),%r8
cmp %dil,(%rax)
jne 1700 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b0>
cmp $0x2,%r9
je 17c8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x278>
mov (%rdx),%rdi
lea (%r11,%rax,1),%esi
movslq %esi,%rsi
mov (%rdi,%rsi,4),%esi
add $0x2,%esi
mov %esi,(%r8)
jmp 1719 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c9>
nopl 0x0(%rax)
add $0x1,%r9
cmp %r9,%r12
jne 16d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x180>
mov 0x10(%rsp),%r15
mov 0x18(%rsp),%rbx
movslq 0x8(%rsp),%rax
mov (%rbx),%rdi
mov (%rdi,%rax,4),%r12d
cmp %r15,%rbx
jne 1793 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x243>
jmp 17a6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x256>
nopw 0x0(%rax,%rax,1)
mov (%rbx),%rdi
test %rdi,%rdi
je 179d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x24d>
callq 11c0 <_ZdlPv@plt>
add $0x18,%rbx
cmp %rbx,%r15
jne 1790 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x240>
mov 0x18(%rsp),%rdi
callq 11c0 <_ZdlPv@plt>
add $0x28,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
movl $0x2,(%r8)
jmpq 1719 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c9>
mov 0x10(%rsp),%eax
mov 0x0,%rdx
movq $0x0,0x18(%rsp)
sub $0x1,%eax
cltq
mov (%rdx,%rax,4),%r12d
jmp 17a6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x256>
mov 0x10(%rsp),%rax
sub $0x1,%eax
mov %eax,0x8(%rsp)
jmpq 1697 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x147>
lea 0x7fc(%rip),%rdi
callq 1170 <_ZSt20__throw_length_errorPKc@plt>
callq 1140 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rdi
jmpq 1240 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%rbp
jmpq 126a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x2a>
xchg %ax,%ax
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movsxd rbx, ebp
mov rax, rbx
shr rax, 3Dh
jnz loc_175B
lea rax, [rbx+rbx*2]
pxor xmm0, xmm0
shl rax, 3
movups [rsp+78h+var_58+8], xmm0
mov [rsp+78h+var_68], rax
test rbx, rbx
jz loc_172D
lea r14, ds:0[rbx*4]
mov r12, rdi
mov rdi, r14; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r14; n
xor esi, esi; c
lea r15, [rax+r14]
mov rdi, rax; s
mov qword ptr [rsp+78h+var_58], rax
mov r13, rax
mov [rsp+78h+var_48], r15
call _memset
mov rdi, [rsp+78h+var_68]; unsigned __int64
mov qword ptr [rsp+78h+var_58+8], r15
call __Znwm; operator new(ulong)
lea rdx, [rsp+78h+var_58]
mov rsi, rbx
mov rdi, rax
mov r15, rax
mov [rsp+78h+var_78], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rdi, r13; void *
mov rsi, r14; unsigned __int64
mov rbx, rax
mov r13d, ebp
call __ZdlPvm; operator delete(void *,ulong)
lea edx, [rbp-1]
mov rcx, r15
mov rax, rdx
lea rdi, ds:4[rdx*4]
xor edx, edx
loc_15E0:
mov rsi, [rcx]
add rcx, 18h
mov dword ptr [rsi+rdx], 1
add rdx, 4
cmp rdx, rdi
jnz short loc_15E0
cmp ebp, 1
jz loc_16C9
mov r11, [r12]
mov [rsp+78h+var_60], rbx
lea r12d, [rbp+1]
mov r10d, eax
mov [rsp+78h+var_6C], r13d
mov r9d, 2
mov r8d, 4
lea r14, [r15+18h]
mov [rsp+78h+var_78], r11
lea rbp, [r11+1]
nop dword ptr [rax]
loc_1630:
mov ebx, [rsp+78h+var_6C]
mov rax, [rsp+78h+var_78]
lea edi, [r9-2]
mov rcx, r14
mov rsi, r8
sub ebx, r9d
add rbx, rbp
jmp short loc_167D
loc_1650:
movsxd r13, edi
mov edx, [rdx+r13*4]
mov r13, [rcx]
mov r13d, [r13+rsi+0]
cmp edx, r13d
cmovl edx, r13d
loc_1666:
add rax, 1
mov [r11], edx
add rsi, 4
add edi, 1
add rcx, 18h
cmp rbx, rax
jz short loc_16B0
loc_167D:
mov rdx, [rcx-18h]
movzx r13d, byte ptr [r9+rax-1]
lea r11, [rdx+rsi]
cmp [rax], r13b
jnz short loc_1650
mov edx, 2
cmp r9, 2
jz short loc_1666
mov r13, [rcx]
movsxd rdx, edi
mov edx, [r13+rdx*4+0]
add edx, 2
jmp short loc_1666
loc_16B0:
add r9, 1
add r8, 4
cmp r9, r12
jnz loc_1630
mov rbx, [rsp+78h+var_60]
mov eax, r10d
loc_16C9:
mov rdx, [r15]
cdqe
mov r12d, [rdx+rax*4]
cmp r15, rbx
jz short loc_16FE
mov rbp, r15
nop word ptr [rax+rax+00h]
loc_16E0:
mov rdi, [rbp+0]; void *
test rdi, rdi
jz short loc_16F5
mov rsi, [rbp+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16F5:
add rbp, 18h
cmp rbp, rbx
jnz short loc_16E0
loc_16FE:
mov rsi, [rsp+78h+var_68]; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1777
add rsp, 48h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_172D:
lea rdx, [rsp+78h+var_58]
xor esi, esi
xor edi, edi
movaps [rsp+78h+var_58], xmm0
mov [rsp+78h+var_48], 0
mov [rsp+78h+var_78], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rbx, rax
xor r15d, r15d
lea eax, [rbp-1]
jmp loc_16C9
loc_175B:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1777
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1777:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
lea rax, [rsp+arg_18]
mov [rsp+0], rax
jmp loc_1292
endbr64
mov rbx, rax
jmp loc_1292 | long long func0(_QWORD *a1)
{
long long v1; // rbp
long long *v2; // r15
long long v3; // rbx
long long *v4; // rcx
long long v5; // rax
long long v6; // rdx
long long v7; // rsi
long long v8; // r12
int v9; // r10d
long long v10; // r9
long long v11; // r8
long long v12; // rbp
_BYTE *v13; // rax
int v14; // edi
_QWORD *v15; // rcx
long long v16; // rsi
int v17; // edx
long long v18; // rdx
int *v19; // r11
unsigned int v20; // r12d
void **v21; // rbp
_BYTE *v23; // [rsp+0h] [rbp-78h]
int v24; // [rsp+Ch] [rbp-6Ch]
long long v25; // [rsp+10h] [rbp-68h]
void *v26; // [rsp+20h] [rbp-58h]
v1 = a1[1];
if ( (unsigned long long)(int)v1 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v25 = 24LL * (int)v1;
if ( (_DWORD)v1 )
{
v26 = (void *)operator new(4LL * (int)v1);
memset(v26, 0, 4LL * (int)v1);
v2 = (long long *)operator new(v25);
v3 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v2, (int)v1);
operator delete(v26, 4LL * (int)v1);
v4 = v2;
v5 = (unsigned int)(v1 - 1);
v6 = 0LL;
do
{
v7 = *v4;
v4 += 3;
*(_DWORD *)(v7 + v6) = 1;
v6 += 4LL;
}
while ( v6 != 4 * v5 + 4 );
if ( (_DWORD)v1 != 1 )
{
v8 = (unsigned int)(v1 + 1);
v9 = v1 - 1;
v24 = v1;
v10 = 2LL;
v11 = 4LL;
v23 = (_BYTE *)*a1;
v12 = *a1 + 1LL;
do
{
v13 = v23;
v14 = v10 - 2;
v15 = v2 + 3;
v16 = v11;
do
{
v18 = *(v15 - 3);
v19 = (int *)(v18 + v16);
if ( *v13 == v13[v10 - 1] )
{
v17 = 2;
if ( v10 != 2 )
v17 = *(_DWORD *)(*v15 + 4LL * v14) + 2;
}
else
{
v17 = *(_DWORD *)(v18 + 4LL * v14);
if ( v17 < *(_DWORD *)(*v15 + v16) )
v17 = *(_DWORD *)(*v15 + v16);
}
++v13;
*v19 = v17;
v16 += 4LL;
++v14;
v15 += 3;
}
while ( (_BYTE *)(v12 + (unsigned int)(v24 - v10)) != v13 );
++v10;
v11 += 4LL;
}
while ( v10 != v8 );
LODWORD(v5) = v9;
}
}
else
{
v3 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(0LL, 0LL);
v2 = 0LL;
LODWORD(v5) = -1;
}
v20 = *(_DWORD *)(*v2 + 4LL * (int)v5);
if ( v2 != (long long *)v3 )
{
v21 = (void **)v2;
do
{
if ( *v21 )
operator delete(*v21, (_BYTE *)v21[2] - (_BYTE *)*v21);
v21 += 3;
}
while ( v21 != (void **)v3 );
}
operator delete(v2, v25);
return v20;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVSXD RBX,EBP
MOV RAX,RBX
SHR RAX,0x3d
JNZ 0x0010175b
LEA RAX,[RBX + RBX*0x2]
PXOR XMM0,XMM0
SHL RAX,0x3
MOVUPS xmmword ptr [RSP + 0x28],XMM0
MOV qword ptr [RSP + 0x10],RAX
TEST RBX,RBX
JZ 0x0010172d
LEA R14,[RBX*0x4]
MOV R12,RDI
MOV RDI,R14
LAB_00101573:
CALL 0x001011f0
MOV RDX,R14
XOR ESI,ESI
LEA R15,[RAX + R14*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x20],RAX
MOV R13,RAX
MOV qword ptr [RSP + 0x30],R15
CALL 0x001011a0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],R15
LAB_001015a0:
CALL 0x001011f0
LEA RDX,[RSP + 0x20]
MOV RSI,RBX
MOV RDI,RAX
MOV R15,RAX
MOV qword ptr [RSP],RDX
LAB_001015b7:
CALL 0x001018d0
MOV RDI,R13
MOV RSI,R14
MOV RBX,RAX
MOV R13D,EBP
CALL 0x00101200
LEA EDX,[RBP + -0x1]
MOV RCX,R15
MOV RAX,RDX
LEA RDI,[0x4 + RDX*0x4]
XOR EDX,EDX
LAB_001015e0:
MOV RSI,qword ptr [RCX]
ADD RCX,0x18
MOV dword ptr [RSI + RDX*0x1],0x1
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x001015e0
CMP EBP,0x1
JZ 0x001016c9
MOV R11,qword ptr [R12]
MOV qword ptr [RSP + 0x18],RBX
LEA R12D,[RBP + 0x1]
MOV R10D,EAX
MOV dword ptr [RSP + 0xc],R13D
MOV R9D,0x2
MOV R8D,0x4
LEA R14,[R15 + 0x18]
MOV qword ptr [RSP],R11
LEA RBP,[R11 + 0x1]
NOP dword ptr [RAX]
LAB_00101630:
MOV EBX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP]
LEA EDI,[R9 + -0x2]
MOV RCX,R14
MOV RSI,R8
SUB EBX,R9D
ADD RBX,RBP
JMP 0x0010167d
LAB_00101650:
MOVSXD R13,EDI
MOV EDX,dword ptr [RDX + R13*0x4]
MOV R13,qword ptr [RCX]
MOV R13D,dword ptr [R13 + RSI*0x1]
CMP EDX,R13D
CMOVL EDX,R13D
LAB_00101666:
ADD RAX,0x1
MOV dword ptr [R11],EDX
ADD RSI,0x4
ADD EDI,0x1
ADD RCX,0x18
CMP RBX,RAX
JZ 0x001016b0
LAB_0010167d:
MOV RDX,qword ptr [RCX + -0x18]
MOVZX R13D,byte ptr [R9 + RAX*0x1 + -0x1]
LEA R11,[RDX + RSI*0x1]
CMP byte ptr [RAX],R13B
JNZ 0x00101650
MOV EDX,0x2
CMP R9,0x2
JZ 0x00101666
MOV R13,qword ptr [RCX]
MOVSXD RDX,EDI
MOV EDX,dword ptr [R13 + RDX*0x4]
ADD EDX,0x2
JMP 0x00101666
LAB_001016b0:
ADD R9,0x1
ADD R8,0x4
CMP R9,R12
JNZ 0x00101630
MOV RBX,qword ptr [RSP + 0x18]
MOV EAX,R10D
LAB_001016c9:
MOV RDX,qword ptr [R15]
CDQE
MOV R12D,dword ptr [RDX + RAX*0x4]
CMP R15,RBX
JZ 0x001016fe
MOV RBP,R15
NOP word ptr [RAX + RAX*0x1]
LAB_001016e0:
MOV RDI,qword ptr [RBP]
TEST RDI,RDI
JZ 0x001016f5
MOV RSI,qword ptr [RBP + 0x10]
SUB RSI,RDI
CALL 0x00101200
LAB_001016f5:
ADD RBP,0x18
CMP RBP,RBX
JNZ 0x001016e0
LAB_001016fe:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,R15
CALL 0x00101200
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101777
ADD RSP,0x48
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010172d:
LEA RDX,[RSP + 0x20]
XOR ESI,ESI
XOR EDI,EDI
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP],RDX
LAB_00101748:
CALL 0x001018d0
MOV RBX,RAX
XOR R15D,R15D
LEA EAX,[RBP + -0x1]
JMP 0x001016c9
LAB_0010175b:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101777
LEA RDI,[0x102040]
LAB_00101772:
CALL 0x00101190
LAB_00101777:
CALL 0x00101210 | /* func0(std::string const&) */
int4 func0(string *param_1)
{
int4 uVar1;
char *pcVar2;
void *pvVar3;
vector *pvVar4;
vector *pvVar5;
char *pcVar6;
vector *pvVar7;
vector *pvVar8;
int iVar9;
long lVar10;
ulong uVar11;
int iVar12;
long lVar13;
int iVar14;
ulong uVar15;
long in_FS_OFFSET;
void *local_58;
void *pvStack_50;
void *pvStack_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iVar12 = (int)*(int8 *)(param_1 + 8);
uVar11 = (ulong)iVar12;
if (uVar11 >> 0x3d == 0) {
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
if (uVar11 == 0) {
local_58 = (void *)0x0;
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
/* try { // try from 00101748 to 0010174c has its CatchHandler @ 0010179d */
pvVar5 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
((vector *)0x0,0,(vector *)&local_58);
pvVar4 = (vector *)0x0;
}
else {
uVar15 = uVar11 * 4;
pvVar3 = operator_new(uVar15);
local_58 = pvVar3;
pvStack_48 = (void *)((long)pvVar3 + uVar15);
memset(pvVar3,0,uVar15);
pvStack_50 = (void *)((long)pvVar3 + uVar15);
/* try { // try from 001015a0 to 001015a4 has its CatchHandler @ 00101788 */
pvVar4 = (vector *)operator_new(uVar11 * 0x18);
/* try { // try from 001015b7 to 001015bb has its CatchHandler @ 0010177c */
pvVar5 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar4,uVar11,(vector *)&local_58);
operator_delete(pvVar3,uVar15);
lVar10 = 0;
pvVar7 = pvVar4;
do {
lVar13 = *(long *)pvVar7;
pvVar7 = pvVar7 + 0x18;
*(int4 *)(lVar13 + lVar10) = 1;
lVar10 = lVar10 + 4;
} while (lVar10 != (ulong)(iVar12 - 1) * 4 + 4);
if (iVar12 != 1) {
pcVar2 = *(char **)param_1;
uVar15 = 2;
lVar10 = 4;
do {
iVar14 = (int)uVar15 + -2;
pcVar6 = pcVar2;
lVar13 = lVar10;
pvVar7 = pvVar4;
do {
pvVar8 = pvVar7 + 0x18;
if (*pcVar6 == pcVar6[uVar15 - 1]) {
iVar9 = 2;
if (uVar15 != 2) {
iVar9 = *(int *)(*(long *)pvVar8 + (long)iVar14 * 4) + 2;
}
}
else {
iVar9 = *(int *)(*(long *)pvVar7 + (long)iVar14 * 4);
if (iVar9 < *(int *)(*(long *)pvVar8 + lVar13)) {
iVar9 = *(int *)(*(long *)pvVar8 + lVar13);
}
}
pcVar6 = pcVar6 + 1;
*(int *)(*(long *)pvVar7 + lVar13) = iVar9;
lVar13 = lVar13 + 4;
iVar14 = iVar14 + 1;
pvVar7 = pvVar8;
} while (pcVar2 + (ulong)(uint)(iVar12 - (int)uVar15) + 1 != pcVar6);
uVar15 = uVar15 + 1;
lVar10 = lVar10 + 4;
} while (uVar15 != iVar12 + 1);
}
}
uVar1 = *(int4 *)(*(long *)pvVar4 + (long)(iVar12 + -1) * 4);
for (pvVar7 = pvVar4; pvVar7 != pvVar5; pvVar7 = pvVar7 + 0x18) {
pvVar3 = *(void **)pvVar7;
if (pvVar3 != (void *)0x0) {
operator_delete(pvVar3,*(long *)(pvVar7 + 0x10) - (long)pvVar3);
}
}
operator_delete(pvVar4,uVar11 * 0x18);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar1;
}
}
else if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
987 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| int func0(const std::string& str) {
int n = str.length();
std::vector<std::vector<int>> L(n, std::vector<int>(n, 0));
for (int i = 0; i < n; ++i) {
L[i][i] = 1;
}
for (int cl = 2; cl <= n; ++cl) {
for (int i = 0; i < n - cl + 1; ++i) {
int j = i + cl - 1;
if (str[i] == str[j] && cl == 2) {
L[i][j] = 2;
} else if (str[i] == str[j]) {
L[i][j] = L[i + 1][j - 1] + 2;
} else {
L[i][j] = std::max(L[i][j - 1], L[i + 1][j]);
}
}
}
return L[0][n - 1];
}
| int main() {
assert(func0("TENS FOR TENS") == 5);
assert(func0("CARDIO FOR CARDS") == 7);
assert(func0("PART OF THE JOURNEY IS PART") == 9);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov 0x8(%rdi),%rax
mov %rdi,0x10(%rsp)
mov %rax,0x8(%rsp)
movslq %eax,%r13
movabs $0x1fffffffffffffff,%rax
cmp %rax,%r13
ja 18e3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x373>
test %r13,%r13
je 18b5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x345>
lea 0x0(,%r13,4),%rbp
lea 0x0(%r13,%r13,2),%rbx
mov %rbp,%rdi
shl $0x3,%rbx
callq 11f0 <_Znwm@plt>
mov %rbp,%rdx
xor %esi,%esi
mov %rax,%rdi
mov %rax,%r14
callq 1190 <memset@plt>
mov %rbx,%rdi
callq 11f0 <_Znwm@plt>
mov %rax,%r12
mov %rbp,%rax
sar $0x2,%rax
je 1840 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 18ef <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x37f>
mov %r12,%rbx
nopw %cs:0x0(%rax,%rax,1)
movq $0x0,0x10(%rbx)
pxor %xmm1,%xmm1
mov %rbp,%rdi
movups %xmm1,(%rbx)
callq 11f0 <_Znwm@plt>
lea (%rax,%rbp,1),%r15
mov %rax,(%rbx)
mov %rax,%rdi
mov %rbp,%rdx
mov %r15,0x10(%rbx)
mov %r14,%rsi
add $0x18,%rbx
callq 11c0 <memcpy@plt>
mov %r15,-0x10(%rbx)
sub $0x1,%r13
jne 1610 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xa0>
mov %r14,%rdi
callq 11e0 <_ZdlPv@plt>
mov 0x8(%rsp),%eax
test %eax,%eax
jle 18d2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x362>
mov 0x8(%rsp),%eax
mov %r12,%rdx
sub $0x1,%eax
mov %eax,0x1c(%rsp)
lea 0x4(,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdx),%rcx
add $0x18,%rdx
movl $0x1,(%rcx,%rax,1)
add $0x4,%rax
cmp %rsi,%rax
jne 1680 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x110>
cmpl $0x1,0x8(%rsp)
jle 1772 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x202>
mov 0x8(%rsp),%rax
mov %rbx,0x8(%rsp)
mov $0x2,%r9d
mov $0xfffffffe,%r15d
mov 0x10(%rsp),%rbx
lea -0x2(%rax),%r13d
mov %eax,%ebp
add $0x3,%r13
nopw 0x0(%rax,%rax,1)
mov %ebp,%esi
mov %r9d,%r11d
sub %r9d,%esi
js 1760 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f0>
mov (%rbx),%rax
cmp $0x2,%r9
je 17d8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x268>
mov %r15d,%edx
mov %esi,%esi
lea 0x18(%r12),%rdi
sub %eax,%edx
lea -0x4(,%r9,4),%r8
lea 0x1(%rax,%rsi,1),%r14
add %edx,%r11d
jmp 173a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ca>
nopl 0x0(%rax)
mov (%rdi),%rcx
lea (%r11,%rax,1),%r10d
movslq %r10d,%r10
mov (%rcx,%r8,1),%ecx
cmp %ecx,(%rdx,%r10,4)
cmovge (%rdx,%r10,4),%ecx
mov %ecx,(%rsi)
add $0x1,%rax
add $0x4,%r8
add $0x18,%rdi
cmp %r14,%rax
je 1760 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f0>
mov -0x18(%rdi),%rdx
movzbl (%rax),%ecx
lea (%rdx,%r8,1),%rsi
cmp %cl,-0x1(%rax,%r9,1)
jne 1710 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a0>
mov (%rdi),%rcx
lea (%r11,%rax,1),%edx
movslq %edx,%rdx
mov (%rcx,%rdx,4),%edx
add $0x2,%edx
mov %edx,(%rsi)
jmp 1729 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b9>
add $0x1,%r9
cmp %r13,%r9
jne 16d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x160>
mov 0x8(%rsp),%rbx
movslq 0x1c(%rsp),%rdx
mov (%r12),%rax
mov (%rax,%rdx,4),%r13d
cmp %r12,%rbx
je 17a7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x237>
mov %r12,%rbp
nopw 0x0(%rax,%rax,1)
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 17c8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x258>
callq 11e0 <_ZdlPv@plt>
add $0x18,%rbp
cmp %rbx,%rbp
jne 1790 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x220>
mov %r12,%rdi
callq 11e0 <_ZdlPv@plt>
add $0x28,%rsp
mov %r13d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
add $0x18,%rbp
cmp %rbp,%rbx
jne 1790 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x220>
jmp 17a7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x237>
nopl 0x0(%rax,%rax,1)
mov %esi,%esi
mov %r12,%rcx
mov $0x4,%edx
lea 0x1(%rax,%rsi,1),%r14
mov %r15d,%esi
sub %eax,%esi
add %esi,%r11d
jmp 1827 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b7>
nopl 0x0(%rax)
mov 0x18(%rcx),%rdi
lea (%r11,%rax,1),%r10d
movslq %r10d,%r10
mov (%rdi,%rdx,1),%edi
cmp %edi,(%rsi,%r10,4)
cmovge (%rsi,%r10,4),%edi
mov %edi,(%r8)
add $0x1,%rax
add $0x18,%rcx
add $0x4,%rdx
cmp %r14,%rax
je 1760 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f0>
mov (%rcx),%rsi
movzbl 0x1(%rax),%edi
lea (%rsi,%rdx,1),%r8
cmp %dil,(%rax)
jne 17f8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x288>
movl $0x2,(%r8)
jmp 1812 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2a2>
add %r12,%rbx
mov %r12,%r13
test %rbp,%rbp
je 1884 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x314>
nopl 0x0(%rax,%rax,1)
pxor %xmm2,%xmm2
mov %rbp,0x10(%r13)
mov %rbp,%rdx
mov %r14,%rsi
movups %xmm2,0x0(%r13)
xor %edi,%edi
add $0x18,%r13
movq $0x0,-0x18(%r13)
callq 11c0 <memcpy@plt>
mov %rbp,-0x10(%r13)
cmp %rbx,%r13
jne 1850 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2e0>
jmpq 164e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xde>
mov %r12,%rax
nopw 0x0(%rax,%rax,1)
movq $0x0,(%rax)
add $0x18,%rax
movq $0x0,-0x8(%rax)
movq $0x0,-0x10(%rax)
cmp %rbx,%rax
jne 1890 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x320>
jmpq 164e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xde>
mov 0x8(%rsp),%eax
mov 0x0,%rdx
xor %r12d,%r12d
sub $0x1,%eax
cltq
mov (%rdx,%rax,4),%r13d
jmpq 17a7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x237>
mov 0x8(%rsp),%rax
sub $0x1,%eax
mov %eax,0x1c(%rsp)
jmpq 1697 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
lea 0x71e(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
movq $0x0,0x10(%r12)
pxor %xmm0,%xmm0
movups %xmm0,(%r12)
callq 1150 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbp
jmpq 1275 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x15>
endbr64
mov %rax,%rdi
jmpq 1288 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x28>
endbr64
mov %rax,%rdi
jmpq 1285 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x25>
nopw 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbx, [rdi+8]
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movsxd rbp, ebx
mov rax, rbp
shr rax, 3Dh
jnz loc_17EE
lea rax, [rbp+rbp*2+0]
pxor xmm0, xmm0
shl rax, 3
movups [rsp+78h+var_58+8], xmm0
mov [rsp+78h+var_68], rax
test rbp, rbp
jz loc_17C0
lea r14, ds:0[rbp*4]
mov r12, rdi
mov rdi, r14; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r14; n
xor esi, esi; c
lea r15, [rax+r14]
mov rdi, rax; s
mov qword ptr [rsp+78h+var_58], rax
mov r13, rax
mov [rsp+78h+var_48], r15
call _memset
mov rdi, [rsp+78h+var_68]; unsigned __int64
mov qword ptr [rsp+78h+var_58+8], r15
call __Znwm; operator new(ulong)
lea rdx, [rsp+78h+var_58]
mov rsi, rbp
mov rdi, rax
mov r15, rax
mov [rsp+78h+var_78], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rdi, r13; void *
mov rsi, r14; unsigned __int64
mov rbp, rax
call __ZdlPvm; operator delete(void *,ulong)
lea edx, [rbx-1]
mov edi, ebx
mov rcx, r15
mov rax, rdx
lea r8, ds:4[rdx*4]
xor edx, edx
loc_15E0:
mov rsi, [rcx]
add rcx, 18h
mov dword ptr [rsi+rdx], 1
add rdx, 4
cmp rdx, r8
jnz short loc_15E0
cmp ebx, 1
jz loc_16D1
mov r8, [r12]
sub edi, 2
mov [rsp+78h+var_60], rbp
sub ebx, 2
mov r11d, 2
mov r13d, 4
sub edi, r8d
lea r9, [r8+1]
mov rdx, r8
mov r8d, eax
mov r10d, edi
nop dword ptr [rax+rax+00h]
loc_1630:
cmp r11, 2
jz loc_1750
mov r14d, ebx
mov [rsp+78h+var_78], r13
mov rax, rdx
lea edi, [r11-2]
mov dword ptr [rsp+78h+var_70], ebx
lea rcx, [r15+18h]
add r14, r9
mov rsi, r13
jmp short loc_168B
loc_1660:
mov rbx, [rcx]
movsxd r12, edi
mov ebp, [rbp+r12*4+0]
mov ebx, [rbx+rsi]
cmp ebx, ebp
cmovl ebx, ebp
loc_1673:
add rax, 1
mov [r13+0], ebx
add rsi, 4
add edi, 1
add rcx, 18h
cmp r14, rax
jz short loc_16B0
loc_168B:
mov rbp, [rcx-18h]
movzx ebx, byte ptr [rax]
lea r13, [rbp+rsi+0]
cmp [r11+rax-1], bl
jnz short loc_1660
mov rbp, [rcx]
movsxd rbx, edi
mov ebx, [rbp+rbx*4+0]
add ebx, 2
jmp short loc_1673
loc_16B0:
mov r13, [rsp+78h+var_78]
mov ebx, dword ptr [rsp+78h+var_70]
loc_16B8:
add r13, 4
add r11, 1
sub ebx, 1
jnb loc_1630
mov rbp, [rsp+78h+var_60]
mov eax, r8d
loc_16D1:
mov rdx, [r15]
cdqe
mov r12d, [rdx+rax*4]
cmp rbp, r15
jz short loc_1705
mov rbx, r15
nop word ptr [rax+rax+00h]
loc_16E8:
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_1740
mov rsi, [rbx+10h]
add rbx, 18h
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
cmp rbx, rbp
jnz short loc_16E8
loc_1705:
mov rsi, [rsp+78h+var_68]; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz loc_180A
add rsp, 48h
mov eax, r12d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1740:
add rbx, 18h
cmp rbp, rbx
jnz short loc_16E8
jmp short loc_1705
loc_1750:
mov [rsp+78h+var_78], r13
mov ebp, ebx
mov r12d, r10d
mov rsi, r13
mov [rsp+78h+var_70], rdx
add rbp, r9
mov rcx, r15
mov rax, rdx
sub r12d, ebx
nop dword ptr [rax]
loc_1770:
mov r14, [rcx]
movzx edx, byte ptr [rax+1]
mov edi, 2
lea r13, [r14+rsi]
cmp [rax], dl
jz short loc_179D
mov rdx, [rcx+18h]
lea edi, [r12+rax]
movsxd rdi, edi
mov r14d, [r14+rdi*4]
mov edi, [rdx+rsi]
cmp r14d, edi
cmovge edi, r14d
loc_179D:
add rax, 1
mov [r13+0], edi
add rcx, 18h
add rsi, 4
cmp rax, rbp
jnz short loc_1770
mov r13, [rsp+78h+var_78]
mov rdx, [rsp+78h+var_70]
jmp loc_16B8
loc_17C0:
lea rdx, [rsp+78h+var_58]
xor esi, esi
xor edi, edi
movaps [rsp+78h+var_58], xmm0
mov [rsp+78h+var_48], 0
mov [rsp+78h+var_78], rdx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
mov rbp, rax
xor r15d, r15d
lea eax, [rbx-1]
jmp loc_16D1
loc_17EE:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_180A
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_180A:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
lea rax, [rsp+arg_18]
mov [rsp+0], rax
jmp loc_1292
endbr64
mov rbx, rax
jmp loc_1292 | long long func0(_QWORD *a1)
{
long long v1; // rbx
void *v3; // r13
long long *v4; // r15
long long v5; // rbp
int v6; // edi
long long *v7; // rcx
long long v8; // rax
long long v9; // rdx
long long v10; // rsi
unsigned int v11; // ebx
long long v12; // r11
long long v13; // r13
long long v14; // r9
_BYTE *v15; // rdx
int v16; // r8d
int v17; // r10d
_BYTE *v18; // rax
int v19; // edi
_QWORD *v20; // rcx
_BYTE *v21; // r14
long long v22; // rsi
int v23; // ebp
int v24; // ebx
long long v25; // rbp
int *v26; // r13
unsigned int v28; // r12d
void **v29; // rbx
void *v30; // rdi
_BYTE *v31; // rsi
long long v33; // rsi
long long *v34; // rcx
_BYTE *v35; // rax
int v36; // edi
long long v37; // [rsp+0h] [rbp-78h]
unsigned int v38; // [rsp+8h] [rbp-70h]
long long v39; // [rsp+10h] [rbp-68h]
long long v40; // [rsp+18h] [rbp-60h]
v1 = a1[1];
if ( (unsigned long long)(int)v1 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v39 = 24LL * (int)v1;
if ( (_DWORD)v1 )
{
v3 = (void *)operator new(4LL * (int)v1);
memset(v3, 0, 4LL * (int)v1);
v4 = (long long *)operator new(v39);
v5 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v4, (int)v1);
operator delete(v3, 4LL * (int)v1);
v6 = v1;
v7 = v4;
v8 = (unsigned int)(v1 - 1);
v9 = 0LL;
do
{
v10 = *v7;
v7 += 3;
*(_DWORD *)(v10 + v9) = 1;
v9 += 4LL;
}
while ( v9 != 4 * v8 + 4 );
if ( (_DWORD)v1 != 1 )
{
v40 = v5;
v11 = v1 - 2;
v12 = 2LL;
v13 = 4LL;
v14 = *a1 + 1LL;
v15 = (_BYTE *)*a1;
v16 = v8;
v17 = v6 - 2 - *a1;
do
{
if ( v12 == 2 )
{
v33 = v13;
v34 = v4;
v35 = v15;
do
{
v36 = 2;
if ( *v35 != v35[1] )
{
v36 = *(_DWORD *)(v34[3] + v33);
if ( *(_DWORD *)(*v34 + 4LL * (int)(v17 - v11 + (_DWORD)v35)) >= v36 )
v36 = *(_DWORD *)(*v34 + 4LL * (int)(v17 - v11 + (_DWORD)v35));
}
++v35;
*(_DWORD *)(*v34 + v33) = v36;
v34 += 3;
v33 += 4LL;
}
while ( v35 != (_BYTE *)(v14 + v11) );
}
else
{
v37 = v13;
v18 = v15;
v19 = v12 - 2;
v38 = v11;
v20 = v4 + 3;
v21 = (_BYTE *)(v14 + v11);
v22 = v13;
do
{
v25 = *(v20 - 3);
v26 = (int *)(v25 + v22);
if ( v18[v12 - 1] == *v18 )
{
v24 = *(_DWORD *)(*v20 + 4LL * v19) + 2;
}
else
{
v23 = *(_DWORD *)(v25 + 4LL * v19);
v24 = *(_DWORD *)(*v20 + v22);
if ( v24 < v23 )
v24 = v23;
}
++v18;
*v26 = v24;
v22 += 4LL;
++v19;
v20 += 3;
}
while ( v21 != v18 );
v13 = v37;
v11 = v38;
}
v13 += 4LL;
++v12;
}
while ( v11-- != 0 );
v5 = v40;
LODWORD(v8) = v16;
}
}
else
{
v5 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(0LL, 0LL);
v4 = 0LL;
LODWORD(v8) = -1;
}
v28 = *(_DWORD *)(*v4 + 4LL * (int)v8);
if ( (long long *)v5 != v4 )
{
v29 = (void **)v4;
do
{
while ( 1 )
{
v30 = *v29;
if ( !*v29 )
break;
v31 = v29[2];
v29 += 3;
operator delete(v30, v31 - (_BYTE *)v30);
if ( v29 == (void **)v5 )
goto LABEL_21;
}
v29 += 3;
}
while ( (void **)v5 != v29 );
}
LABEL_21:
operator delete(v4, v39);
return v28;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RBX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVSXD RBP,EBX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x001017ee
LEA RAX,[RBP + RBP*0x2]
PXOR XMM0,XMM0
SHL RAX,0x3
MOVUPS xmmword ptr [RSP + 0x28],XMM0
MOV qword ptr [RSP + 0x10],RAX
TEST RBP,RBP
JZ 0x001017c0
LEA R14,[RBP*0x4]
MOV R12,RDI
MOV RDI,R14
LAB_00101574:
CALL 0x001011f0
MOV RDX,R14
XOR ESI,ESI
LEA R15,[RAX + R14*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x20],RAX
MOV R13,RAX
MOV qword ptr [RSP + 0x30],R15
CALL 0x001011a0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],R15
LAB_001015a1:
CALL 0x001011f0
LEA RDX,[RSP + 0x20]
MOV RSI,RBP
MOV RDI,RAX
MOV R15,RAX
MOV qword ptr [RSP],RDX
LAB_001015b8:
CALL 0x00101960
MOV RDI,R13
MOV RSI,R14
MOV RBP,RAX
CALL 0x00101200
LEA EDX,[RBX + -0x1]
MOV EDI,EBX
MOV RCX,R15
MOV RAX,RDX
LEA R8,[0x4 + RDX*0x4]
XOR EDX,EDX
LAB_001015e0:
MOV RSI,qword ptr [RCX]
ADD RCX,0x18
MOV dword ptr [RSI + RDX*0x1],0x1
ADD RDX,0x4
CMP RDX,R8
JNZ 0x001015e0
CMP EBX,0x1
JZ 0x001016d1
MOV R8,qword ptr [R12]
SUB EDI,0x2
MOV qword ptr [RSP + 0x18],RBP
SUB EBX,0x2
MOV R11D,0x2
MOV R13D,0x4
SUB EDI,R8D
LEA R9,[R8 + 0x1]
MOV RDX,R8
MOV R8D,EAX
MOV R10D,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101630:
CMP R11,0x2
JZ 0x00101750
MOV R14D,EBX
MOV qword ptr [RSP],R13
MOV RAX,RDX
LEA EDI,[R11 + -0x2]
MOV dword ptr [RSP + 0x8],EBX
LEA RCX,[R15 + 0x18]
ADD R14,R9
MOV RSI,R13
JMP 0x0010168b
LAB_00101660:
MOV RBX,qword ptr [RCX]
MOVSXD R12,EDI
MOV EBP,dword ptr [RBP + R12*0x4]
MOV EBX,dword ptr [RBX + RSI*0x1]
CMP EBX,EBP
CMOVL EBX,EBP
LAB_00101673:
ADD RAX,0x1
MOV dword ptr [R13],EBX
ADD RSI,0x4
ADD EDI,0x1
ADD RCX,0x18
CMP R14,RAX
JZ 0x001016b0
LAB_0010168b:
MOV RBP,qword ptr [RCX + -0x18]
MOVZX EBX,byte ptr [RAX]
LEA R13,[RBP + RSI*0x1]
CMP byte ptr [R11 + RAX*0x1 + -0x1],BL
JNZ 0x00101660
MOV RBP,qword ptr [RCX]
MOVSXD RBX,EDI
MOV EBX,dword ptr [RBP + RBX*0x4]
ADD EBX,0x2
JMP 0x00101673
LAB_001016b0:
MOV R13,qword ptr [RSP]
MOV EBX,dword ptr [RSP + 0x8]
LAB_001016b8:
ADD R13,0x4
ADD R11,0x1
SUB EBX,0x1
JNC 0x00101630
MOV RBP,qword ptr [RSP + 0x18]
MOV EAX,R8D
LAB_001016d1:
MOV RDX,qword ptr [R15]
CDQE
MOV R12D,dword ptr [RDX + RAX*0x4]
CMP RBP,R15
JZ 0x00101705
MOV RBX,R15
NOP word ptr [RAX + RAX*0x1]
LAB_001016e8:
MOV RDI,qword ptr [RBX]
TEST RDI,RDI
JZ 0x00101740
MOV RSI,qword ptr [RBX + 0x10]
ADD RBX,0x18
SUB RSI,RDI
CALL 0x00101200
CMP RBX,RBP
JNZ 0x001016e8
LAB_00101705:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,R15
CALL 0x00101200
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010180a
ADD RSP,0x48
MOV EAX,R12D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101740:
ADD RBX,0x18
CMP RBP,RBX
JNZ 0x001016e8
JMP 0x00101705
LAB_00101750:
MOV qword ptr [RSP],R13
MOV EBP,EBX
MOV R12D,R10D
MOV RSI,R13
MOV qword ptr [RSP + 0x8],RDX
ADD RBP,R9
MOV RCX,R15
MOV RAX,RDX
SUB R12D,EBX
NOP dword ptr [RAX]
LAB_00101770:
MOV R14,qword ptr [RCX]
MOVZX EDX,byte ptr [RAX + 0x1]
MOV EDI,0x2
LEA R13,[R14 + RSI*0x1]
CMP byte ptr [RAX],DL
JZ 0x0010179d
MOV RDX,qword ptr [RCX + 0x18]
LEA EDI,[R12 + RAX*0x1]
MOVSXD RDI,EDI
MOV R14D,dword ptr [R14 + RDI*0x4]
MOV EDI,dword ptr [RDX + RSI*0x1]
CMP R14D,EDI
CMOVGE EDI,R14D
LAB_0010179d:
ADD RAX,0x1
MOV dword ptr [R13],EDI
ADD RCX,0x18
ADD RSI,0x4
CMP RAX,RBP
JNZ 0x00101770
MOV R13,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
JMP 0x001016b8
LAB_001017c0:
LEA RDX,[RSP + 0x20]
XOR ESI,ESI
XOR EDI,EDI
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP],RDX
LAB_001017db:
CALL 0x00101960
MOV RBP,RAX
XOR R15D,R15D
LEA EAX,[RBX + -0x1]
JMP 0x001016d1
LAB_001017ee:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010180a
LEA RDI,[0x102040]
LAB_00101805:
CALL 0x00101190
LAB_0010180a:
CALL 0x00101210 | /* func0(std::string const&) */
int4 func0(string *param_1)
{
ulong __n;
int iVar1;
int4 uVar2;
char *pcVar3;
void *pvVar4;
vector *pvVar5;
vector *pvVar6;
char *pcVar7;
vector *pvVar8;
vector *pvVar9;
long lVar10;
int iVar11;
uint uVar12;
int iVar13;
ulong uVar14;
long lVar15;
int iVar16;
long lVar17;
long in_FS_OFFSET;
bool bVar18;
void *local_58;
void *pvStack_50;
void *pvStack_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
iVar11 = (int)*(int8 *)(param_1 + 8);
uVar14 = (ulong)iVar11;
if (uVar14 >> 0x3d == 0) {
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
if (uVar14 == 0) {
local_58 = (void *)0x0;
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
/* try { // try from 001017db to 001017df has its CatchHandler @ 00101830 */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
((vector *)0x0,0,(vector *)&local_58);
pvVar5 = (vector *)0x0;
}
else {
__n = uVar14 * 4;
pvVar4 = operator_new(__n);
local_58 = pvVar4;
pvStack_48 = (void *)((long)pvVar4 + __n);
memset(pvVar4,0,__n);
pvStack_50 = (void *)((long)pvVar4 + __n);
/* try { // try from 001015a1 to 001015a5 has its CatchHandler @ 0010181b */
pvVar5 = (vector *)operator_new(uVar14 * 0x18);
/* try { // try from 001015b8 to 001015bc has its CatchHandler @ 0010180f */
pvVar6 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar5,uVar14,(vector *)&local_58);
operator_delete(pvVar4,__n);
lVar10 = 0;
pvVar8 = pvVar5;
do {
lVar17 = *(long *)pvVar8;
pvVar8 = pvVar8 + 0x18;
*(int4 *)(lVar17 + lVar10) = 1;
lVar10 = lVar10 + 4;
} while (lVar10 != (ulong)(iVar11 - 1) * 4 + 4);
if (iVar11 != 1) {
pcVar3 = *(char **)param_1;
uVar12 = iVar11 - 2;
lVar10 = 2;
lVar17 = 4;
do {
if (lVar10 == 2) {
pcVar7 = pcVar3;
pvVar8 = pvVar5;
lVar15 = lVar17;
do {
iVar16 = 2;
if (*pcVar7 != pcVar7[1]) {
iVar1 = *(int *)(*(long *)pvVar8 +
(long)(int)((((iVar11 + -2) - (int)pcVar3) - uVar12) + (int)pcVar7)
* 4);
iVar16 = *(int *)(*(long *)(pvVar8 + 0x18) + lVar15);
if (*(int *)(*(long *)(pvVar8 + 0x18) + lVar15) <= iVar1) {
iVar16 = iVar1;
}
}
pcVar7 = pcVar7 + 1;
*(int *)(*(long *)pvVar8 + lVar15) = iVar16;
pvVar8 = pvVar8 + 0x18;
lVar15 = lVar15 + 4;
} while (pcVar7 != pcVar3 + (ulong)uVar12 + 1);
}
else {
iVar16 = (int)lVar10 + -2;
pcVar7 = pcVar3;
lVar15 = lVar17;
pvVar8 = pvVar5;
do {
pvVar9 = pvVar8 + 0x18;
if (pcVar7[lVar10 + -1] == *pcVar7) {
iVar13 = *(int *)(*(long *)pvVar9 + (long)iVar16 * 4) + 2;
}
else {
iVar1 = *(int *)(*(long *)pvVar8 + (long)iVar16 * 4);
iVar13 = *(int *)(*(long *)pvVar9 + lVar15);
if (*(int *)(*(long *)pvVar9 + lVar15) < iVar1) {
iVar13 = iVar1;
}
}
pcVar7 = pcVar7 + 1;
*(int *)(*(long *)pvVar8 + lVar15) = iVar13;
lVar15 = lVar15 + 4;
iVar16 = iVar16 + 1;
pvVar8 = pvVar9;
} while (pcVar3 + (ulong)uVar12 + 1 != pcVar7);
}
lVar17 = lVar17 + 4;
lVar10 = lVar10 + 1;
bVar18 = uVar12 != 0;
uVar12 = uVar12 - 1;
} while (bVar18);
}
}
uVar2 = *(int4 *)(*(long *)pvVar5 + (long)(iVar11 + -1) * 4);
for (pvVar8 = pvVar5; pvVar6 != pvVar8; pvVar8 = pvVar8 + 0x18) {
while (pvVar4 = *(void **)pvVar8, pvVar4 == (void *)0x0) {
pvVar8 = pvVar8 + 0x18;
if (pvVar6 == pvVar8) goto LAB_00101705;
}
operator_delete(pvVar4,*(long *)(pvVar8 + 0x10) - (long)pvVar4);
}
LAB_00101705:
operator_delete(pvVar5,uVar14 * 0x18);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return uVar2;
}
}
else if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
988 | func0 |
#include <assert.h>
#include <cmath>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(std::abs(func0(7) - 2.5928571428571425) < 1e-9);
assert(std::abs(func0(4) - 2.083333333333333) < 1e-9);
assert(std::abs(func0(19) - 3.547739657143682) < 1e-9);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jg 1168 <_Z5func0i+0x1f>
movsd 0xfaa(%rip),%xmm0
jmp 1190 <_Z5func0i+0x47>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd 0xf9b(%rip),%xmm0
divsd %xmm1,%xmm0
movsd %xmm0,-0x10(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <_Z5func0i>
addsd -0x10(%rbp),%xmm0
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp [rbp+var_4], 1
jg short loc_1168
movsd xmm0, cs:qword_20F0
jmp short locret_1194
loc_1168:
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd xmm0, cs:qword_20F0
divsd xmm0, xmm1
movsd [rbp+var_10], xmm0
mov eax, [rbp+var_4]
sub eax, 1
mov edi, eax; int
call _Z5func0i; func0(int)
addsd xmm0, [rbp+var_10]
locret_1194:
leave
retn | double func0(int a1)
{
double result; // xmm0_8
result = 1.0;
if ( a1 > 1 )
{
func0(a1 - 1);
return 1.0 / (double)a1 + 1.0 / (double)a1;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x1
JG 0x00101168
MOVSD XMM0,qword ptr [0x001020f0]
JMP 0x00101194
LAB_00101168:
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD XMM0,qword ptr [0x001020f0]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x10],XMM0
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
ADDSD XMM0,qword ptr [RBP + -0x10]
LAB_00101194:
LEAVE
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
dVar1 = DAT_001020f0;
if (1 < param_1) {
dVar1 = DAT_001020f0 / (double)param_1;
dVar2 = (double)func0(param_1 + -1);
dVar1 = dVar2 + dVar1;
}
return dVar1;
} |
989 | func0 |
#include <assert.h>
#include <cmath>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(std::abs(func0(7) - 2.5928571428571425) < 1e-9);
assert(std::abs(func0(4) - 2.083333333333333) < 1e-9);
assert(std::abs(func0(19) - 3.547739657143682) < 1e-9);
return 0;
}
| O1 | cpp | func0(int):
endbr64
movsd 0xf93(%rip),%xmm0
cmp $0x1,%edi
jle 1183 <_Z5func0i+0x3a>
push %rbx
mov %edi,%ebx
lea -0x1(%rdi),%edi
callq 1149 <_Z5func0i>
movapd %xmm0,%xmm2
pxor %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movsd 0xf6f(%rip),%xmm0
divsd %xmm1,%xmm0
addsd %xmm2,%xmm0
pop %rbx
retq
retq
| _Z5func0i:
endbr64
movsd xmm0, cs:qword_20C0
cmp edi, 1
jle short locret_118B
sub rsp, 18h
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
movsd xmm1, cs:qword_20C0
divsd xmm1, xmm0
movsd [rsp+18h+var_10], xmm1
sub edi, 1; int
call _Z5func0i; func0(int)
addsd xmm0, [rsp+18h+var_10]
add rsp, 18h
retn
locret_118B:
retn | double func0(int a1)
{
double result; // xmm0_8
result = 1.0;
if ( a1 > 1 )
{
func0(a1 - 1);
return (double)a1 + 1.0 / (double)a1;
}
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x001020c0]
CMP EDI,0x1
JLE 0x0010118b
SUB RSP,0x18
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MOVSD XMM1,qword ptr [0x001020c0]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
SUB EDI,0x1
CALL 0x00101149
ADDSD XMM0,qword ptr [RSP + 0x8]
ADD RSP,0x18
RET
LAB_0010118b:
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
if (1 < param_1) {
dVar2 = DAT_001020c0 / (double)param_1;
dVar1 = (double)func0(param_1 + -1);
return dVar1 + dVar2;
}
return DAT_001020c0;
} |
990 | func0 |
#include <assert.h>
#include <cmath>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(std::abs(func0(7) - 2.5928571428571425) < 1e-9);
assert(std::abs(func0(4) - 2.083333333333333) < 1e-9);
assert(std::abs(func0(19) - 3.547739657143682) < 1e-9);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 1260 <_Z5func0i+0x10>
jmp 1270 <_Z5func0i.part.0>
nopl 0x0(%rax,%rax,1)
movsd 0xe80(%rip),%xmm0
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
movsd xmm0, cs:qword_20C0
cmp edi, 1
jle locret_1348
pxor xmm1, xmm1
movapd xmm3, xmm0
lea eax, [rdi-1]
cvtsi2sd xmm1, edi
divsd xmm3, xmm1
movapd xmm1, xmm0
cmp edi, 2
jz loc_133C
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
lea eax, [rdi-2]
divsd xmm1, xmm2
movapd xmm2, xmm0
cmp edi, 3
jz loc_1338
pxor xmm4, xmm4
cvtsi2sd xmm4, eax
lea eax, [rdi-3]
divsd xmm2, xmm4
movapd xmm4, xmm0
cmp edi, 4
jz loc_1334
pxor xmm5, xmm5
cvtsi2sd xmm5, eax
lea eax, [rdi-4]
divsd xmm4, xmm5
cmp edi, 5
jz short loc_1330
pxor xmm5, xmm5
sub rsp, 38h
sub edi, 5; int
cvtsi2sd xmm5, eax
movsd [rsp+38h+var_10], xmm4
movsd [rsp+38h+var_18], xmm2
movsd [rsp+38h+var_20], xmm1
movsd [rsp+38h+var_28], xmm3
divsd xmm0, xmm5
movsd [rsp+38h+var_30], xmm0
call _Z5func0i; func0(int)
addsd xmm0, [rsp+38h+var_30]
movsd xmm4, [rsp+38h+var_10]
movsd xmm2, [rsp+38h+var_18]
movsd xmm1, [rsp+38h+var_20]
movsd xmm3, [rsp+38h+var_28]
add rsp, 38h
addsd xmm4, xmm0
addsd xmm2, xmm4
addsd xmm1, xmm2
addsd xmm3, xmm1
movapd xmm0, xmm3
retn
loc_1330:
addsd xmm4, xmm0
loc_1334:
addsd xmm2, xmm4
loc_1338:
addsd xmm1, xmm2
loc_133C:
addsd xmm3, xmm1
movapd xmm0, xmm3
retn
locret_1348:
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
__int128 result; // xmm0
__int128 v2; // xmm3
double v3; // xmm1_8
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm2_8
double v7; // xmm4_8
double v8; // xmm5_8
double v9; // xmm0_8
double v10; // [rsp+20h] [rbp-10h]
result = 0x3FF0000000000000uLL;
if ( a1 > 1 )
{
*((_QWORD *)&v2 + 1) = 0LL;
*(double *)&v2 = 1.0 / (double)a1;
v3 = 1.0;
if ( a1 != 2 )
{
v4 = 1.0 / (double)(a1 - 1);
v5 = 1.0;
if ( a1 != 3 )
{
v6 = 1.0 / (double)(a1 - 2);
v7 = 1.0;
if ( a1 != 4 )
{
v8 = (double)(a1 - 3);
if ( a1 != 5 )
{
v10 = 1.0 / v8;
v9 = 1.0 / (double)(a1 - 4);
func0(a1 - 5);
v2 = (unsigned long long)v2;
*(double *)&v2 = *(double *)&v2 + v4 + v6 + v10 + v9 + v9;
return v2;
}
v7 = 1.0 / v8 + 1.0;
}
v5 = v6 + v7;
}
v3 = v4 + v5;
}
*(double *)&v2 = *(double *)&v2 + v3;
return v2;
}
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x001020c0]
CMP EDI,0x1
JLE 0x00101348
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
LEA EAX,[RDI + -0x1]
CVTSI2SD XMM1,EDI
DIVSD XMM3,XMM1
MOVAPD XMM1,XMM0
CMP EDI,0x2
JZ 0x0010133c
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
LEA EAX,[RDI + -0x2]
DIVSD XMM1,XMM2
MOVAPD XMM2,XMM0
CMP EDI,0x3
JZ 0x00101338
PXOR XMM4,XMM4
CVTSI2SD XMM4,EAX
LEA EAX,[RDI + -0x3]
DIVSD XMM2,XMM4
MOVAPD XMM4,XMM0
CMP EDI,0x4
JZ 0x00101334
PXOR XMM5,XMM5
CVTSI2SD XMM5,EAX
LEA EAX,[RDI + -0x4]
DIVSD XMM4,XMM5
CMP EDI,0x5
JZ 0x00101330
PXOR XMM5,XMM5
SUB RSP,0x38
SUB EDI,0x5
CVTSI2SD XMM5,EAX
MOVSD qword ptr [RSP + 0x28],XMM4
MOVSD qword ptr [RSP + 0x20],XMM2
MOVSD qword ptr [RSP + 0x18],XMM1
MOVSD qword ptr [RSP + 0x10],XMM3
DIVSD XMM0,XMM5
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x00101240
ADDSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM4,qword ptr [RSP + 0x28]
MOVSD XMM2,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RSP + 0x10]
ADD RSP,0x38
ADDSD XMM4,XMM0
ADDSD XMM2,XMM4
ADDSD XMM1,XMM2
ADDSD XMM3,XMM1
MOVAPD XMM0,XMM3
RET
LAB_00101330:
ADDSD XMM4,XMM0
LAB_00101334:
ADDSD XMM2,XMM4
LAB_00101338:
ADDSD XMM1,XMM2
LAB_0010133c:
ADDSD XMM3,XMM1
MOVAPD XMM0,XMM3
RET
LAB_00101348:
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_1 < 2) {
return DAT_001020c0;
}
dVar5 = DAT_001020c0 / (double)param_1;
dVar3 = DAT_001020c0;
if (param_1 != 2) {
dVar3 = DAT_001020c0 / (double)(param_1 + -1);
dVar4 = DAT_001020c0;
if (param_1 != 3) {
dVar4 = DAT_001020c0 / (double)(param_1 + -2);
dVar6 = DAT_001020c0;
if (param_1 != 4) {
dVar6 = DAT_001020c0 / (double)(param_1 + -3);
if (param_1 != 5) {
dVar1 = DAT_001020c0 / (double)(param_1 + -4);
dVar2 = (double)func0(param_1 + -5);
return dVar5 + dVar3 + dVar4 + dVar6 + dVar2 + dVar1;
}
dVar6 = dVar6 + DAT_001020c0;
}
dVar4 = dVar4 + dVar6;
}
dVar3 = dVar3 + dVar4;
}
return dVar5 + dVar3;
} |
991 | func0 |
#include <assert.h>
#include <cmath>
| double func0(int n) {
if (n < 2) {
return 1;
} else {
return 1.0 / n + func0(n - 1);
}
}
| int main() {
assert(std::abs(func0(7) - 2.5928571428571425) < 1e-9);
assert(std::abs(func0(4) - 2.083333333333333) < 1e-9);
assert(std::abs(func0(19) - 3.547739657143682) < 1e-9);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movsd 0xe9c(%rip),%xmm1
cmp $0x1,%edi
jle 1290 <_Z5func0i+0x50>
push %rbx
mov %edi,%ebx
lea -0x1(%rdi),%edi
sub $0x10,%rsp
movsd %xmm1,0x8(%rsp)
callq 1240 <_Z5func0i>
movsd 0x8(%rsp),%xmm1
add $0x10,%rsp
movapd %xmm0,%xmm2
pxor %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
pop %rbx
divsd %xmm0,%xmm1
addsd %xmm2,%xmm1
movapd %xmm1,%xmm0
retq
nopw 0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
retq
data16 nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
movsd xmm0, cs:qword_20C8
cmp edi, 1
jle locret_1348
pxor xmm1, xmm1
movapd xmm3, xmm0
lea eax, [rdi-1]
cvtsi2sd xmm1, edi
divsd xmm3, xmm1
movapd xmm1, xmm0
cmp edi, 2
jz loc_133C
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
lea eax, [rdi-2]
divsd xmm1, xmm2
movapd xmm2, xmm0
cmp edi, 3
jz loc_1338
pxor xmm4, xmm4
cvtsi2sd xmm4, eax
lea eax, [rdi-3]
divsd xmm2, xmm4
movapd xmm4, xmm0
cmp edi, 4
jz loc_1334
pxor xmm5, xmm5
cvtsi2sd xmm5, eax
lea eax, [rdi-4]
divsd xmm4, xmm5
cmp edi, 5
jz short loc_1330
pxor xmm5, xmm5
sub rsp, 38h
sub edi, 5; int
cvtsi2sd xmm5, eax
movsd [rsp+38h+var_10], xmm4
movsd [rsp+38h+var_18], xmm2
movsd [rsp+38h+var_20], xmm1
movsd [rsp+38h+var_28], xmm3
divsd xmm0, xmm5
movsd [rsp+38h+var_30], xmm0
call _Z5func0i; func0(int)
addsd xmm0, [rsp+38h+var_30]
movsd xmm4, [rsp+38h+var_10]
movsd xmm2, [rsp+38h+var_18]
movsd xmm1, [rsp+38h+var_20]
movsd xmm3, [rsp+38h+var_28]
add rsp, 38h
addsd xmm4, xmm0
addsd xmm2, xmm4
addsd xmm1, xmm2
addsd xmm3, xmm1
movapd xmm0, xmm3
retn
loc_1330:
addsd xmm4, xmm0
loc_1334:
addsd xmm2, xmm4
loc_1338:
addsd xmm1, xmm2
loc_133C:
addsd xmm3, xmm1
movapd xmm0, xmm3
retn
locret_1348:
retn | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
__int128 result; // xmm0
__int128 v2; // xmm3
double v3; // xmm1_8
double v4; // xmm1_8
double v5; // xmm2_8
double v6; // xmm2_8
double v7; // xmm4_8
double v8; // xmm5_8
double v9; // xmm0_8
double v10; // [rsp+20h] [rbp-10h]
result = 0x3FF0000000000000uLL;
if ( a1 > 1 )
{
*((_QWORD *)&v2 + 1) = 0LL;
*(double *)&v2 = 1.0 / (double)a1;
v3 = 1.0;
if ( a1 != 2 )
{
v4 = 1.0 / (double)(a1 - 1);
v5 = 1.0;
if ( a1 != 3 )
{
v6 = 1.0 / (double)(a1 - 2);
v7 = 1.0;
if ( a1 != 4 )
{
v8 = (double)(a1 - 3);
if ( a1 != 5 )
{
v10 = 1.0 / v8;
v9 = 1.0 / (double)(a1 - 4);
func0(a1 - 5);
v2 = (unsigned long long)v2;
*(double *)&v2 = *(double *)&v2 + v4 + v6 + v10 + v9 + v9;
return v2;
}
v7 = 1.0 / v8 + 1.0;
}
v5 = v6 + v7;
}
v3 = v4 + v5;
}
*(double *)&v2 = *(double *)&v2 + v3;
return v2;
}
return result;
} | func0:
ENDBR64
MOVSD XMM0,qword ptr [0x001020c8]
CMP EDI,0x1
JLE 0x00101348
PXOR XMM1,XMM1
MOVAPD XMM3,XMM0
LEA EAX,[RDI + -0x1]
CVTSI2SD XMM1,EDI
DIVSD XMM3,XMM1
MOVAPD XMM1,XMM0
CMP EDI,0x2
JZ 0x0010133c
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
LEA EAX,[RDI + -0x2]
DIVSD XMM1,XMM2
MOVAPD XMM2,XMM0
CMP EDI,0x3
JZ 0x00101338
PXOR XMM4,XMM4
CVTSI2SD XMM4,EAX
LEA EAX,[RDI + -0x3]
DIVSD XMM2,XMM4
MOVAPD XMM4,XMM0
CMP EDI,0x4
JZ 0x00101334
PXOR XMM5,XMM5
CVTSI2SD XMM5,EAX
LEA EAX,[RDI + -0x4]
DIVSD XMM4,XMM5
CMP EDI,0x5
JZ 0x00101330
PXOR XMM5,XMM5
SUB RSP,0x38
SUB EDI,0x5
CVTSI2SD XMM5,EAX
MOVSD qword ptr [RSP + 0x28],XMM4
MOVSD qword ptr [RSP + 0x20],XMM2
MOVSD qword ptr [RSP + 0x18],XMM1
MOVSD qword ptr [RSP + 0x10],XMM3
DIVSD XMM0,XMM5
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x00101240
ADDSD XMM0,qword ptr [RSP + 0x8]
MOVSD XMM4,qword ptr [RSP + 0x28]
MOVSD XMM2,qword ptr [RSP + 0x20]
MOVSD XMM1,qword ptr [RSP + 0x18]
MOVSD XMM3,qword ptr [RSP + 0x10]
ADD RSP,0x38
ADDSD XMM4,XMM0
ADDSD XMM2,XMM4
ADDSD XMM1,XMM2
ADDSD XMM3,XMM1
MOVAPD XMM0,XMM3
RET
LAB_00101330:
ADDSD XMM4,XMM0
LAB_00101334:
ADDSD XMM2,XMM4
LAB_00101338:
ADDSD XMM1,XMM2
LAB_0010133c:
ADDSD XMM3,XMM1
MOVAPD XMM0,XMM3
RET
LAB_00101348:
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
if (param_1 < 2) {
return DAT_001020c8;
}
dVar5 = DAT_001020c8 / (double)param_1;
dVar3 = DAT_001020c8;
if (param_1 != 2) {
dVar3 = DAT_001020c8 / (double)(param_1 + -1);
dVar4 = DAT_001020c8;
if (param_1 != 3) {
dVar4 = DAT_001020c8 / (double)(param_1 + -2);
dVar6 = DAT_001020c8;
if (param_1 != 4) {
dVar6 = DAT_001020c8 / (double)(param_1 + -3);
if (param_1 != 5) {
dVar1 = DAT_001020c8 / (double)(param_1 + -4);
dVar2 = (double)func0(param_1 + -5);
return dVar5 + dVar3 + dVar4 + dVar6 + dVar2 + dVar1;
}
dVar6 = dVar6 + DAT_001020c8;
}
dVar4 = dVar4 + dVar6;
}
dVar3 = dVar3 + dVar4;
}
return dVar5 + dVar3;
} |
992 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& array_nums1, const std::vector<int>& array_nums2) {
std::vector<int> result;
for (auto num : array_nums2) {
if (std::find(array_nums1.begin(), array_nums1.end(), num) != array_nums1.end()) {
result.push_back(num);
}
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {1, 2, 4, 8, 9}) == std::vector<int>{1, 2, 8, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {3, 5, 7, 9}) == std::vector<int>{3, 5, 7, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {10, 20, 30, 40}) == std::vector<int>{10}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %rdx,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 1cf6 <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x68(%rbp),%rax
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1e2a <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x40(%rbp)
mov -0x20(%rbp),%rax
mov %rax,%rdi
callq 1e82 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x38(%rbp)
lea -0x38(%rbp),%rdx
lea -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1eda <_ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_>
test %al,%al
je 136e <_Z5func0RKSt6vectorIiSaIiEES3_+0x125>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 1f3e <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x44(%rbp)
mov -0x60(%rbp),%rax
mov %rax,%rdi
callq 1e82 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x28(%rbp)
mov -0x60(%rbp),%rax
mov %rax,%rdi
callq 1e82 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x60(%rbp),%rax
mov %rax,%rdi
callq 1e2a <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,%rcx
lea -0x44(%rbp),%rax
mov %rax,%rdx
mov %rbx,%rsi
mov %rcx,%rdi
callq 1f53 <_ZSt4findIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET_S8_S8_RKT0_>
mov %rax,-0x30(%rbp)
lea -0x28(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1eda <_ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_>
test %al,%al
je 133f <_Z5func0RKSt6vectorIiSaIiEES3_+0xf6>
lea -0x44(%rbp),%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1f90 <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 1f1a <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv>
jmpq 12a5 <_Z5func0RKSt6vectorIiSaIiEES3_+0x5c>
endbr64
mov %rax,%rbx
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 1de2 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1383 <_Z5func0RKSt6vectorIiSaIiEES3_+0x13a>
callq 1130 <__stack_chk_fail@plt>
mov -0x58(%rbp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+var_68]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_38], rax
jmp loc_1355
loc_12CA:
lea rax, [rbp+var_40]
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_44], eax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_28], rax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rcx, rax
lea rax, [rbp+var_44]
mov rdx, rax
mov rsi, rbx
mov rdi, rcx
call _ZSt4findIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET_S8_S8_RKT0_; std::find<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int const&)
mov [rbp+var_30], rax
lea rdx, [rbp+var_28]
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&)
test al, al
jz short loc_1349
lea rdx, [rbp+var_44]
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
loc_1349:
lea rax, [rbp+var_40]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(void)
loc_1355:
lea rdx, [rbp+var_38]
lea rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&)
test al, al
jnz loc_12CA
jmp short loc_13A4
endbr64
mov rbx, rax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_139C
call ___stack_chk_fail
loc_139C:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13A4:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_13B8
call ___stack_chk_fail
loc_13B8:
mov rax, [rbp+var_58]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
int v7; // [rsp+2Ch] [rbp-44h] BYREF
long long v8; // [rsp+30h] [rbp-40h] BYREF
long long v9; // [rsp+38h] [rbp-38h] BYREF
long long v10; // [rsp+40h] [rbp-30h] BYREF
_QWORD v11[4]; // [rsp+48h] [rbp-28h] BYREF
v11[2] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v11[1] = a3;
v8 = std::vector<int>::begin(a3);
v9 = std::vector<int>::end(a3);
while ( (unsigned __int8)__gnu_cxx::operator!=<int const*,std::vector<int>>(&v8, &v9) )
{
v7 = *(_DWORD *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(&v8);
v11[0] = std::vector<int>::end(a2);
v3 = std::vector<int>::end(a2);
v4 = std::vector<int>::begin(a2);
v10 = std::find<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int>(v4, v3, &v7);
if ( (unsigned __int8)__gnu_cxx::operator!=<int const*,std::vector<int>>(&v10, v11) )
std::vector<int>::push_back(a1, &v7);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(&v8);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
CALL 0x00101d64
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101e62
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,RAX
CALL 0x00101eae
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00101355
LAB_001012ca:
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101f62
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x00101eae
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x00101eae
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x00101e62
MOV RCX,RAX
LEA RAX,[RBP + -0x44]
MOV RDX,RAX
MOV RSI,RBX
MOV RDI,RCX
LAB_00101316:
CALL 0x00101f77
MOV qword ptr [RBP + -0x30],RAX
LEA RDX,[RBP + -0x28]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101efe
TEST AL,AL
JZ 0x00101349
LEA RDX,[RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101fb4
LAB_00101349:
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101f3e
LAB_00101355:
LEA RDX,[RBP + -0x38]
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101efe
TEST AL,AL
JNZ 0x001012ca
JMP 0x001013a4
LAB_001013a4:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001013b8
CALL 0x00101150
LAB_001013b8:
MOV RAX,qword ptr [RBP + -0x58]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
bool bVar1;
int *piVar2;
int8 uVar3;
int8 uVar4;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int local_4c;
int8 local_48;
int8 local_40;
int8 local_38;
int8 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_28 = in_RDX;
local_48 = std::vector<int,std::allocator<int>>::begin(in_RDX);
local_40 = std::vector<int,std::allocator<int>>::end(local_28);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_48,(__normal_iterator *)&local_40);
if (!bVar1) break;
piVar2 = (int *)__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *
)&local_48);
local_4c = *piVar2;
local_30 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_2)
;
uVar3 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_2);
uVar4 = std::vector<int,std::allocator<int>>::begin((vector<int,std::allocator<int>> *)param_2);
/* try { // try from 00101316 to 00101348 has its CatchHandler @ 00101372 */
local_38 = std::find<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,int>
(uVar4,uVar3,&local_4c);
bVar1 = operator!=((__normal_iterator *)&local_38,(__normal_iterator *)&local_30);
if (bVar1) {
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_4c);
}
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_48);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
993 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& array_nums1, const std::vector<int>& array_nums2) {
std::vector<int> result;
for (auto num : array_nums2) {
if (std::find(array_nums1.begin(), array_nums1.end(), num) != array_nums1.end()) {
result.push_back(num);
}
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {1, 2, 4, 8, 9}) == std::vector<int>{1, 2, 8, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {3, 5, 7, 9}) == std::vector<int>{3, 5, 7, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {10, 20, 30, 40}) == std::vector<int>{10}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rdx),%rbx
mov 0x8(%rdx),%r13
cmp %r13,%rbx
je 1383 <_Z5func0RKSt6vectorIiSaIiEES3_+0x13a>
mov %rsi,%r12
lea 0x4(%rsp),%r14
jmp 12c8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x7f>
add $0x4,%rax
cmp %rsi,%rax
je 12bb <_Z5func0RKSt6vectorIiSaIiEES3_+0x72>
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 1356 <_Z5func0RKSt6vectorIiSaIiEES3_+0x10d>
mov %ecx,(%rsi)
addq $0x4,0x8(%rbp)
add $0x4,%rbx
cmp %rbx,%r13
je 1383 <_Z5func0RKSt6vectorIiSaIiEES3_+0x13a>
mov (%rbx),%ecx
mov %ecx,0x4(%rsp)
mov 0x8(%r12),%rsi
mov (%r12),%rax
mov %rsi,%rdx
sub %rax,%rdx
sar $0x4,%rdx
test %rdx,%rdx
jle 1309 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
shl $0x4,%rdx
add %rax,%rdx
cmp (%rax),%ecx
je 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
cmp 0x4(%rax),%ecx
je 129d <_Z5func0RKSt6vectorIiSaIiEES3_+0x54>
cmp 0x8(%rax),%ecx
je 132a <_Z5func0RKSt6vectorIiSaIiEES3_+0xe1>
cmp 0xc(%rax),%ecx
je 1333 <_Z5func0RKSt6vectorIiSaIiEES3_+0xea>
add $0x10,%rax
cmp %rdx,%rax
jne 12ed <_Z5func0RKSt6vectorIiSaIiEES3_+0xa4>
mov %rsi,%rdx
sub %rax,%rdx
cmp $0x8,%rdx
je 1348 <_Z5func0RKSt6vectorIiSaIiEES3_+0xff>
cmp $0xc,%rdx
je 133c <_Z5func0RKSt6vectorIiSaIiEES3_+0xf3>
cmp $0x4,%rdx
jne 12bb <_Z5func0RKSt6vectorIiSaIiEES3_+0x72>
cmp (%rax),%ecx
jne 12bb <_Z5func0RKSt6vectorIiSaIiEES3_+0x72>
jmpq 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
add $0x8,%rax
jmpq 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
add $0xc,%rax
jmpq 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
cmp (%rax),%ecx
je 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
add $0x4,%rax
cmp (%rax),%ecx
je 12a1 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
add $0x4,%rax
jmp 1321 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
mov %r14,%rdx
mov %rbp,%rdi
callq 1a62 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmpq 12bb <_Z5func0RKSt6vectorIiSaIiEES3_+0x72>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 137b <_Z5func0RKSt6vectorIiSaIiEES3_+0x132>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 13a3 <_Z5func0RKSt6vectorIiSaIiEES3_+0x15a>
mov %rbp,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r12, rsi
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, [rdx]
mov r13, [rdx+8]
cmp r13, rbx
jnz short loc_12D9
loc_1290:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz loc_13B9
mov rax, rbp
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12B2:
add rax, 4
loc_12B6:
cmp rax, rsi
jz short loc_12D0
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz loc_137B
mov [rsi], edx
add qword ptr [rbp+8], 4
loc_12D0:
add rbx, 4
cmp r13, rbx
jz short loc_1290
loc_12D9:
mov edx, [rbx]
mov [rsp+38h+var_34], edx
mov rsi, [r12+8]
mov rax, [r12]
mov rcx, rsi
sub rcx, rax
sar rcx, 4
test rcx, rcx
jle short loc_1346
shl rcx, 4
add rcx, rax
loc_12FE:
cmp edx, [rax]
jz short loc_12B6
cmp edx, [rax+4]
jz short loc_12B2
cmp edx, [rax+8]
jz short loc_1334
cmp edx, [rax+0Ch]
jz short loc_133D
add rax, 10h
cmp rax, rcx
jnz short loc_12FE
loc_131A:
mov rax, rsi
sub rax, rcx
cmp rax, 8
jz short loc_1353
cmp rax, 0Ch
jz short loc_134B
cmp rax, 4
jz short loc_135B
jmp short loc_12D0
loc_1334:
add rax, 8
jmp loc_12B6
loc_133D:
add rax, 0Ch
jmp loc_12B6
loc_1346:
mov rcx, rax
jmp short loc_131A
loc_134B:
cmp edx, [rcx]
jz short loc_136B
add rcx, 4
loc_1353:
cmp edx, [rcx]
jz short loc_1373
add rcx, 4
loc_135B:
mov rax, rcx
cmp edx, [rcx]
jnz loc_12D0
jmp loc_12B6
loc_136B:
mov rax, rcx
jmp loc_12B6
loc_1373:
mov rax, rcx
jmp loc_12B6
loc_137B:
lea rdx, [rsp+38h+var_34]
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&)
jmp loc_12D0
endbr64
mov rbx, rax
mov rdi, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_13B1
call ___stack_chk_fail
loc_13B1:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_13B9:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, char **a2, int **a3)
{
int *v4; // rbx
int *v5; // r13
char *v7; // rax
_DWORD *v8; // rsi
int v9; // edx
char *v10; // rsi
long long v11; // rcx
char *v12; // rcx
signed long long v13; // rax
int v14; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v15; // [rsp+8h] [rbp-30h]
v15 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a3;
v5 = a3[1];
if ( v5 != *a3 )
{
do
{
v9 = *v4;
v14 = *v4;
v10 = a2[1];
v7 = *a2;
v11 = (v10 - *a2) >> 4;
if ( v11 > 0 )
{
v12 = &v7[16 * v11];
while ( v9 != *(_DWORD *)v7 )
{
if ( v9 == *((_DWORD *)v7 + 1) )
{
v7 += 4;
goto LABEL_4;
}
if ( v9 == *((_DWORD *)v7 + 2) )
{
v7 += 8;
goto LABEL_4;
}
if ( v9 == *((_DWORD *)v7 + 3) )
{
v7 += 12;
goto LABEL_4;
}
v7 += 16;
if ( v7 == v12 )
goto LABEL_15;
}
goto LABEL_4;
}
v12 = *a2;
LABEL_15:
v13 = v10 - v12;
if ( v10 - v12 != 8 )
{
if ( v13 != 12 )
{
if ( v13 != 4 )
goto LABEL_7;
goto LABEL_26;
}
if ( v9 == *(_DWORD *)v12 )
{
v7 = v12;
goto LABEL_4;
}
v12 += 4;
}
if ( v9 == *(_DWORD *)v12 )
{
v7 = v12;
LABEL_4:
if ( v7 != v10 )
{
v8 = (_DWORD *)a1[1];
if ( v8 == (_DWORD *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v8, &v14, v12);
}
else
{
*v8 = v9;
a1[1] += 4LL;
}
}
goto LABEL_7;
}
v12 += 4;
LABEL_26:
v7 = v12;
if ( v9 == *(_DWORD *)v12 )
goto LABEL_4;
LABEL_7:
++v4;
}
while ( v5 != v4 );
}
return a1;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R12,RSI
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 [RDX]
MOV R13,qword ptr [RDX + 0x8]
CMP R13,RBX
JNZ 0x001012d9
LAB_00101290:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013b9
MOV RAX,RBP
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012b2:
ADD RAX,0x4
LAB_001012b6:
CMP RAX,RSI
JZ 0x001012d0
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x0010137b
MOV dword ptr [RSI],EDX
ADD qword ptr [RBP + 0x8],0x4
LAB_001012d0:
ADD RBX,0x4
CMP R13,RBX
JZ 0x00101290
LAB_001012d9:
MOV EDX,dword ptr [RBX]
MOV dword ptr [RSP + 0x4],EDX
MOV RSI,qword ptr [R12 + 0x8]
MOV RAX,qword ptr [R12]
MOV RCX,RSI
SUB RCX,RAX
SAR RCX,0x4
TEST RCX,RCX
JLE 0x00101346
SHL RCX,0x4
ADD RCX,RAX
LAB_001012fe:
CMP EDX,dword ptr [RAX]
JZ 0x001012b6
CMP EDX,dword ptr [RAX + 0x4]
JZ 0x001012b2
CMP EDX,dword ptr [RAX + 0x8]
JZ 0x00101334
CMP EDX,dword ptr [RAX + 0xc]
JZ 0x0010133d
ADD RAX,0x10
CMP RAX,RCX
JNZ 0x001012fe
LAB_0010131a:
MOV RAX,RSI
SUB RAX,RCX
CMP RAX,0x8
JZ 0x00101353
CMP RAX,0xc
JZ 0x0010134b
CMP RAX,0x4
JZ 0x0010135b
JMP 0x001012d0
LAB_00101334:
ADD RAX,0x8
JMP 0x001012b6
LAB_0010133d:
ADD RAX,0xc
JMP 0x001012b6
LAB_00101346:
MOV RCX,RAX
JMP 0x0010131a
LAB_0010134b:
CMP EDX,dword ptr [RCX]
JZ 0x0010136b
ADD RCX,0x4
LAB_00101353:
CMP EDX,dword ptr [RCX]
JZ 0x00101373
ADD RCX,0x4
LAB_0010135b:
MOV RAX,RCX
CMP EDX,dword ptr [RCX]
JNZ 0x001012d0
JMP 0x001012b6
LAB_0010136b:
MOV RAX,RCX
JMP 0x001012b6
LAB_00101373:
MOV RAX,RCX
JMP 0x001012b6
LAB_0010137b:
LEA RDX,[RSP + 0x4]
MOV RDI,RBP
LAB_00101383:
CALL 0x00101a94
JMP 0x001012d0
LAB_001013b9:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int *piVar5;
int8 *in_RDX;
int *piVar6;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
piVar6 = (int *)*in_RDX;
piVar1 = (int *)in_RDX[1];
do {
if (piVar1 == piVar6) {
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_34 = *piVar6;
piVar2 = *(int **)(param_2 + 8);
piVar3 = *(int **)param_2;
lVar4 = (long)piVar2 - (long)piVar3 >> 4;
piVar5 = piVar3;
if (0 < lVar4) {
piVar5 = piVar3 + lVar4 * 4;
do {
if (local_34 == *piVar3) goto LAB_001012b6;
if (local_34 == piVar3[1]) {
piVar3 = piVar3 + 1;
goto LAB_001012b6;
}
if (local_34 == piVar3[2]) {
piVar3 = piVar3 + 2;
goto LAB_001012b6;
}
if (local_34 == piVar3[3]) {
piVar3 = piVar3 + 3;
goto LAB_001012b6;
}
piVar3 = piVar3 + 4;
} while (piVar3 != piVar5);
}
piVar3 = piVar5;
lVar4 = (long)piVar2 - (long)piVar3;
if (lVar4 == 8) {
LAB_00101353:
if (local_34 != *piVar3) {
piVar3 = piVar3 + 1;
LAB_0010135b:
if (local_34 != *piVar3) goto LAB_001012d0;
}
LAB_001012b6:
if (piVar3 != piVar2) {
piVar2 = *(int **)(param_1 + 8);
if (piVar2 == *(int **)(param_1 + 0x10)) {
/* try { // try from 00101383 to 00101387 has its CatchHandler @ 0010138d */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar2,&local_34)
;
}
else {
*piVar2 = local_34;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
}
}
else {
if (lVar4 == 0xc) {
if (local_34 != *piVar3) {
piVar3 = piVar3 + 1;
goto LAB_00101353;
}
goto LAB_001012b6;
}
if (lVar4 == 4) goto LAB_0010135b;
}
LAB_001012d0:
piVar6 = piVar6 + 1;
} while( true );
} |
994 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& array_nums1, const std::vector<int>& array_nums2) {
std::vector<int> result;
for (auto num : array_nums2) {
if (std::find(array_nums1.begin(), array_nums1.end(), num) != array_nums1.end()) {
result.push_back(num);
}
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {1, 2, 4, 8, 9}) == std::vector<int>{1, 2, 8, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {3, 5, 7, 9}) == std::vector<int>{3, 5, 7, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {10, 20, 30, 40}) == std::vector<int>{10}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
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 0x8(%rdx),%r13
mov (%rdx),%rbx
cmp %rbx,%r13
je 1895 <_Z5func0RKSt6vectorIiSaIiEES3_+0xe5>
mov %rsi,%rbp
lea 0x4(%rsp),%r14
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%rsi
mov 0x0(%rbp),%rax
mov (%rbx),%ecx
mov %rsi,%rdx
sub %rax,%rdx
mov %ecx,0x4(%rsp)
mov %rdx,%rdi
sar $0x4,%rdx
sar $0x2,%rdi
test %rdx,%rdx
jle 18ca <_Z5func0RKSt6vectorIiSaIiEES3_+0x11a>
shl $0x4,%rdx
add %rax,%rdx
jmp 1864 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb4>
nopl 0x0(%rax)
cmp 0x4(%rax),%ecx
je 18e8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x138>
cmp 0x8(%rax),%ecx
je 18f8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x148>
cmp 0xc(%rax),%ecx
je 1908 <_Z5func0RKSt6vectorIiSaIiEES3_+0x158>
add $0x10,%rax
cmp %rdx,%rax
je 18c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x110>
cmp (%rax),%ecx
jne 1840 <_Z5func0RKSt6vectorIiSaIiEES3_+0x90>
cmp %rax,%rsi
je 1888 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1918 <_Z5func0RKSt6vectorIiSaIiEES3_+0x168>
mov %ecx,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
add $0x4,%rbx
cmp %rbx,%r13
jne 1808 <_Z5func0RKSt6vectorIiSaIiEES3_+0x58>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1955 <_Z5func0RKSt6vectorIiSaIiEES3_+0x1a5>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov %rsi,%rdi
sub %rax,%rdi
sar $0x2,%rdi
cmp $0x2,%rdi
je 193c <_Z5func0RKSt6vectorIiSaIiEES3_+0x18c>
cmp $0x3,%rdi
je 1930 <_Z5func0RKSt6vectorIiSaIiEES3_+0x180>
cmp $0x1,%rdi
jne 1888 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
cmp (%rax),%ecx
jne 1888 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
jmp 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
jmpq 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
nopl 0x0(%rax)
add $0x8,%rax
jmpq 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
nopl 0x0(%rax)
add $0xc,%rax
jmpq 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
nopl 0x0(%rax)
mov %r14,%rdx
mov %r12,%rdi
callq 1a80 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmpq 1888 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
nopl 0x0(%rax,%rax,1)
cmp (%rax),%ecx
je 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
add $0x4,%rax
cmp (%rax),%ecx
je 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
add $0x4,%rax
cmp (%rax),%ecx
jne 1888 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd8>
jmpq 1868 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb8>
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
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 r13, [rdx+8]
mov rbx, [rdx]
cmp r13, rbx
jz loc_17E5
mov rbp, rsi
nop dword ptr [rax+rax+00h]
loc_1758:
mov rsi, [rbp+8]
mov rax, [rbp+0]
mov edx, [rbx]
mov rcx, rsi
sub rcx, rax
mov [rsp+38h+var_34], edx
mov rdi, rcx
sar rcx, 4
sar rdi, 2
test rcx, rcx
jle loc_181A
shl rcx, 4
add rcx, rax
jmp short loc_17B4
loc_1790:
cmp edx, [rax+4]
jz loc_1838
cmp edx, [rax+8]
jz loc_1848
cmp edx, [rax+0Ch]
jz loc_1858
add rax, 10h
cmp rax, rcx
jz short loc_1810
loc_17B4:
cmp edx, [rax]
jnz short loc_1790
loc_17B8:
cmp rax, rsi
jz short loc_17D8
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz loc_1861
mov [rsi], edx
add rsi, 4
mov [r12+8], rsi
loc_17D8:
add rbx, 4
cmp r13, rbx
jnz loc_1758
loc_17E5:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz loc_1898
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1810:
mov rdi, rsi
sub rdi, rax
sar rdi, 2
loc_181A:
cmp rdi, 2
jz short loc_187F
cmp rdi, 3
jz short loc_1873
cmp rdi, 1
jnz short loc_17D8
cmp edx, [rax]
jnz short loc_17D8
jmp short loc_17B8
loc_1838:
add rax, 4
jmp loc_17B8
loc_1848:
add rax, 8
jmp loc_17B8
loc_1858:
add rax, 0Ch
jmp loc_17B8
loc_1861:
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&)
jmp loc_17D8
loc_1873:
cmp edx, [rax]
jz loc_17B8
add rax, 4
loc_187F:
cmp edx, [rax]
jz loc_17B8
add rax, 4
cmp edx, [rax]
jnz loc_17D8
jmp loc_17B8
loc_1898:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long a2, int **a3)
{
int *v4; // r13
int *i; // rbx
_DWORD *v7; // rsi
_DWORD *v8; // rax
int v9; // edx
long long v10; // rcx
long long v11; // rdi
long long v12; // rcx
long long v13; // rdi
_DWORD *v14; // rsi
int v16; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v17; // [rsp+4h] [rbp-30h]
v17 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = a3[1];
for ( i = *a3; v4 != i; ++i )
{
v7 = *(_DWORD **)(a2 + 8);
v8 = *(_DWORD **)a2;
v9 = *i;
v10 = (long long)v7 - *(_QWORD *)a2;
v16 = *i;
v11 = v10;
v12 = v10 >> 4;
v13 = v11 >> 2;
if ( v12 > 0 )
{
v12 = (long long)&v8[4 * v12];
while ( v9 != *v8 )
{
if ( v9 == v8[1] )
{
++v8;
break;
}
if ( v9 == v8[2] )
{
v8 += 2;
break;
}
if ( v9 == v8[3] )
{
v8 += 3;
break;
}
v8 += 4;
if ( v8 == (_DWORD *)v12 )
{
v13 = v7 - v8;
goto LABEL_15;
}
}
LABEL_9:
if ( v8 != v7 )
{
v14 = *(_DWORD **)(a1 + 8);
if ( v14 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v14, &v16, v12);
}
else
{
*v14 = v9;
*(_QWORD *)(a1 + 8) = v14 + 1;
}
}
continue;
}
LABEL_15:
if ( v13 != 2 )
{
if ( v13 != 3 )
{
if ( v13 == 1 && v9 == *v8 )
goto LABEL_9;
continue;
}
if ( v9 == *v8 )
goto LABEL_9;
++v8;
}
if ( v9 == *v8 )
goto LABEL_9;
if ( v9 == *++v8 )
goto LABEL_9;
}
return a1;
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RDX + 0x8]
MOV RBX,qword ptr [RDX]
CMP R13,RBX
JZ 0x001017e5
MOV RBP,RSI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101758:
MOV RSI,qword ptr [RBP + 0x8]
MOV RAX,qword ptr [RBP]
MOV EDX,dword ptr [RBX]
MOV RCX,RSI
SUB RCX,RAX
MOV dword ptr [RSP + 0x4],EDX
MOV RDI,RCX
SAR RCX,0x4
SAR RDI,0x2
TEST RCX,RCX
JLE 0x0010181a
SHL RCX,0x4
ADD RCX,RAX
JMP 0x001017b4
LAB_00101790:
CMP EDX,dword ptr [RAX + 0x4]
JZ 0x00101838
CMP EDX,dword ptr [RAX + 0x8]
JZ 0x00101848
CMP EDX,dword ptr [RAX + 0xc]
JZ 0x00101858
ADD RAX,0x10
CMP RAX,RCX
JZ 0x00101810
LAB_001017b4:
CMP EDX,dword ptr [RAX]
JNZ 0x00101790
LAB_001017b8:
CMP RAX,RSI
JZ 0x001017d8
MOV RSI,qword ptr [R12 + 0x8]
CMP RSI,qword ptr [R12 + 0x10]
JZ 0x00101861
MOV dword ptr [RSI],EDX
ADD RSI,0x4
MOV qword ptr [R12 + 0x8],RSI
LAB_001017d8:
ADD RBX,0x4
CMP R13,RBX
JNZ 0x00101758
LAB_001017e5:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101898
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101810:
MOV RDI,RSI
SUB RDI,RAX
SAR RDI,0x2
LAB_0010181a:
CMP RDI,0x2
JZ 0x0010187f
CMP RDI,0x3
JZ 0x00101873
CMP RDI,0x1
JNZ 0x001017d8
CMP EDX,dword ptr [RAX]
JNZ 0x001017d8
JMP 0x001017b8
LAB_00101838:
ADD RAX,0x4
JMP 0x001017b8
LAB_00101848:
ADD RAX,0x8
JMP 0x001017b8
LAB_00101858:
ADD RAX,0xc
JMP 0x001017b8
LAB_00101861:
LEA RDX,[RSP + 0x4]
MOV RDI,R12
LAB_00101869:
CALL 0x001019c0
JMP 0x001017d8
LAB_00101873:
CMP EDX,dword ptr [RAX]
JZ 0x001017b8
ADD RAX,0x4
LAB_0010187f:
CMP EDX,dword ptr [RAX]
JZ 0x001017b8
ADD RAX,0x4
CMP EDX,dword ptr [RAX]
JNZ 0x001017d8
JMP 0x001017b8
LAB_00101898:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int *piVar5;
int8 *in_RDX;
int *piVar6;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
piVar1 = (int *)in_RDX[1];
piVar6 = (int *)*in_RDX;
do {
if (piVar1 == piVar6) {
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
piVar2 = *(int **)(param_2 + 8);
piVar3 = *(int **)param_2;
local_34 = *piVar6;
lVar4 = (long)piVar2 - (long)piVar3;
if (0 < lVar4 >> 4) {
piVar5 = piVar3 + (lVar4 >> 4) * 4;
do {
if (local_34 == *piVar3) goto LAB_001017b8;
if (local_34 == piVar3[1]) {
piVar3 = piVar3 + 1;
goto LAB_001017b8;
}
if (local_34 == piVar3[2]) {
piVar3 = piVar3 + 2;
goto LAB_001017b8;
}
if (local_34 == piVar3[3]) {
piVar3 = piVar3 + 3;
goto LAB_001017b8;
}
piVar3 = piVar3 + 4;
} while (piVar3 != piVar5);
lVar4 = (long)piVar2 - (long)piVar3;
}
lVar4 = lVar4 >> 2;
if (lVar4 == 2) {
LAB_0010187f:
if ((local_34 == *piVar3) || (piVar3 = piVar3 + 1, local_34 == *piVar3)) goto LAB_001017b8;
}
else {
if (lVar4 == 3) {
if (local_34 != *piVar3) {
piVar3 = piVar3 + 1;
goto LAB_0010187f;
}
}
else if ((lVar4 != 1) || (local_34 != *piVar3)) goto LAB_001017d8;
LAB_001017b8:
if (piVar3 != piVar2) {
piVar2 = *(int **)(param_1 + 8);
if (piVar2 == *(int **)(param_1 + 0x10)) {
/* try { // try from 00101869 to 0010186d has its CatchHandler @ 0010189d */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar2,&local_34)
;
}
else {
*piVar2 = local_34;
*(int **)(param_1 + 8) = piVar2 + 1;
}
}
}
LAB_001017d8:
piVar6 = piVar6 + 1;
} while( true );
} |
995 | func0 |
#include <vector>
#include <algorithm>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& array_nums1, const std::vector<int>& array_nums2) {
std::vector<int> result;
for (auto num : array_nums2) {
if (std::find(array_nums1.begin(), array_nums1.end(), num) != array_nums1.end()) {
result.push_back(num);
}
}
return result;
}
| int main() {
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {1, 2, 4, 8, 9}) == std::vector<int>{1, 2, 8, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {3, 5, 7, 9}) == std::vector<int>{3, 5, 7, 9}));
assert((func0({1, 2, 3, 5, 7, 8, 9, 10}, {10, 20, 30, 40}) == std::vector<int>{10}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
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 0x8(%rdx),%r13
mov (%rdx),%rbx
cmp %rbx,%r13
je 182d <_Z5func0RKSt6vectorIiSaIiEES3_+0xdd>
mov %rsi,%rbp
lea 0x4(%rsp),%r14
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%rsi
mov 0x0(%rbp),%rax
mov (%rbx),%ecx
mov %rsi,%rdx
sub %rax,%rdx
mov %ecx,0x4(%rsp)
mov %rdx,%rdi
sar $0x4,%rdx
sar $0x2,%rdi
test %rdx,%rdx
jle 1862 <_Z5func0RKSt6vectorIiSaIiEES3_+0x112>
shl $0x4,%rdx
add %rax,%rdx
jmp 17fc <_Z5func0RKSt6vectorIiSaIiEES3_+0xac>
nopl 0x0(%rax)
cmp 0x4(%rax),%ecx
je 1880 <_Z5func0RKSt6vectorIiSaIiEES3_+0x130>
cmp 0x8(%rax),%ecx
je 1890 <_Z5func0RKSt6vectorIiSaIiEES3_+0x140>
cmp 0xc(%rax),%ecx
je 18a0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x150>
add $0x10,%rax
cmp %rax,%rdx
je 1858 <_Z5func0RKSt6vectorIiSaIiEES3_+0x108>
cmp (%rax),%ecx
jne 17d8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x88>
cmp %rax,%rsi
je 1820 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 18b0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x160>
mov %ecx,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
add $0x4,%rbx
cmp %rbx,%r13
jne 17a0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x50>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 18e5 <_Z5func0RKSt6vectorIiSaIiEES3_+0x195>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov %rsi,%rdi
sub %rax,%rdi
sar $0x2,%rdi
cmp $0x2,%rdi
je 18cc <_Z5func0RKSt6vectorIiSaIiEES3_+0x17c>
cmp $0x3,%rdi
je 18c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x170>
cmp $0x1,%rdi
jne 1820 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
cmp (%rax),%ecx
jne 1820 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
jmp 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
nopw 0x0(%rax,%rax,1)
add $0x4,%rax
jmpq 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
nopl 0x0(%rax)
add $0x8,%rax
jmpq 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
nopl 0x0(%rax)
add $0xc,%rax
jmpq 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
nopl 0x0(%rax)
mov %r14,%rdx
mov %r12,%rdi
callq 1950 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmpq 1820 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
cmp (%rax),%ecx
je 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
add $0x4,%rax
cmp (%rax),%ecx
je 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
add $0x4,%rax
cmp (%rax),%ecx
jne 1820 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
jmpq 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
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 r13, [rdx+8]
mov rbx, [rdx]
cmp r13, rbx
jz loc_17E5
mov rbp, rsi
nop dword ptr [rax+rax+00h]
loc_1758:
mov rsi, [rbp+8]
mov rax, [rbp+0]
mov edx, [rbx]
mov rcx, rsi
sub rcx, rax
mov [rsp+38h+var_34], edx
mov rdi, rcx
sar rcx, 4
sar rdi, 2
test rcx, rcx
jle loc_181A
shl rcx, 4
add rcx, rax
jmp short loc_17B4
loc_1790:
cmp edx, [rax+4]
jz loc_1838
cmp edx, [rax+8]
jz loc_1848
cmp edx, [rax+0Ch]
jz loc_1858
add rax, 10h
cmp rax, rcx
jz short loc_1810
loc_17B4:
cmp edx, [rax]
jnz short loc_1790
loc_17B8:
cmp rax, rsi
jz short loc_17D8
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz loc_1861
mov [rsi], edx
add rsi, 4
mov [r12+8], rsi
loc_17D8:
add rbx, 4
cmp r13, rbx
jnz loc_1758
loc_17E5:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz loc_1898
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1810:
mov rdi, rsi
sub rdi, rax
sar rdi, 2
loc_181A:
cmp rdi, 2
jz short loc_187F
cmp rdi, 3
jz short loc_1873
cmp rdi, 1
jnz short loc_17D8
cmp edx, [rax]
jnz short loc_17D8
jmp short loc_17B8
loc_1838:
add rax, 4
jmp loc_17B8
loc_1848:
add rax, 8
jmp loc_17B8
loc_1858:
add rax, 0Ch
jmp loc_17B8
loc_1861:
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&)
jmp loc_17D8
loc_1873:
cmp edx, [rax]
jz loc_17B8
add rax, 4
loc_187F:
cmp edx, [rax]
jz loc_17B8
add rax, 4
cmp edx, [rax]
jnz loc_17D8
jmp loc_17B8
loc_1898:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long a2, int **a3)
{
int *v4; // r13
int *i; // rbx
_DWORD *v7; // rsi
_DWORD *v8; // rax
int v9; // edx
long long v10; // rcx
long long v11; // rdi
long long v12; // rcx
long long v13; // rdi
_DWORD *v14; // rsi
int v16; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v17; // [rsp+4h] [rbp-30h]
v17 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = a3[1];
for ( i = *a3; v4 != i; ++i )
{
v7 = *(_DWORD **)(a2 + 8);
v8 = *(_DWORD **)a2;
v9 = *i;
v10 = (long long)v7 - *(_QWORD *)a2;
v16 = *i;
v11 = v10;
v12 = v10 >> 4;
v13 = v11 >> 2;
if ( v12 > 0 )
{
v12 = (long long)&v8[4 * v12];
while ( v9 != *v8 )
{
if ( v9 == v8[1] )
{
++v8;
break;
}
if ( v9 == v8[2] )
{
v8 += 2;
break;
}
if ( v9 == v8[3] )
{
v8 += 3;
break;
}
v8 += 4;
if ( v8 == (_DWORD *)v12 )
{
v13 = v7 - v8;
goto LABEL_15;
}
}
LABEL_9:
if ( v8 != v7 )
{
v14 = *(_DWORD **)(a1 + 8);
if ( v14 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v14, &v16, v12);
}
else
{
*v14 = v9;
*(_QWORD *)(a1 + 8) = v14 + 1;
}
}
continue;
}
LABEL_15:
if ( v13 != 2 )
{
if ( v13 != 3 )
{
if ( v13 == 1 && v9 == *v8 )
goto LABEL_9;
continue;
}
if ( v9 == *v8 )
goto LABEL_9;
++v8;
}
if ( v9 == *v8 )
goto LABEL_9;
if ( v9 == *++v8 )
goto LABEL_9;
}
return a1;
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV R13,qword ptr [RDX + 0x8]
MOV RBX,qword ptr [RDX]
CMP R13,RBX
JZ 0x001017e5
MOV RBP,RSI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101758:
MOV RSI,qword ptr [RBP + 0x8]
MOV RAX,qword ptr [RBP]
MOV EDX,dword ptr [RBX]
MOV RCX,RSI
SUB RCX,RAX
MOV dword ptr [RSP + 0x4],EDX
MOV RDI,RCX
SAR RCX,0x4
SAR RDI,0x2
TEST RCX,RCX
JLE 0x0010181a
SHL RCX,0x4
ADD RCX,RAX
JMP 0x001017b4
LAB_00101790:
CMP EDX,dword ptr [RAX + 0x4]
JZ 0x00101838
CMP EDX,dword ptr [RAX + 0x8]
JZ 0x00101848
CMP EDX,dword ptr [RAX + 0xc]
JZ 0x00101858
ADD RAX,0x10
CMP RAX,RCX
JZ 0x00101810
LAB_001017b4:
CMP EDX,dword ptr [RAX]
JNZ 0x00101790
LAB_001017b8:
CMP RAX,RSI
JZ 0x001017d8
MOV RSI,qword ptr [R12 + 0x8]
CMP RSI,qword ptr [R12 + 0x10]
JZ 0x00101861
MOV dword ptr [RSI],EDX
ADD RSI,0x4
MOV qword ptr [R12 + 0x8],RSI
LAB_001017d8:
ADD RBX,0x4
CMP R13,RBX
JNZ 0x00101758
LAB_001017e5:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101898
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101810:
MOV RDI,RSI
SUB RDI,RAX
SAR RDI,0x2
LAB_0010181a:
CMP RDI,0x2
JZ 0x0010187f
CMP RDI,0x3
JZ 0x00101873
CMP RDI,0x1
JNZ 0x001017d8
CMP EDX,dword ptr [RAX]
JNZ 0x001017d8
JMP 0x001017b8
LAB_00101838:
ADD RAX,0x4
JMP 0x001017b8
LAB_00101848:
ADD RAX,0x8
JMP 0x001017b8
LAB_00101858:
ADD RAX,0xc
JMP 0x001017b8
LAB_00101861:
LEA RDX,[RSP + 0x4]
MOV RDI,R12
LAB_00101869:
CALL 0x001019c0
JMP 0x001017d8
LAB_00101873:
CMP EDX,dword ptr [RAX]
JZ 0x001017b8
ADD RAX,0x4
LAB_0010187f:
CMP EDX,dword ptr [RAX]
JZ 0x001017b8
ADD RAX,0x4
CMP EDX,dword ptr [RAX]
JNZ 0x001017d8
JMP 0x001017b8
LAB_00101898:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
long lVar4;
int *piVar5;
int8 *in_RDX;
int *piVar6;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
piVar1 = (int *)in_RDX[1];
piVar6 = (int *)*in_RDX;
do {
if (piVar1 == piVar6) {
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
piVar2 = *(int **)(param_2 + 8);
piVar3 = *(int **)param_2;
local_34 = *piVar6;
lVar4 = (long)piVar2 - (long)piVar3;
if (0 < lVar4 >> 4) {
piVar5 = piVar3 + (lVar4 >> 4) * 4;
do {
if (local_34 == *piVar3) goto LAB_001017b8;
if (local_34 == piVar3[1]) {
piVar3 = piVar3 + 1;
goto LAB_001017b8;
}
if (local_34 == piVar3[2]) {
piVar3 = piVar3 + 2;
goto LAB_001017b8;
}
if (local_34 == piVar3[3]) {
piVar3 = piVar3 + 3;
goto LAB_001017b8;
}
piVar3 = piVar3 + 4;
} while (piVar3 != piVar5);
lVar4 = (long)piVar2 - (long)piVar3;
}
lVar4 = lVar4 >> 2;
if (lVar4 == 2) {
LAB_0010187f:
if ((local_34 == *piVar3) || (piVar3 = piVar3 + 1, local_34 == *piVar3)) goto LAB_001017b8;
}
else {
if (lVar4 == 3) {
if (local_34 != *piVar3) {
piVar3 = piVar3 + 1;
goto LAB_0010187f;
}
}
else if ((lVar4 != 1) || (local_34 != *piVar3)) goto LAB_001017d8;
LAB_001017b8:
if (piVar3 != piVar2) {
piVar2 = *(int **)(param_1 + 8);
if (piVar2 == *(int **)(param_1 + 0x10)) {
/* try { // try from 00101869 to 0010186d has its CatchHandler @ 0010189d */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar2,&local_34)
;
}
else {
*piVar2 = local_34;
*(int **)(param_1 + 8) = piVar2 + 1;
}
}
}
LAB_001017d8:
piVar6 = piVar6 + 1;
} while( true );
} |
996 | func0 | #include <vector>
#include <assert.h>
| int func0(const std::vector<int>& tup, int x) {
int count = 0;
for(int ele : tup) {
if(ele == x) {
count++;
}
}
return count;
}
| int main() {
std::vector<int> tup = {10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2};
assert(func0(tup, 4) == 0);
assert(func0(tup, 10) == 3);
assert(func0(tup, 8) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1490 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x20(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 14e8 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x18(%rbp)
lea -0x18(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1540 <_ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_>
test %al,%al
je 12bc <_Z5func0RKSt6vectorIiSaIiEEi+0x93>
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 15a4 <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jne 12ae <_Z5func0RKSt6vectorIiSaIiEEi+0x85>
addl $0x1,-0x28(%rbp)
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 1580 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv>
jmp 127a <_Z5func0RKSt6vectorIiSaIiEEi+0x51>
mov -0x28(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12d3 <_Z5func0RKSt6vectorIiSaIiEEi+0xaa>
callq 1110 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
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 _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; 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_iteratorIPKiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int const*,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_iteratorIPKiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int const*,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_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,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 const*,std::vector<int>>(&v4, v5) )
{
if ( *(_DWORD *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(&v4) == a2 )
++v3;
__gnu_cxx::__normal_iterator<int const*,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 0x001014ba
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101506
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012c5
LAB_0010129c:
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x001015ba
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 0x00101596
LAB_001012c5:
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101556
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> > const&, int) */
int func0(vector *param_1,int param_2)
{
bool bVar1;
int *piVar2;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
local_18 = (vector<int,std::allocator<int>> *)param_1;
local_28 = std::vector<int,std::allocator<int>>::begin((vector<int,std::allocator<int>> *)param_1)
;
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_const*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *
)&local_28);
if (*piVar2 == param_2) {
local_30 = local_30 + 1;
}
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int_const*,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;
} |
997 | func0 | #include <vector>
#include <assert.h>
| int func0(const std::vector<int>& tup, int x) {
int count = 0;
for(int ele : tup) {
if(ele == x) {
count++;
}
}
return count;
}
| int main() {
std::vector<int> tup = {10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2};
assert(func0(tup, 4) == 0);
assert(func0(tup, 10) == 3);
assert(func0(tup, 8) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdi
cmp %rdi,%rax
je 11d4 <_Z5func0RKSt6vectorIiSaIiEEi+0x2b>
mov $0x0,%edx
cmp %esi,(%rax)
sete %cl
movzbl %cl,%ecx
add %ecx,%edx
add $0x4,%rax
cmp %rax,%rdi
jne 11be <_Z5func0RKSt6vectorIiSaIiEEi+0x15>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 11d1 <_Z5func0RKSt6vectorIiSaIiEEi+0x28>
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
cmp rdi, rax
jz short loc_11D4
mov edx, 0
loc_11BE:
cmp [rax], esi
setz cl
movzx ecx, cl
add edx, ecx
add rax, 4
cmp rax, rdi
jnz short loc_11BE
loc_11D1:
mov eax, edx
retn
loc_11D4:
mov edx, 0
jmp short loc_11D1 | 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 0x001011d4
MOV EDX,0x0
LAB_001011be:
CMP dword ptr [RAX],ESI
SETZ CL
MOVZX ECX,CL
ADD EDX,ECX
ADD RAX,0x4
CMP RAX,RDI
JNZ 0x001011be
LAB_001011d1:
MOV EAX,EDX
RET
LAB_001011d4:
MOV EDX,0x0
JMP 0x001011d1 | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int *piVar1;
int iVar2;
piVar1 = *(int **)param_1;
if (*(int **)(param_1 + 8) == piVar1) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)(*piVar1 == param_2);
piVar1 = piVar1 + 1;
} while (piVar1 != *(int **)(param_1 + 8));
}
return iVar2;
} |
998 | func0 | #include <vector>
#include <assert.h>
| int func0(const std::vector<int>& tup, int x) {
int count = 0;
for(int ele : tup) {
if(ele == x) {
count++;
}
}
return count;
}
| int main() {
std::vector<int> tup = {10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2};
assert(func0(tup, 4) == 0);
assert(func0(tup, 10) == 3);
assert(func0(tup, 8) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
cmp %rcx,%rax
je 135b <_Z5func0RKSt6vectorIiSaIiEEi+0x2b>
nopl 0x0(%rax,%rax,1)
xor %edx,%edx
cmp %esi,(%rax)
sete %dl
add $0x4,%rax
add %edx,%r8d
cmp %rax,%rcx
jne 1348 <_Z5func0RKSt6vectorIiSaIiEEi+0x18>
mov %r8d,%eax
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov rax, [rdi]
mov rdi, [rdi+8]
xor edx, edx
cmp rdi, rax
jz short loc_13AA
nop word ptr [rax+rax+00h]
loc_1398:
xor ecx, ecx
cmp esi, [rax]
setz cl
add rax, 4
add edx, ecx
cmp rdi, rax
jnz short loc_1398
loc_13AA:
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 0x001013aa
NOP word ptr [RAX + RAX*0x1]
LAB_00101398:
XOR ECX,ECX
CMP ESI,dword ptr [RAX]
SETZ CL
ADD RAX,0x4
ADD EDX,ECX
CMP RDI,RAX
JNZ 0x00101398
LAB_001013aa:
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int *piVar1;
int iVar2;
iVar2 = 0;
for (piVar1 = *(int **)param_1; *(int **)(param_1 + 8) != piVar1; piVar1 = piVar1 + 1) {
iVar2 = iVar2 + (uint)(param_2 == *piVar1);
}
return iVar2;
} |
999 | func0 | #include <vector>
#include <assert.h>
| int func0(const std::vector<int>& tup, int x) {
int count = 0;
for(int ele : tup) {
if(ele == x) {
count++;
}
}
return count;
}
| int main() {
std::vector<int> tup = {10, 8, 5, 2, 10, 15, 10, 8, 5, 8, 8, 2};
assert(func0(tup, 4) == 0);
assert(func0(tup, 10) == 3);
assert(func0(tup, 8) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rdi
cmp %rdi,%rdx
je 1470 <_Z5func0RKSt6vectorIiSaIiEEi+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 1479 <_Z5func0RKSt6vectorIiSaIiEEi+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 13e8 <_Z5func0RKSt6vectorIiSaIiEEi+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 1478 <_Z5func0RKSt6vectorIiSaIiEEi+0xe8>
xor %ecx,%ecx
cmp (%rdx),%esi
sete %cl
add %ecx,%eax
lea 0x4(%rdx),%rcx
cmp %rcx,%rdi
je 1472 <_Z5func0RKSt6vectorIiSaIiEEi+0xe2>
xor %ecx,%ecx
cmp 0x4(%rdx),%esi
sete %cl
add %ecx,%eax
lea 0x8(%rdx),%rcx
cmp %rcx,%rdi
je 1472 <_Z5func0RKSt6vectorIiSaIiEEi+0xe2>
xor %ecx,%ecx
cmp %esi,0x8(%rdx)
sete %cl
add %ecx,%eax
lea 0xc(%rdx),%rcx
cmp %rcx,%rdi
je 1472 <_Z5func0RKSt6vectorIiSaIiEEi+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 142b <_Z5func0RKSt6vectorIiSaIiEEi+0x9b>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov rdx, [rdi]
mov r8, [rdi+8]
cmp r8, rdx
jz loc_12F8
lea rcx, [r8-4]
mov rax, rdx
sub rcx, rdx
mov rdi, rcx
shr rdi, 2
add rdi, 1
cmp rcx, 8
jbe loc_12FB
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_1270:
movdqu xmm1, xmmword ptr [rax]
add rax, 10h
pcmpeqd xmm1, xmm2
psubd xmm0, xmm1
cmp rax, rcx
jnz short loc_1270
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_12E8
loc_12B3:
xor ecx, ecx
cmp esi, [rdx]
setz cl
add eax, ecx
lea rcx, [rdx+4]
cmp r8, rcx
jz short locret_12D8
cmp esi, [rdx+4]
jz short loc_12E0
loc_12CA:
lea rcx, [rdx+8]
cmp r8, rcx
jz short locret_12D8
cmp esi, [rdx+8]
jz short loc_12F0
locret_12D8:
retn
loc_12E0:
add eax, 1
jmp short loc_12CA
locret_12E8:
retn
loc_12F0:
add eax, 1
retn
loc_12F8:
xor eax, eax
retn
loc_12FB:
xor eax, eax
jmp short loc_12B3 | 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 0x001012f8
LEA RCX,[R8 + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RDI,RCX
SHR RDI,0x2
ADD RDI,0x1
CMP RCX,0x8
JBE 0x001012fb
MOV RCX,RDI
MOVD XMM3,ESI
PXOR XMM0,XMM0
SHR RCX,0x2
PSHUFD XMM2,XMM3,0x0
SHL RCX,0x4
ADD RCX,RDX
NOP
LAB_00101270:
MOVDQU XMM1,xmmword ptr [RAX]
ADD RAX,0x10
PCMPEQD XMM1,XMM2
PSUBD XMM0,XMM1
CMP RAX,RCX
JNZ 0x00101270
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 0x001012e8
LAB_001012b3:
XOR ECX,ECX
CMP ESI,dword ptr [RDX]
SETZ CL
ADD EAX,ECX
LEA RCX,[RDX + 0x4]
CMP R8,RCX
JZ 0x001012d8
CMP ESI,dword ptr [RDX + 0x4]
JZ 0x001012e0
LAB_001012ca:
LEA RCX,[RDX + 0x8]
CMP R8,RCX
JZ 0x001012d8
CMP ESI,dword ptr [RDX + 0x8]
JZ 0x001012f0
LAB_001012d8:
RET
LAB_001012e0:
ADD EAX,0x1
JMP 0x001012ca
LAB_001012e8:
RET
LAB_001012f0:
ADD EAX,0x1
RET
LAB_001012f8:
XOR EAX,EAX
RET
LAB_001012fb:
XOR EAX,EAX
JMP 0x001012b3 | /* func0(std::vector<int, std::allocator<int> > const&, 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;
ulong uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
piVar8 = *(int **)param_1;
piVar1 = *(int **)(param_1 + 8);
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;
} |
1,000 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::vector<std::string> func0(const std::vector<std::string>& list, const std::string& element) {
std::vector<std::string> result;
for (const auto& elt : list) {
result.push_back(element);
result.push_back(elt);
}
return result;
}
| int main() {
std::vector<std::string> test1 = func0({"Red", "Green", "Black"}, "c");
std::vector<std::string> expected1 = {"c", "Red", "c", "Green", "c", "Black"};
assert(test1 == expected1);
std::vector<std::string> test2 = func0({"python", "java"}, "program");
std::vector<std::string> expected2 = {"program", "python", "program", "java"};
assert(test2 == expected2);
std::vector<std::string> test3 = func0({"happy", "sad"}, "laugh");
std::vector<std::string> expected3 = {"laugh", "happy", "laugh", "sad"};
assert(test3 == expected3);
return 0;
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %rdx,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 37a0 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC1Ev>
mov -0x50(%rbp),%rax
mov %rax,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 3958 <_ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv>
mov %rax,-0x38(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 39b0 <_ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3a08 <_ZN9__gnu_cxxneIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_>
test %al,%al
je 259e <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xd5>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 3a6c <_ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv>
mov %rax,-0x20(%rbp)
mov -0x58(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3a82 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_>
mov -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3a82 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_>
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 3a48 <_ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv>
jmp 2525 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x5c>
endbr64
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 3910 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23a0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 25b3 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xea>
callq 2350 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_58], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rax, [rbp+var_50]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rbp+var_30], rax
jmp short loc_2549
loc_2507:
lea rax, [rbp+var_38]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*(void)
mov [rbp+var_20], rax
mov rdx, [rbp+var_58]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
mov rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
lea rax, [rbp+var_38]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(void)
loc_2549:
lea rdx, [rbp+var_30]
lea rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEEbRKNS_17__normal_iteratorIT_T0_EESH_; __gnu_cxx::operator!=<std::string const*,std::vector<std::string>>(__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>> const&,__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>> const&)
test al, al
jnz short loc_2507
jmp short loc_2594
endbr64
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_258C
call ___stack_chk_fail
loc_258C:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_2594:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_25A8
call ___stack_chk_fail
loc_25A8:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v5; // [rsp+28h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+30h] [rbp-30h] BYREF
long long v7; // [rsp+40h] [rbp-20h]
unsigned long long v8; // [rsp+48h] [rbp-18h]
v8 = __readfsqword(0x28u);
std::vector<std::string>::vector(a1);
v6[1] = a2;
v5 = std::vector<std::string>::begin(a2);
v6[0] = std::vector<std::string>::end(a2);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::string const*,std::vector<std::string>>(&v5, v6) )
{
v7 = __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*(&v5);
std::vector<std::string>::push_back(a1, a3);
std::vector<std::string>::push_back(a1, v7);
__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(&v5);
}
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 qword ptr [RBP + -0x58],RDX
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 0x00102eae
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00103042
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010308e
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00102549
LAB_00102507:
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x00103142
MOV qword ptr [RBP + -0x20],RAX
MOV RDX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_00102525:
CALL 0x00103158
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00103158
LEA RAX,[RBP + -0x38]
MOV RDI,RAX
CALL 0x0010311e
LAB_00102549:
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001030de
TEST AL,AL
JNZ 0x00102507
JMP 0x00102594
LAB_00102594:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001025a8
CALL 0x00102340
LAB_001025a8:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::string, std::allocator<std::string > > const&, std::string const&) */
vector * func0(vector *param_1,string *param_2)
{
bool bVar1;
string *in_RDX;
long in_FS_OFFSET;
int8 local_40;
int8 local_38;
vector<std::string,std::allocator<std::string>> *local_30;
string *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::string,std::allocator<std::string>>::vector
((vector<std::string,std::allocator<std::string>> *)param_1);
local_30 = (vector<std::string,std::allocator<std::string>> *)param_2;
local_40 = std::vector<std::string,std::allocator<std::string>>::begin
((vector<std::string,std::allocator<std::string>> *)param_2);
local_38 = std::vector<std::string,std::allocator<std::string>>::end(local_30);
while( true ) {
bVar1 = operator!=((__normal_iterator *)&local_40,(__normal_iterator *)&local_38);
if (!bVar1) break;
local_28 = (string *)
__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
::operator*((__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
*)&local_40);
/* try { // try from 00102525 to 0010253c has its CatchHandler @ 00102562 */
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,in_RDX);
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,local_28);
__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>::
operator++((__normal_iterator<std::string_const*,std::vector<std::string,std::allocator<std::string>>>
*)&local_40);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
1,001 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::vector<std::string> func0(const std::vector<std::string>& list, const std::string& element) {
std::vector<std::string> result;
for (const auto& elt : list) {
result.push_back(element);
result.push_back(elt);
}
return result;
}
| int main() {
std::vector<std::string> test1 = func0({"Red", "Green", "Black"}, "c");
std::vector<std::string> expected1 = {"c", "Red", "c", "Green", "c", "Black"};
assert(test1 == expected1);
std::vector<std::string> test2 = func0({"python", "java"}, "program");
std::vector<std::string> expected2 = {"program", "python", "program", "java"};
assert(test2 == expected2);
std::vector<std::string> test3 = func0({"happy", "sad"}, "laugh");
std::vector<std::string> expected3 = {"laugh", "happy", "laugh", "sad"};
assert(test3 == expected3);
return 0;
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rdx,%r13
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbp
mov 0x8(%rsi),%r14
cmp %r14,%rbp
jne 1351 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x88>
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
addq $0x20,0x8(%rbx)
mov 0x8(%rbx),%rdi
cmp 0x10(%rbx),%rdi
je 1377 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xae>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
mov (%r12),%rsi
mov %rsi,%rdx
add 0x8(%r12),%rdx
callq 1de2 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
jmp 1343 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x7a>
mov %r13,%rdx
mov %rdi,%rsi
mov %rbx,%rdi
callq 1fc6 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
jmp 130f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x46>
addq $0x20,0x8(%rbx)
add $0x20,%rbp
cmp %rbp,%r14
je 12fe <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x35>
mov %rbp,%r12
mov 0x8(%rbx),%rdi
cmp 0x10(%rbx),%rdi
je 1333 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x6a>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
mov 0x0(%r13),%rsi
mov %rsi,%rdx
add 0x8(%r13),%rdx
callq 1de2 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
jmp 130a <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x41>
mov %r12,%rdx
mov %rdi,%rsi
mov %rbx,%rdi
callq 1fc6 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
jmp 1348 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x7f>
endbr64
mov %rax,%rbp
mov %rbx,%rdi
callq 1c54 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov %rbp,%rdi
callq 11c0 <_Unwind_Resume@plt>
| _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov r13, rdx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbp, [rsi]
mov r14, [rsi+8]
cmp r14, rbp
jnz short loc_1391
loc_133E:
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_134A:
add qword ptr [rbx+8], 20h ; ' '
loc_134F:
mov rdi, [rbx+8]
cmp rdi, [rbx+10h]
jz short loc_13B7
lea rax, [rdi+10h]
mov [rdi], rax
mov rsi, [r12]
mov rdx, rsi
add rdx, [r12+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_1383
loc_1373:
mov rdx, r13
mov rsi, rdi
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
jmp short loc_134F
loc_1383:
add qword ptr [rbx+8], 20h ; ' '
loc_1388:
add rbp, 20h ; ' '
cmp r14, rbp
jz short loc_133E
loc_1391:
mov r12, rbp
mov rdi, [rbx+8]
cmp rdi, [rbx+10h]
jz short loc_1373
lea rax, [rdi+10h]
mov [rdi], rax
mov rsi, [r13+0]
mov rdx, rsi
add rdx, [r13+8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
jmp short loc_134A
loc_13B7:
mov rdx, r12
mov rsi, rdi
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
jmp short loc_1388
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume | _QWORD * func0(_QWORD *a1, _QWORD *a2, _QWORD *a3)
{
_QWORD *v5; // rbp
_QWORD *v6; // r14
_QWORD *v8; // rdi
_QWORD *v9; // rdi
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v5 = (_QWORD *)*a2;
v6 = (_QWORD *)a2[1];
if ( v6 != (_QWORD *)*a2 )
{
do
{
v9 = (_QWORD *)a1[1];
if ( v9 == (_QWORD *)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, a1[1], a3);
}
else
{
*v9 = v9 + 2;
std::string::_M_construct<char *>(v9, *a3, a3[1] + *a3);
a1[1] += 32LL;
}
v8 = (_QWORD *)a1[1];
if ( v8 == (_QWORD *)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, a1[1], v5);
}
else
{
*v8 = v8 + 2;
std::string::_M_construct<char *>(v8, *v5, v5[1] + *v5);
a1[1] += 32LL;
}
v5 += 4;
}
while ( v6 != v5 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R13,RDX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
CMP R14,RBP
JNZ 0x00101391
LAB_0010133e:
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010134a:
ADD qword ptr [RBX + 0x8],0x20
LAB_0010134f:
MOV RDI,qword ptr [RBX + 0x8]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x001013b7
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV RSI,qword ptr [R12]
MOV RDX,RSI
ADD RDX,qword ptr [R12 + 0x8]
LAB_0010136c:
CALL 0x00101a90
JMP 0x00101383
LAB_00101373:
MOV RDX,R13
MOV RSI,RDI
MOV RDI,RBX
CALL 0x00101b2c
JMP 0x0010134f
LAB_00101383:
ADD qword ptr [RBX + 0x8],0x20
LAB_00101388:
ADD RBP,0x20
CMP R14,RBP
JZ 0x0010133e
LAB_00101391:
MOV R12,RBP
MOV RDI,qword ptr [RBX + 0x8]
CMP RDI,qword ptr [RBX + 0x10]
JZ 0x00101373
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV RSI,qword ptr [R13]
MOV RDX,RSI
ADD RDX,qword ptr [R13 + 0x8]
CALL 0x00101a90
JMP 0x0010134a
LAB_001013b7:
MOV RDX,R12
MOV RSI,RDI
MOV RDI,RBX
CALL 0x00101b2c
JMP 0x00101388 | /* func0(std::vector<std::string, std::allocator<std::string > > const&, std::string const&) */
vector * func0(vector *param_1,string *param_2)
{
string *psVar1;
long *plVar2;
string *in_RDX;
string *psVar3;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
psVar1 = *(string **)(param_2 + 8);
for (psVar3 = *(string **)param_2; psVar1 != psVar3; psVar3 = psVar3 + 0x20) {
plVar2 = *(long **)(param_1 + 8);
if (plVar2 == *(long **)(param_1 + 0x10)) {
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string_const&>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar2,in_RDX);
}
else {
*plVar2 = (long)(plVar2 + 2);
std::string::_M_construct<char*>
((char *)plVar2,*(char **)in_RDX,
(int)*(char **)in_RDX + (int)*(int8 *)(in_RDX + 8));
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
plVar2 = *(long **)(param_1 + 8);
if (plVar2 == *(long **)(param_1 + 0x10)) {
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string_const&>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar2,psVar3);
}
else {
*plVar2 = (long)(plVar2 + 2);
/* try { // try from 0010136c to 001013c4 has its CatchHandler @ 001013c7 */
std::string::_M_construct<char*>
((char *)plVar2,*(char **)psVar3,
(int)*(char **)psVar3 + (int)*(int8 *)(psVar3 + 8));
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
}
return param_1;
} |
1,002 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::vector<std::string> func0(const std::vector<std::string>& list, const std::string& element) {
std::vector<std::string> result;
for (const auto& elt : list) {
result.push_back(element);
result.push_back(elt);
}
return result;
}
| int main() {
std::vector<std::string> test1 = func0({"Red", "Green", "Black"}, "c");
std::vector<std::string> expected1 = {"c", "Red", "c", "Green", "c", "Black"};
assert(test1 == expected1);
std::vector<std::string> test2 = func0({"python", "java"}, "program");
std::vector<std::string> expected2 = {"program", "python", "program", "java"};
assert(test2 == expected2);
std::vector<std::string> test3 = func0({"happy", "sad"}, "laugh");
std::vector<std::string> expected3 = {"laugh", "happy", "laugh", "sad"};
assert(test3 == expected3);
return 0;
}
| O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov 0x8(%rsi),%r13
cmp %r13,%rbx
je 1c29 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xd9>
mov %rdx,%rbp
xor %eax,%eax
xor %edi,%edi
jmp 1bf3 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xa3>
nopl 0x0(%rax)
lea 0x10(%rdi),%rax
mov 0x8(%rbp),%rdx
mov %rax,(%rdi)
mov 0x0(%rbp),%rsi
add %rsi,%rdx
callq 1d30 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
mov 0x8(%r12),%rax
lea 0x20(%rax),%rdi
mov %rdi,0x8(%r12)
cmp %rdi,0x10(%r12)
je 1c12 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xc2>
lea 0x10(%rdi),%rax
mov 0x8(%rbx),%rdx
mov %rax,(%rdi)
mov (%rbx),%rsi
add %rsi,%rdx
callq 1d30 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag>
add $0x20,%rbx
addq $0x20,0x8(%r12)
cmp %rbx,%r13
je 1c29 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xd9>
mov 0x8(%r12),%rdi
mov 0x10(%r12),%rax
cmp %rax,%rdi
jne 1b98 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x48>
mov %rdi,%rsi
mov %rbp,%rdx
mov %r12,%rdi
callq 1f30 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
mov 0x8(%r12),%rdi
cmp %rdi,0x10(%r12)
jne 1bc4 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x74>
mov %rdi,%rsi
mov %rbx,%rdx
mov %r12,%rdi
callq 1f30 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
add $0x20,%rbx
cmp %rbx,%r13
jne 1be9 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x99>
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
endbr64
mov %rax,%rbp
jmpq 1200 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbp, [rsi]
mov r13, [rsi+8]
cmp r13, rbp
jz loc_1A8B
mov r12, rdx
xor eax, eax
xor edi, edi
jmp short loc_1A57
loc_1A00:
lea rax, [rdi+10h]
mov rdx, [r12+8]
mov [rdi], rax
mov rsi, [r12]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag_isra_0; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag) [clone]
mov rax, [rbx+8]
lea rdi, [rax+20h]
mov [rbx+8], rdi
cmp [rbx+10h], rdi
jz short loc_1A74
loc_1A2A:
lea rax, [rdi+10h]
mov rdx, [rbp+8]
mov [rdi], rax
mov rsi, [rbp+0]
add rdx, rsi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag_isra_0; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag) [clone]
add rbp, 20h ; ' '
add qword ptr [rbx+8], 20h ; ' '
cmp r13, rbp
jz short loc_1A8B
loc_1A4F:
mov rdi, [rbx+8]
mov rax, [rbx+10h]
loc_1A57:
cmp rdi, rax
jnz short loc_1A00
mov rsi, rdi
mov rdx, r12
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
mov rdi, [rbx+8]
cmp [rbx+10h], rdi
jnz short loc_1A2A
loc_1A74:
mov rsi, rdi
mov rdx, rbp
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
add rbp, 20h ; ' '
cmp r13, rbp
jnz short loc_1A4F
loc_1A8B:
add rsp, 8
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
retn
endbr64
mov rbp, rax
jmp _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5__cold; func0(std::vector<std::string> const&,std::string const&) [clone] | long long func0(long long a1, _QWORD *a2, _QWORD *a3)
{
_QWORD *v4; // rbp
_QWORD *v5; // r13
_QWORD *v7; // rax
_QWORD *v8; // rdi
long long v9; // rdx
_QWORD *v10; // rdi
long long v11; // rdx
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = (_QWORD *)*a2;
v5 = (_QWORD *)a2[1];
if ( v5 != (_QWORD *)*a2 )
{
v7 = 0LL;
v8 = 0LL;
while ( 1 )
{
if ( v8 == v7 )
{
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, v8, a3);
v10 = *(_QWORD **)(a1 + 8);
if ( *(_QWORD **)(a1 + 16) != v10 )
{
LABEL_4:
v11 = v4[1];
*v10 = v10 + 2;
std::string::_M_construct<char *>(v10, *v4, *v4 + v11);
v4 += 4;
*(_QWORD *)(a1 + 8) += 32LL;
if ( v5 == v4 )
return a1;
goto LABEL_5;
}
}
else
{
v9 = a3[1];
*v8 = v8 + 2;
std::string::_M_construct<char *>(v8, *a3, *a3 + v9);
v10 = (_QWORD *)(*(_QWORD *)(a1 + 8) + 32LL);
*(_QWORD *)(a1 + 8) = v10;
if ( *(_QWORD **)(a1 + 16) != v10 )
goto LABEL_4;
}
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, v10, v4);
v4 += 4;
if ( v5 == v4 )
return a1;
LABEL_5:
v8 = *(_QWORD **)(a1 + 8);
v7 = *(_QWORD **)(a1 + 16);
}
}
return a1;
} | func0:
MOV RDI,RBX
CALL 0x00101ab0
MOV RDI,RBP
LAB_0010122b:
CALL 0x00101200 | /* func0(std::vector<std::string, std::allocator<std::string > > const&, std::string const&) [clone
.cold] */
void func0(vector *param_1,string *param_2)
{
vector<std::string,std::allocator<std::string>> *unaff_RBX;
std::vector<std::string,std::allocator<std::string>>::~vector(unaff_RBX);
/* WARNING: Subroutine does not return */
_Unwind_Resume();
} |
1,003 | func0 |
#include <cassert>
#include <vector>
#include <string>
| std::vector<std::string> func0(const std::vector<std::string>& list, const std::string& element) {
std::vector<std::string> result;
for (const auto& elt : list) {
result.push_back(element);
result.push_back(elt);
}
return result;
}
| int main() {
std::vector<std::string> test1 = func0({"Red", "Green", "Black"}, "c");
std::vector<std::string> expected1 = {"c", "Red", "c", "Green", "c", "Black"};
assert(test1 == expected1);
std::vector<std::string> test2 = func0({"python", "java"}, "program");
std::vector<std::string> expected2 = {"program", "python", "program", "java"};
assert(test2 == expected2);
std::vector<std::string> test3 = func0({"happy", "sad"}, "laugh");
std::vector<std::string> expected3 = {"laugh", "happy", "laugh", "sad"};
assert(test3 == expected3);
return 0;
}
| O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%rax
mov (%rsi),%rbx
mov %rax,(%rsp)
cmp %rax,%rbx
je 1d01 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x161>
lea 0x10(%rsp),%rax
mov %rdx,%r14
xor %esi,%esi
xor %ebp,%ebp
mov %rax,0x8(%rsp)
jmpq 1cc5 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x125>
xchg %ax,%ax
lea 0x10(%rbp),%rdi
mov 0x8(%r14),%r13
mov %rdi,0x0(%rbp)
mov (%r14),%r15
mov %r15,%rax
add %r13,%rax
je 1c20 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x80>
test %r15,%r15
je 1dc8 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x228>
mov %r13,0x10(%rsp)
cmp $0xf,%r13
ja 1d50 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x1b0>
cmp $0x1,%r13
jne 1d30 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x190>
movzbl (%r15),%eax
mov %al,0x10(%rbp)
mov %r13,0x8(%rbp)
movb $0x0,(%rdi,%r13,1)
mov 0x8(%r12),%rax
lea 0x20(%rax),%rbp
mov %rbp,0x8(%r12)
cmp %rbp,0x10(%r12)
je 1ce9 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x149>
lea 0x10(%rbp),%rdi
mov 0x8(%rbx),%r13
mov %rdi,0x0(%rbp)
mov (%rbx),%r15
mov %r15,%rax
add %r13,%rax
je 1c82 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xe2>
test %r15,%r15
je 1dd4 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x234>
mov %r13,0x10(%rsp)
cmp $0xf,%r13
ja 1d90 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x1f0>
cmp $0x1,%r13
jne 1d40 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x1a0>
movzbl (%r15),%eax
mov %al,0x10(%rbp)
mov %r13,0x8(%rbp)
add $0x20,%rbx
movb $0x0,(%rdi,%r13,1)
addq $0x20,0x8(%r12)
cmp %rbx,(%rsp)
je 1d01 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x161>
mov 0x8(%r12),%rbp
mov 0x10(%r12),%rsi
cmp %rbp,%rsi
jne 1c00 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x60>
mov %r14,%rdx
mov %r12,%rdi
callq 20e0 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
mov 0x8(%r12),%rbp
cmp %rbp,0x10(%r12)
jne 1c62 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xc2>
mov %rbx,%rdx
mov %rbp,%rsi
mov %r12,%rdi
callq 20e0 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
add $0x20,%rbx
cmp %rbx,(%rsp)
jne 1cbb <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x11b>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 1de0 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x240>
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
test %r13,%r13
je 1c40 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xa0>
jmp 1d6f <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x1cf>
nopl 0x0(%rax,%rax,1)
test %r13,%r13
je 1ca2 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x102>
jmp 1daf <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x20f>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rsi
xor %edx,%edx
mov %rbp,%rdi
callq 11f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x0(%rbp)
mov %rax,%rdi
mov 0x10(%rsp),%rax
mov %rax,0x10(%rbp)
mov %r13,%rdx
mov %r15,%rsi
callq 1180 <memcpy@plt>
mov 0x10(%rsp),%r13
mov 0x0(%rbp),%rdi
jmpq 1c40 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0xa0>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rsi
xor %edx,%edx
mov %rbp,%rdi
callq 11f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x0(%rbp)
mov %rax,%rdi
mov 0x10(%rsp),%rax
mov %rax,0x10(%rbp)
mov %r13,%rdx
mov %r15,%rsi
callq 1180 <memcpy@plt>
mov 0x10(%rsp),%r13
mov 0x0(%rbp),%rdi
jmpq 1ca2 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_+0x102>
lea 0x1239(%rip),%rdi
callq 1170 <_ZSt19__throw_logic_errorPKc@plt>
lea 0x122d(%rip),%rdi
callq 1170 <_ZSt19__throw_logic_errorPKc@plt>
callq 11b0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1200 <_Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rax, [rsi+8]
mov r12, [rsi]
mov [rsp+58h+var_58], rax
cmp rax, r12
jz loc_1AFA
lea rax, [rsp+58h+var_48]
mov r14, rdx
xor esi, esi
xor ebx, ebx
mov [rsp+58h+var_50], rax
jmp short loc_1A90
loc_1A40:
mov r13, [r12+8]
lea rdi, [rbx+10h]
mov [rbx], rdi
mov r15, [r12]
mov [rsp+58h+var_48], r13
cmp r13, 0Fh
ja loc_1B90
cmp r13, 1
jnz loc_1B40
movzx eax, byte ptr [r15]
mov [rbx+10h], al
loc_1A70:
mov [rbx+8], r13
add r12, 20h ; ' '
mov byte ptr [rdi+r13], 0
add qword ptr [rbp+8], 20h ; ' '
cmp [rsp+58h+var_58], r12
jz short loc_1AFA
loc_1A88:
mov rbx, [rbp+8]
mov rsi, [rbp+10h]
loc_1A90:
cmp rsi, rbx
jz loc_1B20
mov r13, [r14+8]
lea rdi, [rbx+10h]
mov [rbx], rdi
mov r15, [r14]
mov [rsp+58h+var_48], r13
cmp r13, 0Fh
ja loc_1B50
cmp r13, 1
jnz short loc_1B38
movzx eax, byte ptr [r15]
mov [rbx+10h], al
loc_1AC3:
mov [rbx+8], r13
mov byte ptr [rdi+r13], 0
mov rax, [rbp+8]
lea rbx, [rax+20h]
mov [rbp+8], rbx
loc_1AD8:
cmp [rbp+10h], rbx
jnz loc_1A40
mov rdx, r12
mov rsi, rbx
mov rdi, rbp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
add r12, 20h ; ' '
cmp [rsp+58h+var_58], r12
jnz short loc_1A88
loc_1AFA:
mov rax, [rsp+58h+var_40]
sub rax, fs:28h
jnz loc_1BC6
add rsp, 28h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1B20:
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
mov rbx, [rbp+8]
jmp short loc_1AD8
loc_1B38:
test r13, r13
jz short loc_1AC3
jmp short loc_1B6E
loc_1B40:
test r13, r13
jz loc_1A70
jmp short loc_1BAE
loc_1B50:
mov rsi, [rsp+58h+var_50]
xor edx, edx
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbx], rax
mov rdi, rax; dest
mov rax, [rsp+58h+var_48]
mov [rbx+10h], rax
loc_1B6E:
mov rdx, r13; n
mov rsi, r15; src
call _memcpy
mov r13, [rsp+58h+var_48]
mov rdi, [rbx]
jmp loc_1AC3
loc_1B90:
mov rsi, [rsp+58h+var_50]
xor edx, edx
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbx], rax
mov rdi, rax; dest
mov rax, [rsp+58h+var_48]
mov [rbx+10h], rax
loc_1BAE:
mov rdx, r13; n
mov rsi, r15; src
call _memcpy
mov r13, [rsp+58h+var_48]
mov rdi, [rbx]
jmp loc_1A70
loc_1BC6:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5__cold; func0(std::vector<std::string> const&,std::string const&) [clone] | long long func0(long long a1, long long *a2, long long a3)
{
long long v4; // r12
long long *v6; // rsi
long long *v7; // rbx
size_t v8; // r13
void *v9; // rdi
_BYTE *v10; // r15
size_t v11; // r13
_BYTE *v12; // rdi
_BYTE *v13; // r15
long long v14; // rbx
long long v16; // rax
long long v17; // rax
long long v18; // [rsp+0h] [rbp-58h]
_QWORD v19[9]; // [rsp+10h] [rbp-48h] BYREF
v19[1] = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v4 = *a2;
v18 = a2[1];
if ( v18 != *a2 )
{
v6 = 0LL;
v7 = 0LL;
while ( v6 == v7 )
{
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, v6, a3);
v14 = *(_QWORD *)(a1 + 8);
LABEL_13:
if ( *(_QWORD *)(a1 + 16) != v14 )
{
v8 = *(_QWORD *)(v4 + 8);
v9 = (void *)(v14 + 16);
*(_QWORD *)v14 = v14 + 16;
v10 = *(_BYTE **)v4;
v19[0] = v8;
if ( v8 <= 0xF )
{
if ( v8 == 1 )
{
*(_BYTE *)(v14 + 16) = *v10;
goto LABEL_6;
}
if ( v8 )
{
LABEL_24:
memcpy(v9, v10, v8);
v8 = v19[0];
v9 = *(void **)v14;
}
LABEL_6:
*(_QWORD *)(v14 + 8) = v8;
v4 += 32LL;
*((_BYTE *)v9 + v8) = 0;
*(_QWORD *)(a1 + 8) += 32LL;
if ( v18 == v4 )
return a1;
goto LABEL_7;
}
v17 = std::string::_M_create(v14, v19, 0LL);
*(_QWORD *)v14 = v17;
v9 = (void *)v17;
*(_QWORD *)(v14 + 16) = v19[0];
goto LABEL_24;
}
std::vector<std::string>::_M_realloc_insert<std::string const&>(a1, v14, v4);
v4 += 32LL;
if ( v18 == v4 )
return a1;
LABEL_7:
v7 = *(long long **)(a1 + 8);
v6 = *(long long **)(a1 + 16);
}
v11 = *(_QWORD *)(a3 + 8);
v12 = v7 + 2;
*v7 = (long long)(v7 + 2);
v13 = *(_BYTE **)a3;
v19[0] = v11;
if ( v11 > 0xF )
{
v16 = std::string::_M_create(v7, v19, 0LL);
*v7 = v16;
v12 = (_BYTE *)v16;
v7[2] = v19[0];
}
else
{
if ( v11 == 1 )
{
*((_BYTE *)v7 + 16) = *v13;
LABEL_12:
v7[1] = v11;
v12[v11] = 0;
v14 = *(_QWORD *)(a1 + 8) + 32LL;
*(_QWORD *)(a1 + 8) = v14;
goto LABEL_13;
}
if ( !v11 )
goto LABEL_12;
}
memcpy(v12, v13, v11);
v11 = v19[0];
v12 = (_BYTE *)*v7;
goto LABEL_12;
}
return a1;
} | func0:
MOV RDI,RBP
CALL 0x00101be0
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101240
MOV RDI,RBX
LAB_0010123b:
CALL 0x00101200
LAB_00101240:
CALL 0x001011c0 | /* func0(std::vector<std::string, std::allocator<std::string > > const&, std::string const&) [clone
.cold] */
void func0(vector *param_1,string *param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,long param_9)
{
vector<std::string,std::allocator<std::string>> *unaff_RBP;
long in_FS_OFFSET;
std::vector<std::string,std::allocator<std::string>>::~vector(unaff_RBP);
if (param_9 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,004 | func0 | #include <assert.h>
#include <cmath>
#include <complex>
| std::pair<double, double> func0(const std::complex<double>& numbers) {
return std::make_pair(std::abs(numbers), std::arg(numbers));
}
| int main() {
assert(func0(std::complex<double>(1, 0)) == std::make_pair(1.0, 0.0));
assert(func0(std::complex<double>(4, 0)) == std::make_pair(4.0, 0.0));
assert(func0(std::complex<double>(5, 0)) == std::make_pair(5.0, 0.0));
return 0;
}
| O0 | cpp | func0(std::complex<double> const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 15da <_ZSt3argIdET_RKSt7complexIS0_E>
movq %xmm0,%rax
mov %rax,-0x20(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 15a3 <_ZSt3absIdET_RKSt7complexIS0_E>
movq %xmm0,%rax
mov %rax,-0x28(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1611 <_ZSt9make_pairIddESt4pairINSt17__decay_and_stripIT_E6__typeENS1_IT0_E6__typeEEOS2_OS5_>
mov $0x0,%eax
mov $0x0,%edx
movq %xmm0,%rax
movq %xmm1,%rdx
mov %rax,%rcx
mov %rdx,%rbx
movq %rcx,%xmm0
movq %rdx,%xmm1
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 125e <_Z5func0RKSt7complexIdE+0x95>
callq 10b0 <__stack_chk_fail@plt>
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt7complexIdE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZSt3argIdET_RKSt7complexIS0_E; std::arg<double>(std::complex<double> const&)
movq rax, xmm0
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZSt3absIdET_RKSt7complexIS0_E; std::abs<double>(std::complex<double> const&)
movq rax, xmm0
mov [rbp+var_18], rax
lea rdx, [rbp+var_10]
lea rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZSt9make_pairIddESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS1_INS2_IT0_E4typeEE6__typeEEOS3_OS8_; std::make_pair<double,double>(double&&,double&&)
mov eax, 0
mov edx, 0
movq rax, xmm0
movq rdx, xmm1
mov qword ptr [rbp+var_40], rax
mov qword ptr [rbp+var_40+8], rdx
movdqa xmm0, [rbp+var_40]
movq xmm1, rdx
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_123F
call ___stack_chk_fail
locret_123F:
leave
retn | unsigned long long func0(long long a1)
{
double v2; // [rsp+28h] [rbp-18h] BYREF
double v3; // [rsp+30h] [rbp-10h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-8h]
v4 = __readfsqword(0x28u);
v3 = std::arg<double>(a1);
v2 = std::abs<double>(a1);
std::make_pair<double,double>(&v2, &v3);
return v4 - __readfsqword(0x28u);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101588
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101565
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x18],RAX
LEA RDX,[RBP + -0x10]
LEA RAX,[RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001015ab
MOV EAX,0x0
MOV EDX,0x0
MOVQ RAX,XMM0
MOVQ RDX,XMM1
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x38],RDX
MOVDQA XMM0,xmmword ptr [RBP + -0x40]
MOVQ XMM1,RDX
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010123f
CALL 0x00101080
LAB_0010123f:
LEAVE
RET | /* func0(std::complex<double> const&) */
int [16] func0(complex *param_1)
{
long in_FS_OFFSET;
int8 extraout_XMM0_Qa;
int8 in_XMM1_Qa;
int auVar1 [16];
double local_20;
double local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = std::arg<double>(param_1);
local_20 = std::abs<double>(param_1);
std::make_pair<double,double>(&local_20,&local_18);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
auVar1._8_8_ = in_XMM1_Qa;
auVar1._0_8_ = extraout_XMM0_Qa;
return auVar1;
} |
1,005 | func0 | #include <assert.h>
#include <cmath>
#include <complex>
| std::pair<double, double> func0(const std::complex<double>& numbers) {
return std::make_pair(std::abs(numbers), std::arg(numbers));
}
| int main() {
assert(func0(std::complex<double>(1, 0)) == std::make_pair(1.0, 0.0));
assert(func0(std::complex<double>(4, 0)) == std::make_pair(4.0, 0.0));
assert(func0(std::complex<double>(5, 0)) == std::make_pair(5.0, 0.0));
return 0;
}
| O1 | cpp | func0(std::complex<double> const&):
endbr64
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
movsd 0x8(%rdi),%xmm0
movsd (%rdi),%xmm1
callq 10a0 <atan2@plt>
movsd %xmm0,0x8(%rsp)
movsd (%rbx),%xmm0
movsd 0x8(%rbx),%xmm1
callq 10b0 <cabs@plt>
movsd 0x8(%rsp),%xmm1
add $0x10,%rsp
pop %rbx
retq
| _Z5func0RKSt7complexIdE:
endbr64
push rbp
push rbx
sub rsp, 18h
mov rbx, [rdi+8]
mov rbp, [rdi]
movq xmm1, rbp; x
movq xmm0, rbx; y
call _atan2
movsd [rsp+28h+var_20], xmm0
movq xmm0, rbp
movq xmm1, rbx
call _cabs
movsd xmm1, [rsp+28h+var_20]
add rsp, 18h
pop rbx
pop rbp
retn | long long func0(double *a1)
{
double v1; // rbx
double v2; // rbp
v1 = a1[1];
v2 = *a1;
atan2(v1, *a1);
return cabs(v2, v1);
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOVQ XMM1,RBP
MOVQ XMM0,RBX
CALL 0x001010a0
MOVSD qword ptr [RSP + 0x8],XMM0
MOVQ XMM0,RBP
MOVQ XMM1,RBX
CALL 0x001010b0
MOVSD XMM1,qword ptr [RSP + 0x8]
ADD RSP,0x18
POP RBX
POP RBP
RET | /* func0(std::complex<double> const&) */
void func0(complex *param_1)
{
double __x;
__x = *(double *)param_1;
atan2(*(double *)(param_1 + 8),__x);
cabs(__x);
return;
} |
1,006 | func0 | #include <assert.h>
#include <cmath>
#include <complex>
| std::pair<double, double> func0(const std::complex<double>& numbers) {
return std::make_pair(std::abs(numbers), std::arg(numbers));
}
| int main() {
assert(func0(std::complex<double>(1, 0)) == std::make_pair(1.0, 0.0));
assert(func0(std::complex<double>(4, 0)) == std::make_pair(4.0, 0.0));
assert(func0(std::complex<double>(5, 0)) == std::make_pair(5.0, 0.0));
return 0;
}
| O2 | cpp | func0(std::complex<double> const&):
endbr64
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
movsd (%rdi),%xmm1
movsd 0x8(%rdi),%xmm0
callq 10a0 <atan2@plt>
movsd 0x8(%rbx),%xmm1
movsd %xmm0,0x8(%rsp)
movsd (%rbx),%xmm0
callq 10b0 <cabs@plt>
movsd 0x8(%rsp),%xmm2
add $0x10,%rsp
pop %rbx
movapd %xmm2,%xmm1
retq
xchg %ax,%ax
| _Z5func0RKSt7complexIdE:
endbr64
push rbx
sub rsp, 10h
movsd xmm2, qword ptr [rdi+8]
movsd xmm1, qword ptr [rdi]; x
movapd xmm0, xmm2; y
movsd [rsp+18h+var_10], xmm1
movsd [rsp+18h+var_18], xmm2
call _atan2
movsd xmm1, [rsp+18h+var_10]
movsd xmm2, [rsp+18h+var_18]
movq rbx, xmm0
movapd xmm0, xmm1
movapd xmm1, xmm2
call _cabs
add rsp, 10h
movq xmm1, rbx
pop rbx
retn | long long func0(double *a1)
{
double v2; // [rsp+0h] [rbp-18h]
double v3; // [rsp+8h] [rbp-10h]
v3 = *a1;
v2 = a1[1];
atan2(v2, *a1);
return cabs(v3, v2);
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x10
MOVSD XMM2,qword ptr [RDI + 0x8]
MOVSD XMM1,qword ptr [RDI]
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
MOVSD qword ptr [RSP],XMM2
CALL 0x001010a0
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP]
MOVQ RBX,XMM0
MOVAPD XMM0,XMM1
MOVAPD XMM1,XMM2
CALL 0x001010b0
ADD RSP,0x10
MOVQ XMM1,RBX
POP RBX
RET | /* func0(std::complex<double> const&) */
void func0(complex *param_1)
{
double __x;
__x = *(double *)param_1;
atan2(*(double *)(param_1 + 8),__x);
cabs(__x);
return;
} |
1,007 | func0 | #include <assert.h>
#include <cmath>
#include <complex>
| std::pair<double, double> func0(const std::complex<double>& numbers) {
return std::make_pair(std::abs(numbers), std::arg(numbers));
}
| int main() {
assert(func0(std::complex<double>(1, 0)) == std::make_pair(1.0, 0.0));
assert(func0(std::complex<double>(4, 0)) == std::make_pair(4.0, 0.0));
assert(func0(std::complex<double>(5, 0)) == std::make_pair(5.0, 0.0));
return 0;
}
| O3 | cpp | func0(std::complex<double> const&):
endbr64
push %rbx
mov %rdi,%rbx
sub $0x10,%rsp
movsd (%rdi),%xmm1
movsd 0x8(%rdi),%xmm0
callq 10a0 <atan2@plt>
movsd 0x8(%rbx),%xmm1
movsd %xmm0,0x8(%rsp)
movsd (%rbx),%xmm0
callq 10b0 <cabs@plt>
movsd 0x8(%rsp),%xmm2
add $0x10,%rsp
pop %rbx
movapd %xmm2,%xmm1
retq
xchg %ax,%ax
| _Z5func0RKSt7complexIdE:
endbr64
push rbx
sub rsp, 10h
movsd xmm2, qword ptr [rdi+8]
movsd xmm1, qword ptr [rdi]; x
movapd xmm0, xmm2; y
movsd [rsp+18h+var_10], xmm1
movsd [rsp+18h+var_18], xmm2
call _atan2
movsd xmm1, [rsp+18h+var_10]
movsd xmm2, [rsp+18h+var_18]
movq rbx, xmm0
movapd xmm0, xmm1
movapd xmm1, xmm2
call _cabs
add rsp, 10h
movq xmm1, rbx
pop rbx
retn | long long func0(double *a1)
{
double v2; // [rsp+0h] [rbp-18h]
double v3; // [rsp+8h] [rbp-10h]
v3 = *a1;
v2 = a1[1];
atan2(v2, *a1);
return cabs(v3, v2);
} | func0:
ENDBR64
PUSH RBX
SUB RSP,0x10
MOVSD XMM2,qword ptr [RDI + 0x8]
MOVSD XMM1,qword ptr [RDI]
MOVAPD XMM0,XMM2
MOVSD qword ptr [RSP + 0x8],XMM1
MOVSD qword ptr [RSP],XMM2
CALL 0x001010a0
MOVSD XMM1,qword ptr [RSP + 0x8]
MOVSD XMM2,qword ptr [RSP]
MOVQ RBX,XMM0
MOVAPD XMM0,XMM1
MOVAPD XMM1,XMM2
CALL 0x001010b0
ADD RSP,0x10
MOVQ XMM1,RBX
POP RBX
RET | /* func0(std::complex<double> const&) */
void func0(complex *param_1)
{
double __x;
__x = *(double *)param_1;
atan2(*(double *)(param_1 + 8),__x);
cabs(__x);
return;
} |
1,008 | func0 |
#include <vector>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(const std::vector<std::any>& list1) {
int ctr = 0;
for (const auto& i : list1) {
if (i.type() == typeid(int)) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0({1, 2, "abc", 1.2}) == 2);
assert(func0({1, 2, 3}) == 3);
assert(func0({1, 1.2, 4, 5.1}) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<std::any, std::allocator<std::any> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x2c(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1a4e <_ZNKSt6vectorISt3anySaIS0_EE5beginEv>
mov %rax,-0x28(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1aa6 <_ZNKSt6vectorISt3anySaIS0_EE3endEv>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1afe <_ZN9__gnu_cxxneIPKSt3anySt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_>
test %al,%al
je 132f <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xa6>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b62 <_ZNK9__gnu_cxx17__normal_iteratorIPKSt3anySt6vectorIS1_SaIS1_EEEdeEv>
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 19e0 <_ZNKSt3any4typeEv>
lea 0x49ef(%rip),%rsi
mov %rax,%rdi
callq 1828 <_ZNKSt9type_infoeqERKS_>
test %al,%al
je 1321 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x98>
addl $0x1,-0x2c(%rbp)
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b3e <_ZN9__gnu_cxx17__normal_iteratorIPKSt3anySt6vectorIS1_SaIS1_EEEppEv>
jmp 12d7 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x4e>
mov -0x2c(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 1346 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xbd>
callq 1150 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0RKSt6vectorISt3anySaIS0_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_2C], 0
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorISt3anySaIS0_EE5beginEv; std::vector<std::any>::begin(void)
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorISt3anySaIS0_EE3endEv; std::vector<std::any>::end(void)
mov [rbp+var_20], rax
jmp short loc_133E
loc_12F9:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt3anySt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>>::operator*(void)
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax; this
call _ZNKSt3any4typeEv; std::any::type(void)
mov rdx, rax
lea rax, _ZTIi@CXXABI_1_3
mov rsi, rax
mov rdi, rdx
call _ZNKSt9type_infoeqERKS_; std::type_info::operator==(std::type_info const&)
test al, al
jz short loc_1332
add [rbp+var_2C], 1
loc_1332:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKSt3anySt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>>::operator++(void)
loc_133E:
lea rdx, [rbp+var_20]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKSt3anySt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __gnu_cxx::operator!=<std::any const*,std::vector<std::any>>(__gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>> const&,__gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>> const&)
test al, al
jnz short loc_12F9
mov eax, [rbp+var_2C]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_136C
call ___stack_chk_fail
locret_136C:
leave
retn | long long func0(long long a1)
{
long long v1; // rax
unsigned int v3; // [rsp+14h] [rbp-2Ch]
long long v4; // [rsp+18h] [rbp-28h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-20h] BYREF
std::any *v6; // [rsp+30h] [rbp-10h]
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v3 = 0;
v5[1] = a1;
v4 = std::vector<std::any>::begin(a1);
v5[0] = std::vector<std::any>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<std::any const*,std::vector<std::any>>(&v4, v5) )
{
v6 = (std::any *)__gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>>::operator*(&v4);
v1 = std::any::type(v6);
if ( (unsigned __int8)std::type_info::operator==(v1, &`typeinfo for'int) )
++v3;
__gnu_cxx::__normal_iterator<std::any const*,std::vector<std::any>>::operator++(&v4);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x2c],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101c14
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101c60
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0010133e
LAB_001012f9:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x00101d14
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x00101ba6
MOV RDX,RAX
LEA RAX,[0x104ce0]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001019f2
TEST AL,AL
JZ 0x00101332
ADD dword ptr [RBP + -0x2c],0x1
LAB_00101332:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x00101cf0
LAB_0010133e:
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101cb0
TEST AL,AL
JNZ 0x001012f9
MOV EAX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010136c
CALL 0x00101170
LAB_0010136c:
LEAVE
RET | /* func0(std::vector<std::any, std::allocator<std::any> > const&) */
int func0(vector *param_1)
{
char cVar1;
bool bVar2;
type_info *this;
long in_FS_OFFSET;
int local_34;
int8 local_30;
int8 local_28;
vector<std::any,std::allocator<std::any>> *local_20;
any *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_34 = 0;
local_20 = (vector<std::any,std::allocator<std::any>> *)param_1;
local_30 = std::vector<std::any,std::allocator<std::any>>::begin
((vector<std::any,std::allocator<std::any>> *)param_1);
local_28 = std::vector<std::any,std::allocator<std::any>>::end(local_20);
while( true ) {
bVar2 = operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_28);
if (!bVar2) break;
local_18 = (any *)__normal_iterator<std::any_const*,std::vector<std::any,std::allocator<std::any>>>
::operator*((__normal_iterator<std::any_const*,std::vector<std::any,std::allocator<std::any>>>
*)&local_30);
this = (type_info *)std::any::type(local_18);
cVar1 = std::type_info::operator==(this,(type_info *)int::typeinfo);
if (cVar1 != '\0') {
local_34 = local_34 + 1;
}
__normal_iterator<std::any_const*,std::vector<std::any,std::allocator<std::any>>>::operator++
((__normal_iterator<std::any_const*,std::vector<std::any,std::allocator<std::any>>> *)
&local_30);
}
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_34;
} |
1,009 | func0 |
#include <vector>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(const std::vector<std::any>& list1) {
int ctr = 0;
for (const auto& i : list1) {
if (i.type() == typeid(int)) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0({1, 2, "abc", 1.2}) == 2);
assert(func0({1, 2, 3}) == 3);
assert(func0({1, 1.2, 4, 5.1}) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<std::any, std::allocator<std::any> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
cmp %rbp,%rbx
je 12a2 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x39>
mov $0x0,%r12d
lea 0x2a90(%rip),%r13
jmp 12d3 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x6a>
mov $0x0,%r12d
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 130f <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xa6>
mov %r12d,%eax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
add $0x1,%r12d
add $0x10,%rbx
cmp %rbx,%rbp
je 12a8 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x3f>
mov (%rbx),%rcx
mov %r13,%rax
test %rcx,%rcx
je 12ef <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x86>
mov %rsp,%rdx
mov %rbx,%rsi
mov $0x1,%edi
callq *%rcx
mov (%rsp),%rax
mov 0x8(%rax),%rdi
mov 0x2a0e(%rip),%rsi
cmp %rsi,%rdi
je 12c6 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x5d>
cmpb $0x2a,(%rdi)
je 12ca <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x61>
callq 1140 <strcmp@plt>
test %eax,%eax
je 12c6 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x5d>
jmp 12ca <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x61>
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorISt3anySaIS0_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov rbx, [rdi]
mov rbp, [rdi+8]
cmp rbp, rbx
jz short loc_12F7
mov r12d, 0
lea r13, _ZTIv@CXXABI_1_3
jmp short loc_12AF
loc_12A2:
add r12d, 1
loc_12A6:
add rbx, 10h
cmp rbp, rbx
jz short loc_12FD
loc_12AF:
mov rcx, [rbx]
mov rax, r13
test rcx, rcx
jz short loc_12CB
mov rdx, rsp
mov rsi, rbx
mov edi, 1
call rcx
mov rax, [rsp+38h+var_38]
loc_12CB:
mov rdi, [rax+8]; s1
mov rsi, cs:qword_3CE8
cmp rdi, rsi
jz short loc_12A2
cmp byte ptr [rdi], 2Ah ; '*'
jz short loc_12A6
cmp byte ptr [rsi], 2Ah ; '*'
setz al
movzx eax, al
add rsi, rax; s2
call _strcmp
test eax, eax
jz short loc_12A2
jmp short loc_12A6
loc_12F7:
mov r12d, 0
loc_12FD:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_131B
mov eax, r12d
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
retn
loc_131B:
call ___stack_chk_fail | long long func0(long long a1)
{
void ( **v1)(long long, _QWORD, _QWORD *); // rbx
void ( **v2)(long long, _QWORD, _QWORD *); // rbp
unsigned int v3; // r12d
void *v4; // rax
int *v5; // rdi
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v7[1] = __readfsqword(0x28u);
v1 = *(void ( ***)(long long, _QWORD, _QWORD *))a1;
v2 = *(void ( ***)(long long, _QWORD, _QWORD *))(a1 + 8);
if ( v2 == *(void ( ***)(long long, _QWORD, _QWORD *))a1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = &`typeinfo for'void;
if ( *v1 )
{
(*v1)(1LL, v1, v7);
v4 = (void *)v7[0];
}
v5 = (int *)*((_QWORD *)v4 + 1);
if ( v5 == &dword_0 || *(_BYTE *)v5 != 42 && !strcmp((const char *)v5, (const char *)&dword_0) )
++v3;
v1 += 2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP RBP,RBX
JZ 0x001012f7
MOV R12D,0x0
LEA R13,[0x103d20]
JMP 0x001012af
LAB_001012a2:
ADD R12D,0x1
LAB_001012a6:
ADD RBX,0x10
CMP RBP,RBX
JZ 0x001012fd
LAB_001012af:
MOV RCX,qword ptr [RBX]
MOV RAX,R13
TEST RCX,RCX
JZ 0x001012cb
MOV RDX,RSP
MOV RSI,RBX
MOV EDI,0x1
CALL RCX
MOV RAX,qword ptr [RSP]
LAB_001012cb:
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [0x00103ce8]
CMP RDI,RSI
JZ 0x001012a2
CMP byte ptr [RDI],0x2a
JZ 0x001012a6
CMP byte ptr [RSI],0x2a
SETZ AL
MOVZX EAX,AL
ADD RSI,RAX
CALL 0x00101140
TEST EAX,EAX
JZ 0x001012a2
JMP 0x001012a6
LAB_001012f7:
MOV R12D,0x0
LAB_001012fd:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010131b
MOV EAX,R12D
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_0010131b:
CALL 0x00101130 | /* func0(std::vector<std::any, std::allocator<std::any> > const&) */
int func0(vector *param_1)
{
int8 *puVar1;
char *__s1;
int iVar2;
int1 *puVar3;
int8 *puVar4;
int iVar5;
long in_FS_OFFSET;
int1 *local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
puVar4 = *(int8 **)param_1;
puVar1 = *(int8 **)(param_1 + 8);
if (puVar1 == puVar4) {
iVar5 = 0;
}
else {
iVar5 = 0;
do {
puVar3 = void::typeinfo;
if ((code *)*puVar4 != (code *)0x0) {
(*(code *)*puVar4)(1,puVar4,&local_38);
puVar3 = local_38;
}
__s1 = *(char **)(puVar3 + 8);
if ((__s1 == (char *)int::typeinfo._8_8_) ||
((*__s1 != '*' &&
(iVar2 = strcmp(__s1,(char *)(int::typeinfo._8_8_ +
(ulong)(*(char *)int::typeinfo._8_8_ == '*'))), iVar2 == 0)))
) {
iVar5 = iVar5 + 1;
}
puVar4 = puVar4 + 2;
} while (puVar1 != puVar4);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar5;
} |
1,010 | func0 |
#include <vector>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(const std::vector<std::any>& list1) {
int ctr = 0;
for (const auto& i : list1) {
if (i.type() == typeid(int)) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0({1, 2, "abc", 1.2}) == 2);
assert(func0({1, 2, 3}) == 3);
assert(func0({1, 1.2, 4, 5.1}) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<std::any, std::allocator<std::any> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %r13,%rbx
je 1638 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xa8>
mov 0x2745(%rip),%rbp
xor %r12d,%r12d
lea 0x2763(%rip),%r14
nopl (%rax)
mov (%rbx),%rcx
mov %r14,%rax
test %rcx,%rcx
je 15ec <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x5c>
mov %rsp,%rdx
mov %rbx,%rsi
mov $0x1,%edi
callq *%rcx
mov (%rsp),%rax
mov 0x8(%rax),%rdi
cmp %rbp,%rdi
je 1606 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x76>
cmpb $0x2a,(%rdi)
je 160a <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x7a>
mov %rbp,%rsi
callq 1140 <strcmp@plt>
test %eax,%eax
jne 160a <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x7a>
add $0x1,%r12d
add $0x10,%rbx
cmp %rbx,%r13
jne 15d0 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x40>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 163d <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xad>
add $0x10,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1613 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x83>
callq 1130 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorISt3anySaIS0_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbx, [rdi]
mov r12, [rdi+8]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
cmp r12, rbx
jz loc_1658
mov rbp, cs:qword_3CE8
xor r13d, r13d
lea r14, _ZTIv@CXXABI_1_3
nop dword ptr [rax+00000000h]
loc_15E8:
mov rcx, [rbx]
mov rax, r14
test rcx, rcx
jz short loc_1604
mov rdx, rsp
mov rsi, rbx
mov edi, 1
call rcx
mov rax, [rsp+38h+var_38]
loc_1604:
mov rdi, [rax+8]; s1
cmp rbp, rdi
jz short loc_1628
cmp byte ptr [rdi], 2Ah ; '*'
jz short loc_162C
xor esi, esi
cmp byte ptr [rbp+0], 2Ah ; '*'
setz sil
add rsi, rbp; s2
call _strcmp
test eax, eax
jnz short loc_162C
loc_1628:
add r13d, 1
loc_162C:
add rbx, 10h
cmp r12, rbx
jnz short loc_15E8
loc_1635:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_165D
add rsp, 10h
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1658:
xor r13d, r13d
jmp short loc_1635
loc_165D:
call ___stack_chk_fail | long long func0(long long a1)
{
void ( **v1)(long long, _QWORD, _QWORD *); // rbx
void ( **v2)(long long, _QWORD, _QWORD *); // r12
unsigned int v3; // r13d
void *v4; // rax
int *v5; // rdi
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v1 = *(void ( ***)(long long, _QWORD, _QWORD *))a1;
v2 = *(void ( ***)(long long, _QWORD, _QWORD *))(a1 + 8);
v7[1] = __readfsqword(0x28u);
if ( v2 == v1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = &`typeinfo for'void;
if ( *v1 )
{
(*v1)(1LL, v1, v7);
v4 = (void *)v7[0];
}
v5 = (int *)*((_QWORD *)v4 + 1);
if ( &dword_0 == v5 || *(_BYTE *)v5 != 42 && !strcmp((const char *)v5, (const char *)&dword_0) )
++v3;
v1 += 2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP R12,RBX
JZ 0x00101658
MOV RBP,qword ptr [0x00103ce8]
XOR R13D,R13D
LEA R14,[0x103d20]
NOP dword ptr [RAX]
LAB_001015e8:
MOV RCX,qword ptr [RBX]
MOV RAX,R14
TEST RCX,RCX
JZ 0x00101604
MOV RDX,RSP
MOV RSI,RBX
MOV EDI,0x1
CALL RCX
MOV RAX,qword ptr [RSP]
LAB_00101604:
MOV RDI,qword ptr [RAX + 0x8]
CMP RBP,RDI
JZ 0x00101628
CMP byte ptr [RDI],0x2a
JZ 0x0010162c
XOR ESI,ESI
CMP byte ptr [RBP],0x2a
SETZ SIL
ADD RSI,RBP
CALL 0x00101140
TEST EAX,EAX
JNZ 0x0010162c
LAB_00101628:
ADD R13D,0x1
LAB_0010162c:
ADD RBX,0x10
CMP R12,RBX
JNZ 0x001015e8
LAB_00101635:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010165d
ADD RSP,0x10
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101658:
XOR R13D,R13D
JMP 0x00101635
LAB_0010165d:
CALL 0x00101130 | /* func0(std::vector<std::any, std::allocator<std::any> > const&) */
int func0(vector *param_1)
{
int8 *puVar1;
char *__s1;
int8 uVar2;
int iVar3;
int1 *puVar4;
int8 *puVar5;
int iVar6;
long in_FS_OFFSET;
int1 *local_38;
long local_30;
uVar2 = int::typeinfo._8_8_;
puVar5 = *(int8 **)param_1;
puVar1 = *(int8 **)(param_1 + 8);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (puVar1 == puVar5) {
iVar6 = 0;
}
else {
iVar6 = 0;
do {
puVar4 = void::typeinfo;
if ((code *)*puVar5 != (code *)0x0) {
(*(code *)*puVar5)(1,puVar5,&local_38);
puVar4 = local_38;
}
__s1 = *(char **)(puVar4 + 8);
if ((char *)uVar2 == __s1) {
LAB_00101628:
iVar6 = iVar6 + 1;
}
else if (*__s1 != '*') {
iVar3 = strcmp(__s1,(char *)((ulong)(*(char *)uVar2 == '*') + uVar2));
if (iVar3 == 0) goto LAB_00101628;
}
puVar5 = puVar5 + 2;
} while (puVar1 != puVar5);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,011 | func0 |
#include <vector>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(const std::vector<std::any>& list1) {
int ctr = 0;
for (const auto& i : list1) {
if (i.type() == typeid(int)) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0({1, 2, "abc", 1.2}) == 2);
assert(func0({1, 2, 3}) == 3);
assert(func0({1, 1.2, 4, 5.1}) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<std::any, std::allocator<std::any> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %r13,%rbx
je 1678 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xa8>
mov 0x2705(%rip),%rbp
xor %r12d,%r12d
lea 0x2723(%rip),%r14
nopl (%rax)
mov (%rbx),%rcx
mov %r14,%rax
test %rcx,%rcx
je 162c <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x5c>
mov %rsp,%rdx
mov %rbx,%rsi
mov $0x1,%edi
callq *%rcx
mov (%rsp),%rax
mov 0x8(%rax),%rdi
cmp %rbp,%rdi
je 1646 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x76>
cmpb $0x2a,(%rdi)
je 164a <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x7a>
mov %rbp,%rsi
callq 1140 <strcmp@plt>
test %eax,%eax
jne 164a <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x7a>
add $0x1,%r12d
add $0x10,%rbx
cmp %rbx,%r13
jne 1610 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x40>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 167d <_Z5func0RKSt6vectorISt3anySaIS0_EE+0xad>
add $0x10,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
xor %r12d,%r12d
jmp 1653 <_Z5func0RKSt6vectorISt3anySaIS0_EE+0x83>
callq 1130 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKSt6vectorISt3anySaIS0_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbx, [rdi]
mov r12, [rdi+8]
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
cmp r12, rbx
jz loc_1698
mov rbp, cs:qword_3CE8
xor r13d, r13d
lea r14, _ZTIv@CXXABI_1_3
nop dword ptr [rax+00000000h]
loc_1628:
mov rcx, [rbx]
mov rax, r14
test rcx, rcx
jz short loc_1644
mov rdx, rsp
mov rsi, rbx
mov edi, 1
call rcx
mov rax, [rsp+38h+var_38]
loc_1644:
mov rdi, [rax+8]; s1
cmp rbp, rdi
jz short loc_1668
cmp byte ptr [rdi], 2Ah ; '*'
jz short loc_166C
xor esi, esi
cmp byte ptr [rbp+0], 2Ah ; '*'
setz sil
add rsi, rbp; s2
call _strcmp
test eax, eax
jnz short loc_166C
loc_1668:
add r13d, 1
loc_166C:
add rbx, 10h
cmp r12, rbx
jnz short loc_1628
loc_1675:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_169D
add rsp, 10h
mov eax, r13d
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1698:
xor r13d, r13d
jmp short loc_1675
loc_169D:
call ___stack_chk_fail | long long func0(long long a1)
{
void ( **v1)(long long, _QWORD, _QWORD *); // rbx
void ( **v2)(long long, _QWORD, _QWORD *); // r12
unsigned int v3; // r13d
void *v4; // rax
int *v5; // rdi
_QWORD v7[7]; // [rsp+0h] [rbp-38h] BYREF
v1 = *(void ( ***)(long long, _QWORD, _QWORD *))a1;
v2 = *(void ( ***)(long long, _QWORD, _QWORD *))(a1 + 8);
v7[1] = __readfsqword(0x28u);
if ( v2 == v1 )
{
return 0;
}
else
{
v3 = 0;
do
{
v4 = &`typeinfo for'void;
if ( *v1 )
{
(*v1)(1LL, v1, v7);
v4 = (void *)v7[0];
}
v5 = (int *)*((_QWORD *)v4 + 1);
if ( &dword_0 == v5 || *(_BYTE *)v5 != 42 && !strcmp((const char *)v5, (const char *)&dword_0) )
++v3;
v1 += 2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP R12,RBX
JZ 0x00101698
MOV RBP,qword ptr [0x00103ce8]
XOR R13D,R13D
LEA R14,[0x103d20]
NOP dword ptr [RAX]
LAB_00101628:
MOV RCX,qword ptr [RBX]
MOV RAX,R14
TEST RCX,RCX
JZ 0x00101644
MOV RDX,RSP
MOV RSI,RBX
MOV EDI,0x1
CALL RCX
MOV RAX,qword ptr [RSP]
LAB_00101644:
MOV RDI,qword ptr [RAX + 0x8]
CMP RBP,RDI
JZ 0x00101668
CMP byte ptr [RDI],0x2a
JZ 0x0010166c
XOR ESI,ESI
CMP byte ptr [RBP],0x2a
SETZ SIL
ADD RSI,RBP
CALL 0x00101140
TEST EAX,EAX
JNZ 0x0010166c
LAB_00101668:
ADD R13D,0x1
LAB_0010166c:
ADD RBX,0x10
CMP R12,RBX
JNZ 0x00101628
LAB_00101675:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010169d
ADD RSP,0x10
MOV EAX,R13D
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101698:
XOR R13D,R13D
JMP 0x00101675
LAB_0010169d:
CALL 0x00101130 | /* func0(std::vector<std::any, std::allocator<std::any> > const&) */
int func0(vector *param_1)
{
int8 *puVar1;
char *__s1;
int8 uVar2;
int iVar3;
int1 *puVar4;
int8 *puVar5;
int iVar6;
long in_FS_OFFSET;
int1 *local_38;
long local_30;
uVar2 = int::typeinfo._8_8_;
puVar5 = *(int8 **)param_1;
puVar1 = *(int8 **)(param_1 + 8);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (puVar1 == puVar5) {
iVar6 = 0;
}
else {
iVar6 = 0;
do {
puVar4 = void::typeinfo;
if ((code *)*puVar5 != (code *)0x0) {
(*(code *)*puVar5)(1,puVar5,&local_38);
puVar4 = local_38;
}
__s1 = *(char **)(puVar4 + 8);
if ((char *)uVar2 == __s1) {
LAB_00101668:
iVar6 = iVar6 + 1;
}
else if (*__s1 != '*') {
iVar3 = strcmp(__s1,(char *)((ulong)(*(char *)uVar2 == '*') + uVar2));
if (iVar3 == 0) goto LAB_00101668;
}
puVar5 = puVar5 + 2;
} while (puVar1 != puVar5);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return iVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,012 | func0 | #include <iostream>
#include <regex>
#include <vector>
#include <string>
#include <cassert>
using namespace std;
| vector<string> func0(const string &text) {
vector<string> result;
regex pattern("[ae]\\w+");
auto iter = sregex_iterator(text.begin(), text.end(), pattern);
auto end = sregex_iterator();
for (; iter != end; ++iter) {
result.push_back(iter->str());
}
return result;
}
| int main() {
{
vector<string> expected = {"ame"};
vector<string> result = func0("python programe");
assert(result == expected);
}
{
vector<string> expected = {"ame", "anguage"};
vector<string> result = func0("python programe language");
assert(result == expected);
}
{
vector<string> expected = {"assert", "atement"};
vector<string> result = func0("assert statement");
assert(result == expected);
}
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xe8,%rsp
mov %rdi,-0xe8(%rbp)
mov %rsi,-0xf0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0xe8(%rbp),%rax
mov %rax,%rdi
callq 75ce <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC1Ev>
lea -0xe0(%rbp),%rax
mov $0x10,%edx
lea 0x2d3b1(%rip),%rsi
mov %rax,%rdi
callq 79b8 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1EPKcNSt15regex_constants18syntax_option_typeE>
mov -0xf0(%rbp),%rax
mov %rax,%rdi
callq 5b40 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,%rbx
mov -0xf0(%rbp),%rax
mov %rax,%rdi
callq 58b0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,%rsi
lea -0xe0(%rbp),%rdx
lea -0xc0(%rbp),%rax
mov $0x0,%r8d
mov %rdx,%rcx
mov %rbx,%rdx
mov %rax,%rdi
callq 7b26 <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEC1ESA_SA_RKNS_11basic_regexIcSC_EENSt15regex_constants15match_flag_typeE>
movq $0x0,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 7632 <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEC1Ev>
lea -0x80(%rbp),%rdx
lea -0xc0(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 7d66 <_ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEneERKSD_>
test %al,%al
je 5de5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x15c>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 7ff8 <_ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEptEv>
mov %rax,%rcx
lea -0x40(%rbp),%rax
mov $0x0,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 800e <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE3strEm>
lea -0x40(%rbp),%rdx
mov -0xe8(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 8074 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 7d92 <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv>
jmp 5d72 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe9>
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 760e <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED1Ev>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 760e <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED1Ev>
lea -0xe0(%rbp),%rax
mov %rax,%rdi
callq 7a42 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5e99 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x210>
jmp 5e94 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x20b>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57a0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
jmp 5e3e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b5>
endbr64
mov %rax,%rbx
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 760e <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED1Ev>
lea -0xc0(%rbp),%rax
mov %rax,%rdi
callq 760e <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED1Ev>
jmp 5e62 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1d9>
endbr64
mov %rax,%rbx
lea -0xe0(%rbp),%rax
mov %rax,%rdi
callq 7a42 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
jmp 5e7a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f1>
endbr64
mov %rax,%rbx
mov -0xe8(%rbp),%rax
mov %rax,%rdi
callq 7970 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5b00 <_Unwind_Resume@plt>
callq 5960 <__stack_chk_fail@plt>
mov -0xe8(%rbp),%rax
add $0xe8,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0E8h
mov [rbp+var_E8], rdi
mov [rbp+var_F0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_E8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
lea rax, [rbp+var_E0]
mov edx, 10h
lea rcx, aAeW; "[ae]\\w+"
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
mov rax, [rbp+var_F0]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov rbx, rax
mov rax, [rbp+var_F0]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov rsi, rax
lea rdx, [rbp+var_E0]
lea rax, [rbp+var_C0]
mov r8d, 0
mov rcx, rdx
mov rdx, rbx
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEC2ESA_SA_RKNS_11basic_regexIcSC_EENSt15regex_constants15match_flag_typeE; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::regex_iterator(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
pxor xmm0, xmm0
movaps [rbp+var_80], xmm0
movaps [rbp+var_70], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_50], xmm0
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEC2Ev; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::regex_iterator(void)
jmp short loc_4C42
loc_4BEB:
lea rax, [rbp+var_C0]
mov rdi, rax
call _ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEptEv; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator->(void)
mov rcx, rax
lea rax, [rbp+var_40]
mov edx, 0
mov rsi, rcx
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE3strEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(ulong)
lea rdx, [rbp+var_40]
mov rax, [rbp+var_E8]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator++(void)
loc_4C42:
lea rdx, [rbp+var_80]
lea rax, [rbp+var_C0]
mov rsi, rdx
mov rdi, rax
call _ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEneERKSD_; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator!=(std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>> const&)
test al, al
jnz short loc_4BEB
nop
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED2Ev; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator()
lea rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED2Ev; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator()
lea rax, [rbp+var_E0]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz loc_4D2B
jmp loc_4D26
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_4CBC
endbr64
mov rbx, rax
loc_4CBC:
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED2Ev; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator()
lea rax, [rbp+var_C0]
mov rdi, rax
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEED2Ev; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator()
jmp short loc_4CE0
endbr64
mov rbx, rax
loc_4CE0:
lea rax, [rbp+var_E0]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
jmp short loc_4CF8
endbr64
mov rbx, rax
loc_4CF8:
mov rax, [rbp+var_E8]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4D1E
call ___stack_chk_fail
loc_4D1E:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4D26:
call ___stack_chk_fail
loc_4D2B:
mov rax, [rbp+var_E8]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
long long v4; // rax
_BYTE v6[32]; // [rsp+10h] [rbp-E0h] BYREF
_BYTE v7[64]; // [rsp+30h] [rbp-C0h] BYREF
_OWORD v8[4]; // [rsp+70h] [rbp-80h] BYREF
_BYTE v9[40]; // [rsp+B0h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+D8h] [rbp-18h]
v10 = __readfsqword(0x28u);
std::vector<std::string>::vector(a1);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v6, "[ae]\\w+", 16LL);
v2 = std::string::end(a2);
v3 = std::string::begin(a2);
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::regex_iterator(
v7,
v3,
v2,
v6,
0LL);
memset(v8, 0, sizeof(v8));
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::regex_iterator(v8);
while ( (unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator!=(
v7,
v8) )
{
v4 = std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator->(v7);
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::str(v9, v4, 0LL);
std::vector<std::string>::push_back(a1, v9);
std::string::~string(v9);
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator++(v7);
}
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator(v8);
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::~regex_iterator(v7);
std::basic_regex<char,std::regex_traits<char>>::~basic_regex(v6);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RBP + -0xe8],RDI
MOV qword ptr [RBP + -0xf0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0xe8]
MOV RDI,RAX
CALL 0x00106248
LEA RAX,[RBP + -0xe0]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b7e:
CALL 0x001066be
MOV RAX,qword ptr [RBP + -0xf0]
MOV RDI,RAX
CALL 0x001049f0
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0xf0]
MOV RDI,RAX
CALL 0x001047c0
MOV RSI,RAX
LEA RDX,[RBP + -0xe0]
LEA RAX,[RBP + -0xc0]
MOV R8D,0x0
MOV RCX,RDX
MOV RDX,RBX
MOV RDI,RAX
LAB_00104bc4:
CALL 0x00106840
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x001062ac
JMP 0x00104c42
LAB_00104beb:
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
CALL 0x00106d7a
MOV RCX,RAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x0
MOV RSI,RCX
MOV RDI,RAX
LAB_00104c0c:
CALL 0x00106d90
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0xe8]
MOV RSI,RDX
MOV RDI,RAX
LAB_00104c22:
CALL 0x00106df6
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001046c0
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
LAB_00104c3d:
CALL 0x00106aa0
LAB_00104c42:
LEA RDX,[RBP + -0x80]
LEA RAX,[RBP + -0xc0]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00106a74
TEST AL,AL
JNZ 0x00104beb
NOP
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x00106288
LEA RAX,[RBP + -0xc0]
MOV RDI,RAX
CALL 0x00106288
LEA RAX,[RBP + -0xe0]
MOV RDI,RAX
CALL 0x0010675c
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104d2b
JMP 0x00104d26
LAB_00104d26:
CALL 0x00104860
LAB_00104d2b:
MOV RAX,qword ptr [RBP + -0xe8]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
long in_FS_OFFSET;
regex local_e8 [32];
regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
local_c8 [64];
regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [16];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::string,std::allocator<std::string>>::vector
((vector<std::string,std::allocator<std::string>> *)param_1);
/* try { // try from 00104b7e to 00104b82 has its CatchHandler @ 00104cf1 */
std::regex::basic_regex(local_e8,"[ae]\\w+",0x10);
_Var2 = std::string::end();
_Var3 = std::string::begin();
/* try { // try from 00104bc4 to 00104bc8 has its CatchHandler @ 00104cd9 */
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
regex_iterator(local_c8,_Var3,_Var2,local_e8,0);
local_88[0] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[1] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[2] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[3] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[4] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[5] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[6] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[7] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[8] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[9] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[10] = (regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
)0x0;
local_88[0xb] =
(regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>)0x0;
local_88[0xc] =
(regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>)0x0;
local_88[0xd] =
(regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>)0x0;
local_88[0xe] =
(regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>)0x0;
local_88[0xf] =
(regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>)0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
local_58 = (int [16])0x0;
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
regex_iterator(local_88);
while( true ) {
cVar1 = std::
regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
::operator!=(local_c8,(regex_iterator *)local_88);
if (cVar1 == '\0') break;
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
operator->(local_c8);
/* try { // try from 00104c0c to 00104c10 has its CatchHandler @ 00104cb5 */
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::str((ulong)local_48);
/* try { // try from 00104c22 to 00104c26 has its CatchHandler @ 00104ca0 */
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,local_48);
std::string::~string(local_48);
/* try { // try from 00104c3d to 00104c41 has its CatchHandler @ 00104cb5 */
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
operator++(local_c8);
}
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
~regex_iterator(local_88);
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
~regex_iterator(local_c8);
std::regex::~basic_regex(local_e8);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
1,013 | func0 | #include <iostream>
#include <regex>
#include <vector>
#include <string>
#include <cassert>
using namespace std;
| vector<string> func0(const string &text) {
vector<string> result;
regex pattern("[ae]\\w+");
auto iter = sregex_iterator(text.begin(), text.end(), pattern);
auto end = sregex_iterator();
for (; iter != end; ++iter) {
result.push_back(iter->str());
}
return result;
}
| int main() {
{
vector<string> expected = {"ame"};
vector<string> result = func0("python programe");
assert(result == expected);
}
{
vector<string> expected = {"ame", "anguage"};
vector<string> result = func0("python programe language");
assert(result == expected);
}
{
vector<string> expected = {"assert", "atement"};
vector<string> result = func0("assert statement");
assert(result == expected);
}
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x258,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x248(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
lea 0x70(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZNSt6localeC1Ev@plt>
movl $0x10,0x10(%rsp)
lea 0x18(%rsp),%r12
mov %r13,%rsi
mov %r12,%rdi
callq 44d0 <_ZNSt6localeC1ERKS_@plt>
lea 0xb0(%rsp),%rdi
mov 0x10(%rsp),%r8d
mov %r12,%rcx
lea 0x15e10(%rip),%rdx
lea -0x7(%rdx),%rsi
callq 18880 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x1b0(%rsp),%rax
mov %rax,0x20(%rsp)
mov 0x1b8(%rsp),%rax
movq $0x0,0x1b8(%rsp)
mov %rax,0x28(%rsp)
movq $0x0,0x1b0(%rsp)
lea 0x1e0(%rsp),%rdi
callq 7008 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x1c0(%rsp),%rdi
lea 0x1d0(%rsp),%rax
cmp %rax,%rdi
je 4908 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xdf>
callq 4570 <_ZdlPv@plt>
mov 0x1b8(%rsp),%r12
test %r12,%r12
je 4938 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10f>
cmpq $0x0,0x1c6ab(%rip)
je 49b9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x190>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r12)
cmp $0x1,%eax
je 49cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a2>
mov 0x180(%rsp),%rdi
lea 0x190(%rsp),%rax
cmp %rax,%rdi
je 4952 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x129>
callq 4570 <_ZdlPv@plt>
lea 0x70(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x0(%rbp),%rdi
mov %rdi,%rsi
add 0x8(%rbp),%rsi
mov %rdi,0x30(%rsp)
mov %rsi,0x38(%rsp)
lea 0x10(%rsp),%rcx
mov %rcx,0x40(%rsp)
movl $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
lea 0x50(%rsp),%rdx
mov $0x0,%r8d
callq a208 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
jmp 4a12 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1e9>
mov 0x8(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r12)
jmpq 492f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x106>
mov (%r12),%rax
mov %r12,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1c5eb(%rip)
je 4a03 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1da>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r12)
cmp $0x1,%eax
jne 4938 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10f>
mov (%r12),%rax
mov %r12,%rdi
callq *0x18(%rax)
jmpq 4938 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10f>
mov 0xc(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r12)
jmp 49eb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c2>
test %al,%al
je 4b6d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x344>
movl $0x0,0x8c(%rsp)
movq $0x0,0x70(%rsp)
movq $0x0,0x78(%rsp)
movq $0x0,0x80(%rsp)
movl $0x0,0x88(%rsp)
movq $0x0,0x90(%rsp)
movq $0x0,0x98(%rsp)
movq $0x0,0xa0(%rsp)
movq $0x0,0xa8(%rsp)
lea 0x70(%rsp),%rbp
lea 0x30(%rsp),%rdi
mov %rbp,%rsi
callq 60e2 <_ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEeqERKSD_>
test %al,%al
jne 4d53 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x52a>
mov 0x58(%rsp),%rdx
mov 0x50(%rsp),%rax
cmp %rax,%rdx
je 4ab3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28a>
mov %rdx,%rcx
sub %rax,%rcx
cmp $0x48,%rcx
jne 4ab7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28e>
lea -0x48(%rdx),%rax
cmpb $0x0,0x10(%rax)
jne 4c6e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x445>
lea 0xc0(%rsp),%rax
mov %rax,0xb0(%rsp)
movq $0x0,0xb8(%rsp)
movb $0x0,0xc0(%rsp)
mov 0x8(%rbx),%rsi
cmp 0x10(%rbx),%rsi
je 4d20 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f7>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov 0xb0(%rsp),%rax
lea 0xc0(%rsp),%rdx
cmp %rdx,%rax
je 4d0e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4e5>
mov %rax,(%rsi)
mov 0xc0(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0xb8(%rsp),%rax
mov %rax,0x8(%rsi)
addq $0x20,0x8(%rbx)
lea 0x30(%rsp),%rdi
callq a84e <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv>
jmpq 4a83 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x25a>
endbr64
mov %rax,%rbp
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x70(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov %rbx,%rdi
callq 5e0a <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov %rbp,%rdi
callq 46c0 <_Unwind_Resume@plt>
movl $0x0,0x8c(%rsp)
movq $0x0,0x70(%rsp)
movq $0x0,0x78(%rsp)
movq $0x0,0x80(%rsp)
movl $0x0,0x88(%rsp)
movq $0x0,0x90(%rsp)
movq $0x0,0x98(%rsp)
movq $0x0,0xa0(%rsp)
movq $0x0,0xa8(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
movl $0x0,0x48(%rsp)
lea 0x90(%rsp),%rsi
lea 0x50(%rsp),%rdi
callq 5f50 <_ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE_>
mov 0xa8(%rsp),%rax
mov %rax,0x68(%rsp)
mov 0x90(%rsp),%rdi
test %rdi,%rdi
je 4a1a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f1>
callq 4570 <_ZdlPv@plt>
jmpq 4a1a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f1>
endbr64
mov %rax,%rbp
mov 0x90(%rsp),%rdi
test %rdi,%rdi
je 4c47 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41e>
callq 4570 <_ZdlPv@plt>
mov 0x50(%rsp),%rdi
test %rdi,%rdi
je 4c56 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x42d>
callq 4570 <_ZdlPv@plt>
lea 0x10(%rsp),%rdi
callq 5e50 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
jmpq 4b5d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x334>
endbr64
mov %rax,%rbp
jmp 4c47 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41e>
mov (%rax),%r13
mov 0x8(%rax),%r12
lea 0xc0(%rsp),%rax
mov %rax,0xb0(%rsp)
sub %r13,%r12
mov %r12,0x8(%rsp)
cmp $0xf,%r12
ja 4cc3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x49a>
cmp $0x1,%r12
jne 4cff <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4d6>
movzbl 0x0(%r13),%eax
mov %al,0xc0(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0xb8(%rsp)
mov 0xb0(%rsp),%rdx
movb $0x0,(%rdx,%rax,1)
jmpq 4ae5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2bc>
lea 0x8(%rsp),%rsi
lea 0xb0(%rsp),%rdi
mov $0x0,%edx
callq 46d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,%rdi
mov %rax,0xb0(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0xc0(%rsp)
mov %r12,%rdx
mov %r13,%rsi
callq 4540 <memcpy@plt>
jmp 4ca5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x47c>
test %r12,%r12
je 4ca5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x47c>
lea 0xc0(%rsp),%rdi
jmp 4cf2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4c9>
movdqa 0xc0(%rsp),%xmm0
movups %xmm0,0x10(%rsi)
jmpq 4b22 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2f9>
lea 0xb0(%rsp),%rdx
mov %rbx,%rdi
callq 6288 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
mov 0xb0(%rsp),%rdi
lea 0xc0(%rsp),%rax
cmp %rax,%rdi
je 4b33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30a>
callq 4570 <_ZdlPv@plt>
jmpq 4b33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x30a>
mov 0x50(%rsp),%rdi
test %rdi,%rdi
je 4d62 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x539>
callq 4570 <_ZdlPv@plt>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4d85 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x55c>
cmpq $0x0,0x1c254(%rip)
je 4db7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x58e>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4dc2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x599>
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x248(%rsp),%rax
xor %fs:0x28,%rax
jne 4e3e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x615>
mov %rbx,%rax
add $0x258,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmp 4d80 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x557>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1c1f4(%rip)
je 4df1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5c8>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4d85 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x55c>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 4d85 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x55c>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4de0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5b7>
endbr64
mov %rax,%rbp
mov 0xb0(%rsp),%rdi
lea 0xc0(%rsp),%rax
cmp %rax,%rdi
je 4e1d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5f4>
callq 4570 <_ZdlPv@plt>
mov 0x50(%rsp),%rdi
test %rdi,%rdi
je 4c56 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x42d>
callq 4570 <_ZdlPv@plt>
jmpq 4c56 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x42d>
endbr64
mov %rax,%rbp
jmp 4e1d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5f4>
callq 45d0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r13
push r12
push rbx
sub rsp, 250h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea r12, [rbp+var_258]
mov rdi, r12; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_250], 0
mov [rbp+var_248], 0
lea rdi, [rbp+var_1C0]
mov r8d, 10h
mov rcx, r12
lea rdx, aAeW+7; ""
lea rsi, [rdx-7]
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
mov rdx, [rbp+var_C0]
mov rax, [rbp+var_B8]
mov [rbp+var_B8], 0
mov [rbp+var_C0], 0
mov [rbp+var_250], rdx
mov r12, [rbp+var_248]
mov [rbp+var_248], rax
test r12, r12
jz short loc_48EE
lea rcx, [r12+8]
mov rdx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_4A15
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_4A40
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_48E5:
cmp eax, 1
jz loc_4A4E
loc_48EE:
mov [rbp+var_260], 10h
lea rdi, [rbp+var_90]
call _ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED2Ev; std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base()
mov rdi, [rbp+var_B0]; void *
lea rax, [rbp+var_A0]
cmp rdi, rax
jz short loc_4927
mov rax, [rbp+var_A0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4927:
mov r12, [rbp+var_B8]
test r12, r12
jz short loc_4973
lea rcx, [r12+8]
mov rdx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_4A5B
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_4A86
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_496A:
cmp eax, 1
jz loc_4A94
loc_4973:
mov rdi, [rbp+var_F0]; void *
lea rax, [rbp+var_E0]
cmp rdi, rax
jz short loc_4996
mov rax, [rbp+var_E0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4996:
mov rdi, [r14]
mov rsi, rdi
add rsi, [r14+8]
mov [rbp+var_240], rdi
mov [rbp+var_238], rsi
lea rcx, [rbp+var_260]
mov [rbp+var_230], rcx
mov [rbp+var_228], 0
mov [rbp+var_220], 0
mov [rbp+var_218], 0
mov [rbp+var_210], 0
mov [rbp+var_208], 0
lea rdx, [rbp+var_220]
sub rsp, 8
push 0
mov r9d, 0
mov r8d, 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
jmp loc_4AA1
loc_4A15:
mov dword ptr [r12+8], 0
mov dword ptr [r12+0Ch], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_48EE
loc_4A40:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_48E5
loc_4A4E:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_48EE
loc_4A5B:
mov dword ptr [r12+8], 0
mov dword ptr [r12+0Ch], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_4973
loc_4A86:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_496A
loc_4A94:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_4973
loc_4AA1:
add rsp, 10h
test al, al
jz loc_4C06
loc_4AAD:
mov [rbp+var_1F0], 0
mov [rbp+var_1E8], 0
mov [rbp+var_200], 0
mov [rbp+var_1F8], 0
mov [rbp+var_1E0], 0
mov [rbp+var_1D8], 0
mov [rbp+var_1D0], 0
mov [rbp+var_1C8], 0
lea rax, [rbp+var_200]
mov r14, rax
loc_4B0F:
lea rdi, [rbp+var_240]
mov rsi, r14
call _ZNKSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEeqERKSD_; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>> const&)
test al, al
jnz loc_4E81
mov rdx, [rbp+var_218]
mov rax, [rbp+var_220]
cmp rdx, rax
jz short loc_4B45
mov rcx, rdx
sub rcx, rax
cmp rcx, 48h ; 'H'
jnz short loc_4B49
loc_4B45:
lea rax, [rdx-48h]
loc_4B49:
cmp byte ptr [rax+10h], 0
jnz loc_4CEB
lea rax, [rbp+var_1B0]
mov [rbp+var_1C0], rax
mov [rbp+var_1B8], 0
mov byte ptr [rbp+var_1B0], 0
loc_4B73:
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz loc_4E3E
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rbp+var_1C0]
lea rcx, [rbp+var_1B0]
cmp rax, rcx
jz loc_4D95
mov [rsi], rax
mov rax, [rbp+var_1B0]
mov [rsi+10h], rax
loc_4BAD:
mov rax, [rbp+var_1B8]
mov [rsi+8], rax
add qword ptr [rbx+8], 20h ; ' '
jmp loc_4E70
endbr64
mov r14, rax
mov rdi, [rbp+var_248]
test rdi, rdi
jz short loc_4BDA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4BDA:
lea rdi, [rbp+var_258]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
loc_4BE6:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz loc_4F14
call ___stack_chk_fail
loc_4C06:
mov [rbp+var_1F0], 0
mov [rbp+var_1E8], 0
mov [rbp+var_200], 0
mov [rbp+var_1F8], 0
mov [rbp+var_1E0], 0
mov [rbp+var_1D8], 0
mov [rbp+var_1D0], 0
mov [rbp+var_1C8], 0
mov [rbp+var_240], 0
mov [rbp+var_238], 0
mov [rbp+var_230], 0
mov [rbp+var_228], 0
lea rsi, [rbp+var_1E0]
lea rdi, [rbp+var_220]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE_; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>> const&)
mov rax, [rbp+var_1C8]
mov [rbp+var_208], rax
jmp loc_4AAD
endbr64
mov r13, rax
lea rdi, [rbp+var_1E0]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov r14, r13
loc_4CC5:
lea rdi, [rbp+var_220]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
loc_4CD1:
lea rdi, [rbp+var_260]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
jmp loc_4BE6
endbr64
mov r14, rax
jmp short loc_4CC5
loc_4CEB:
mov r13, [rax]
mov r12, [rax+8]
lea rax, [rbp+var_1B0]
mov [rbp+var_1C0], rax
mov [rbp+var_1B8], 0
sub r12, r13
mov [rbp+var_268], r12
cmp r12, 0Fh
ja short loc_4D4A
cmp r12, 1
jnz short loc_4D87
movzx eax, byte ptr [r13+0]
mov byte ptr [rbp+var_1B0], al
loc_4D2C:
mov rax, [rbp+var_268]
mov [rbp+var_1B8], rax
mov rdx, [rbp+var_1C0]
mov byte ptr [rdx+rax], 0
jmp loc_4B73
loc_4D4A:
lea rsi, [rbp+var_268]
lea rdi, [rbp+var_1C0]
mov edx, 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov rdi, rax; dest
mov [rbp+var_1C0], rax
mov rax, [rbp+var_268]
mov [rbp+var_1B0], rax
loc_4D7A:
mov rdx, r12; n
mov rsi, r13; src
call _memcpy
jmp short loc_4D2C
loc_4D87:
test r12, r12
jz short loc_4D2C
lea rdi, [rbp+var_1B0]
jmp short loc_4D7A
loc_4D95:
mov rax, [rbp+var_1B8]
add rax, 1
cmp eax, 8
jnb short loc_4DED
test al, 4
jnz short loc_4DD5
test eax, eax
jz loc_4BAD
movzx edi, byte ptr [rbp+var_1B0]
mov [rsi+10h], dil
test al, 2
jz loc_4BAD
mov eax, eax
movzx ecx, word ptr [rcx+rax-2]
mov [rdx+rax-2], cx
jmp loc_4BAD
loc_4DD5:
mov edi, dword ptr [rbp+var_1B0]
mov [rsi+10h], edi
mov eax, eax
mov ecx, [rcx+rax-4]
mov [rdx+rax-4], ecx
jmp loc_4BAD
loc_4DED:
mov rdi, [rbp+var_1B0]
mov [rsi+10h], rdi
mov edi, eax
mov r8, [rcx+rdi-8]
mov [rdx+rdi-8], r8
lea r8, [rdx+8]
and r8, 0FFFFFFFFFFFFFFF8h
sub rdx, r8
sub rcx, rdx
add eax, edx
and eax, 0FFFFFFF8h
cmp eax, 8
jb loc_4BAD
and eax, 0FFFFFFF8h
mov edx, 0
loc_4E28:
mov edi, edx
mov r9, [rcx+rdi]
mov [r8+rdi], r9
add edx, 8
cmp edx, eax
jb short loc_4E28
jmp loc_4BAD
loc_4E3E:
lea rdx, [rbp+var_1C0]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string &&)
mov rdi, [rbp+var_1C0]; void *
lea rax, [rbp+var_1B0]
cmp rdi, rax
jz short loc_4E70
mov rax, [rbp+var_1B0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4E70:
lea rdi, [rbp+var_240]
call _ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv; std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator++(void)
jmp loc_4B0F
loc_4E81:
mov rdi, [rbp+var_220]; void *
test rdi, rdi
jz short loc_4E9C
mov rsi, [rbp+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4E9C:
mov rdi, [rbp+var_248]
test rdi, rdi
jz short loc_4EAD
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4EAD:
lea rdi, [rbp+var_258]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_4F1C
mov rax, rbx
lea rsp, [rbp-20h]
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
endbr64
mov r13, rax
lea rdi, [rbp+var_1C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov r14, r13
loc_4EEE:
lea rdi, [rbp+var_1E0]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
lea rdi, [rbp+var_220]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
jmp loc_4CD1
endbr64
mov r14, rax
jmp short loc_4EEE
loc_4F14:
mov rdi, r14; struct _Unwind_Exception *
call __Unwind_Resume
loc_4F1C:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2)
{
char *v4; // rsi
long long v5; // rdx
long long v6; // rax
long long v7; // r12
volatile signed __int32 *v8; // rcx
long long v9; // rdx
signed __int32 v10; // eax
_DWORD *v11; // r12
volatile signed __int32 *v12; // rcx
long long v13; // rdx
signed __int32 v14; // eax
long long v15; // rsi
_BYTE *v17; // rax
void **v18; // rsi
_QWORD *v19; // rdx
_BYTE *v20; // r13
long long v21; // r12
size_t v22; // r12
_QWORD *v23; // rdi
unsigned int v24; // eax
unsigned long long v25; // r8
char *v26; // rdx
char *v27; // rcx
unsigned int v28; // eax
unsigned int v29; // eax
unsigned int v30; // edx
size_t v32; // [rsp+8h] [rbp-268h] BYREF
int v33; // [rsp+10h] [rbp-260h] BYREF
char v34[8]; // [rsp+18h] [rbp-258h] BYREF
long long v35; // [rsp+20h] [rbp-250h]
long long v36; // [rsp+28h] [rbp-248h]
long long v37; // [rsp+30h] [rbp-240h] BYREF
long long v38; // [rsp+38h] [rbp-238h]
int *v39; // [rsp+40h] [rbp-230h]
int v40; // [rsp+48h] [rbp-228h]
void *v41; // [rsp+50h] [rbp-220h] BYREF
_BYTE *v42; // [rsp+58h] [rbp-218h]
long long v43; // [rsp+60h] [rbp-210h]
long long v44; // [rsp+68h] [rbp-208h]
long long v45; // [rsp+70h] [rbp-200h] BYREF
long long v46; // [rsp+78h] [rbp-1F8h]
long long v47; // [rsp+80h] [rbp-1F0h]
long long v48; // [rsp+88h] [rbp-1E8h]
long long v49; // [rsp+90h] [rbp-1E0h] BYREF
long long v50; // [rsp+98h] [rbp-1D8h]
long long v51; // [rsp+A0h] [rbp-1D0h]
long long v52; // [rsp+A8h] [rbp-1C8h]
void *v53; // [rsp+B0h] [rbp-1C0h] BYREF
void *v54; // [rsp+B8h] [rbp-1B8h]
_QWORD v55[24]; // [rsp+C0h] [rbp-1B0h] BYREF
void *v56; // [rsp+180h] [rbp-F0h]
long long v57; // [rsp+190h] [rbp-E0h] BYREF
long long v58; // [rsp+1B0h] [rbp-C0h]
long long v59; // [rsp+1B8h] [rbp-B8h]
void *v60; // [rsp+1C0h] [rbp-B0h]
long long v61; // [rsp+1D0h] [rbp-A0h] BYREF
char v62[104]; // [rsp+1E0h] [rbp-90h] BYREF
unsigned long long v63; // [rsp+248h] [rbp-28h]
v63 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
std::locale::locale((std::locale *)v34);
v35 = 0LL;
v36 = 0LL;
v4 = "[ae]\\w+";
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v53, "[ae]\\w+", "", v34, 16LL);
v5 = v58;
v6 = v59;
v59 = 0LL;
v58 = 0LL;
v35 = v5;
v7 = v36;
v36 = v6;
if ( v7 )
{
v8 = (volatile signed __int32 *)(v7 + 8);
v9 = *(_QWORD *)(v7 + 8);
if ( v9 == 0x100000001LL )
{
*(_DWORD *)(v7 + 8) = 0;
*(_DWORD *)(v7 + 12) = 0;
(*(void ( **)(long long, char *, long long, volatile signed __int32 *))(*(_QWORD *)v7 + 16LL))(
v7,
v4,
0x100000001LL,
v8);
(*(void ( **)(long long))(*(_QWORD *)v7 + 24LL))(v7);
}
else
{
if ( _libc_single_threaded )
{
v10 = *(_DWORD *)(v7 + 8);
v9 = (unsigned int)(v10 - 1);
*(_DWORD *)(v7 + 8) = v9;
}
else
{
v10 = _InterlockedExchangeAdd(v8, 0xFFFFFFFF);
}
if ( v10 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v7, v4, v9, v8);
}
}
v33 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v62);
if ( v60 != &v61 )
{
v4 = (char *)(v61 + 1);
operator delete(v60, v61 + 1);
}
v11 = (_DWORD *)v59;
if ( v59 )
{
v12 = (volatile signed __int32 *)(v59 + 8);
v13 = *(_QWORD *)(v59 + 8);
if ( v13 == 0x100000001LL )
{
*(_DWORD *)(v59 + 8) = 0;
v11[3] = 0;
(*(void ( **)(_DWORD *, char *, long long, volatile signed __int32 *))(*(_QWORD *)v11 + 16LL))(
v11,
v4,
0x100000001LL,
v12);
(*(void ( **)(_DWORD *))(*(_QWORD *)v11 + 24LL))(v11);
}
else
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v59 + 8);
v13 = (unsigned int)(v14 - 1);
*(_DWORD *)(v59 + 8) = v13;
}
else
{
v14 = _InterlockedExchangeAdd(v12, 0xFFFFFFFF);
}
if ( v14 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v11, v4, v13, v12);
}
}
if ( v56 != &v57 )
operator delete(v56, v57 + 1);
v15 = a2[1] + *a2;
v37 = *a2;
v38 = v15;
v39 = &v33;
v40 = 0;
v41 = 0LL;
v42 = 0LL;
v43 = 0LL;
v44 = 0LL;
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v37,
v15,
(unsigned int)&v41,
(unsigned int)&v33,
0,
0,
0) )
{
v47 = 0LL;
v48 = 0LL;
v45 = 0LL;
v46 = 0LL;
v49 = 0LL;
v50 = 0LL;
v51 = 0LL;
v52 = 0LL;
v37 = 0LL;
v38 = 0LL;
v39 = 0LL;
v40 = 0;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(&v41, &v49);
v44 = v52;
}
v47 = 0LL;
v48 = 0LL;
v45 = 0LL;
v46 = 0LL;
v49 = 0LL;
v50 = 0LL;
v51 = 0LL;
v52 = 0LL;
while ( !(unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(
&v37,
&v45) )
{
v17 = v41;
if ( v42 == v41 || v42 - (_BYTE *)v41 == 72 )
v17 = v42 - 72;
if ( !v17[16] )
{
v53 = v55;
v54 = 0LL;
LOBYTE(v55[0]) = 0;
goto LABEL_31;
}
v20 = *(_BYTE **)v17;
v21 = *((_QWORD *)v17 + 1);
v53 = v55;
v54 = 0LL;
v22 = v21 - (_QWORD)v20;
v32 = v22;
if ( v22 > 0xF )
{
v23 = (_QWORD *)std::string::_M_create(&v53, &v32, 0LL);
v53 = v23;
v55[0] = v32;
LABEL_40:
memcpy(v23, v20, v22);
goto LABEL_38;
}
if ( v22 != 1 )
{
if ( !v22 )
goto LABEL_38;
v23 = v55;
goto LABEL_40;
}
LOBYTE(v55[0]) = *v20;
LABEL_38:
v54 = (void *)v32;
*((_BYTE *)v53 + v32) = 0;
LABEL_31:
v18 = (void **)a1[1];
if ( v18 == (void **)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v18, &v53);
if ( v53 != v55 )
operator delete(v53, v55[0] + 1LL);
}
else
{
v19 = v18 + 2;
*v18 = v18 + 2;
if ( v53 == v55 )
{
v24 = (_DWORD)v54 + 1;
if ( (unsigned int)((_DWORD)v54 + 1) >= 8 )
{
v18[2] = (void *)v55[0];
*(_QWORD *)((char *)v19 + v24 - 8) = *(_QWORD *)((char *)&v55[-1] + v24);
v25 = (unsigned long long)(v18 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v26 = (char *)v19 - v25;
v27 = (char *)((char *)v55 - v26);
v28 = ((_DWORD)v26 + v24) & 0xFFFFFFF8;
if ( v28 >= 8 )
{
v29 = v28 & 0xFFFFFFF8;
v30 = 0;
do
{
*(_QWORD *)(v25 + v30) = *(_QWORD *)&v27[v30];
v30 += 8;
}
while ( v30 < v29 );
}
}
else if ( (v24 & 4) != 0 )
{
*((_DWORD *)v18 + 4) = v55[0];
*(_DWORD *)((char *)v19 + v24 - 4) = *(_DWORD *)((char *)&v54 + v24 + 4);
}
else if ( (_DWORD)v54 != -1 )
{
*((_BYTE *)v18 + 16) = v55[0];
if ( (v24 & 2) != 0 )
*(_WORD *)((char *)v19 + v24 - 2) = *(_WORD *)((char *)&v54 + v24 + 6);
}
}
else
{
*v18 = v53;
v18[2] = (void *)v55[0];
}
v18[1] = v54;
a1[1] += 32LL;
}
std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator++(&v37);
}
if ( v41 )
operator delete(v41, v43 - (_QWORD)v41);
if ( v36 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale((std::locale *)v34);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x250
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R12,[RBP + -0x258]
MOV RDI,R12
CALL 0x001046f0
MOV qword ptr [RBP + -0x250],0x0
MOV qword ptr [RBP + -0x248],0x0
LEA RDI,[RBP + -0x1c0]
MOV R8D,0x10
MOV RCX,R12
LEA RDX,[0x1195e6]
LEA RSI,[RDX + -0x7]
LAB_0010486b:
CALL 0x00116e20
MOV RDX,qword ptr [RBP + -0xc0]
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0xb8],0x0
MOV qword ptr [RBP + -0xc0],0x0
MOV qword ptr [RBP + -0x250],RDX
MOV R12,qword ptr [RBP + -0x248]
MOV qword ptr [RBP + -0x248],RAX
TEST R12,R12
JZ 0x001048ee
LEA RCX,[R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104a15
CMP byte ptr [0x0011f460],0x0
JZ 0x00104a40
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_001048e5:
CMP EAX,0x1
JZ 0x00104a4e
LAB_001048ee:
MOV dword ptr [RBP + -0x260],0x10
LEA RDI,[RBP + -0x90]
CALL 0x0010687a
MOV RDI,qword ptr [RBP + -0xb0]
LEA RAX,[RBP + -0xa0]
CMP RDI,RAX
JZ 0x00104927
MOV RAX,qword ptr [RBP + -0xa0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_00104927:
MOV R12,qword ptr [RBP + -0xb8]
TEST R12,R12
JZ 0x00104973
LEA RCX,[R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104a5b
CMP byte ptr [0x0011f460],0x0
JZ 0x00104a86
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_0010496a:
CMP EAX,0x1
JZ 0x00104a94
LAB_00104973:
MOV RDI,qword ptr [RBP + -0xf0]
LEA RAX,[RBP + -0xe0]
CMP RDI,RAX
JZ 0x00104996
MOV RAX,qword ptr [RBP + -0xe0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_00104996:
MOV RDI,qword ptr [R14]
MOV RSI,RDI
ADD RSI,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x240],RDI
MOV qword ptr [RBP + -0x238],RSI
LEA RCX,[RBP + -0x260]
MOV qword ptr [RBP + -0x230],RCX
MOV dword ptr [RBP + -0x228],0x0
MOV qword ptr [RBP + -0x220],0x0
MOV qword ptr [RBP + -0x218],0x0
MOV qword ptr [RBP + -0x210],0x0
MOV qword ptr [RBP + -0x208],0x0
LEA RDX,[RBP + -0x220]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x0
MOV R8D,0x0
LAB_00104a0b:
CALL 0x0010c2d3
JMP 0x00104aa1
LAB_00104a15:
MOV dword ptr [R12 + 0x8],0x0
MOV dword ptr [R12 + 0xc],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x001048ee
LAB_00104a40:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x001048e5
LAB_00104a4e:
MOV RDI,R12
CALL 0x00105f28
JMP 0x001048ee
LAB_00104a5b:
MOV dword ptr [R12 + 0x8],0x0
MOV dword ptr [R12 + 0xc],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x00104973
LAB_00104a86:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x0010496a
LAB_00104a94:
MOV RDI,R12
CALL 0x00105f28
JMP 0x00104973
LAB_00104aa1:
ADD RSP,0x10
TEST AL,AL
JZ 0x00104c06
LAB_00104aad:
MOV qword ptr [RBP + -0x1f0],0x0
MOV qword ptr [RBP + -0x1e8],0x0
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
MOV qword ptr [RBP + -0x1e0],0x0
MOV qword ptr [RBP + -0x1d8],0x0
MOV qword ptr [RBP + -0x1d0],0x0
MOV qword ptr [RBP + -0x1c8],0x0
LEA RAX,[RBP + -0x200]
MOV R14,RAX
LAB_00104b0f:
LEA RDI,[RBP + -0x240]
MOV RSI,R14
CALL 0x0010625e
TEST AL,AL
JNZ 0x00104e81
MOV RDX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x220]
CMP RDX,RAX
JZ 0x00104b45
MOV RCX,RDX
SUB RCX,RAX
CMP RCX,0x48
JNZ 0x00104b49
LAB_00104b45:
LEA RAX,[RDX + -0x48]
LAB_00104b49:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00104ceb
LEA RAX,[RBP + -0x1b0]
MOV qword ptr [RBP + -0x1c0],RAX
MOV qword ptr [RBP + -0x1b8],0x0
MOV byte ptr [RBP + -0x1b0],0x0
LAB_00104b73:
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x00104e3e
LEA RDX,[RSI + 0x10]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RCX,[RBP + -0x1b0]
CMP RAX,RCX
JZ 0x00104d95
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBP + -0x1b0]
MOV qword ptr [RSI + 0x10],RAX
LAB_00104bad:
MOV RAX,qword ptr [RBP + -0x1b8]
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [RBX + 0x8],0x20
JMP 0x00104e70
LAB_00104c06:
MOV qword ptr [RBP + -0x1f0],0x0
MOV qword ptr [RBP + -0x1e8],0x0
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
MOV qword ptr [RBP + -0x1e0],0x0
MOV qword ptr [RBP + -0x1d8],0x0
MOV qword ptr [RBP + -0x1d0],0x0
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x240],0x0
MOV qword ptr [RBP + -0x238],0x0
MOV qword ptr [RBP + -0x230],0x0
MOV dword ptr [RBP + -0x228],0x0
LEA RSI,[RBP + -0x1e0]
LEA RDI,[RBP + -0x220]
LAB_00104c97:
CALL 0x00107db0
MOV RAX,qword ptr [RBP + -0x1c8]
MOV qword ptr [RBP + -0x208],RAX
JMP 0x00104aad
LAB_00104ceb:
MOV R13,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
LEA RAX,[RBP + -0x1b0]
MOV qword ptr [RBP + -0x1c0],RAX
MOV qword ptr [RBP + -0x1b8],0x0
SUB R12,R13
MOV qword ptr [RBP + -0x268],R12
CMP R12,0xf
JA 0x00104d4a
CMP R12,0x1
JNZ 0x00104d87
MOVZX EAX,byte ptr [R13]
MOV byte ptr [RBP + -0x1b0],AL
LAB_00104d2c:
MOV RAX,qword ptr [RBP + -0x268]
MOV qword ptr [RBP + -0x1b8],RAX
MOV RDX,qword ptr [RBP + -0x1c0]
MOV byte ptr [RDX + RAX*0x1],0x0
JMP 0x00104b73
LAB_00104d4a:
LEA RSI,[RBP + -0x268]
LEA RDI,[RBP + -0x1c0]
MOV EDX,0x0
LAB_00104d5d:
CALL 0x001046a0
MOV RDI,RAX
MOV qword ptr [RBP + -0x1c0],RAX
MOV RAX,qword ptr [RBP + -0x268]
MOV qword ptr [RBP + -0x1b0],RAX
LAB_00104d7a:
MOV RDX,R12
MOV RSI,R13
CALL 0x00104520
JMP 0x00104d2c
LAB_00104d87:
TEST R12,R12
JZ 0x00104d2c
LEA RDI,[RBP + -0x1b0]
JMP 0x00104d7a
LAB_00104d95:
MOV RAX,qword ptr [RBP + -0x1b8]
ADD RAX,0x1
CMP EAX,0x8
JNC 0x00104ded
TEST AL,0x4
JNZ 0x00104dd5
TEST EAX,EAX
JZ 0x00104bad
MOVZX EDI,byte ptr [RBP + -0x1b0]
MOV byte ptr [RSI + 0x10],DIL
TEST AL,0x2
JZ 0x00104bad
MOV EAX,EAX
MOVZX ECX,word ptr [RCX + RAX*0x1 + -0x2]
MOV word ptr [RDX + RAX*0x1 + -0x2],CX
JMP 0x00104bad
LAB_00104dd5:
MOV EDI,dword ptr [RBP + -0x1b0]
MOV dword ptr [RSI + 0x10],EDI
MOV EAX,EAX
MOV ECX,dword ptr [RCX + RAX*0x1 + -0x4]
MOV dword ptr [RDX + RAX*0x1 + -0x4],ECX
JMP 0x00104bad
LAB_00104ded:
MOV RDI,qword ptr [RBP + -0x1b0]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,EAX
MOV R8,qword ptr [RCX + RDI*0x1 + -0x8]
MOV qword ptr [RDX + RDI*0x1 + -0x8],R8
LEA R8,[RDX + 0x8]
AND R8,-0x8
SUB RDX,R8
SUB RCX,RDX
ADD EAX,EDX
AND EAX,0xfffffff8
CMP EAX,0x8
JC 0x00104bad
AND EAX,0xfffffff8
MOV EDX,0x0
LAB_00104e28:
MOV EDI,EDX
MOV R9,qword ptr [RCX + RDI*0x1]
MOV qword ptr [R8 + RDI*0x1],R9
ADD EDX,0x8
CMP EDX,EAX
JC 0x00104e28
JMP 0x00104bad
LAB_00104e3e:
LEA RDX,[RBP + -0x1c0]
MOV RDI,RBX
LAB_00104e48:
CALL 0x0010648e
MOV RDI,qword ptr [RBP + -0x1c0]
LEA RAX,[RBP + -0x1b0]
CMP RDI,RAX
JZ 0x00104e70
MOV RAX,qword ptr [RBP + -0x1b0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_00104e70:
LEA RDI,[RBP + -0x240]
LAB_00104e77:
CALL 0x0010ca3a
JMP 0x00104b0f
LAB_00104e81:
MOV RDI,qword ptr [RBP + -0x220]
TEST RDI,RDI
JZ 0x00104e9c
MOV RSI,qword ptr [RBP + -0x210]
SUB RSI,RDI
CALL 0x00104540
LAB_00104e9c:
MOV RDI,qword ptr [RBP + -0x248]
TEST RDI,RDI
JZ 0x00104ead
CALL 0x00105f66
LAB_00104ead:
LEA RDI,[RBP + -0x258]
CALL 0x00104630
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00104f1c
MOV RAX,RBX
LEA RSP,[RBP + -0x20]
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00104f1c:
CALL 0x00104580 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
long *plVar2;
int *__src;
_Sp_counted_base<(_Lock_policy)2> *p_Var3;
bool bVar4;
char cVar5;
int iVar6;
uint uVar7;
int8 *puVar8;
ulong uVar9;
uint uVar10;
long lVar11;
long *in_RSI;
long in_FS_OFFSET;
ulong local_270;
int4 local_268 [2];
locale local_260 [2];
int8 local_258;
_Sp_counted_base<(_Lock_policy)2> *local_250;
long local_248;
long local_240;
regex *local_238;
int4 local_230;
int8 *local_228;
int8 *local_220;
long local_218;
int8 local_210;
int8 local_208;
int8 local_200;
int8 local_1f8;
int8 local_1f0;
int8 local_1e8;
int8 local_1e0;
int8 local_1d8;
int8 local_1d0;
ulong *local_1c8;
int8 local_1c0;
ulong local_1b8 [24];
long *local_f8;
long local_e8 [4];
int8 local_c8;
_Sp_counted_base<(_Lock_policy)2> *local_c0;
long *local_b8;
long local_a8 [2];
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
std::locale::locale(local_260);
local_258 = 0;
local_250 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 0010486b to 0010486f has its CatchHandler @ 00104bc2 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1c8,"[ae]\\w+","",local_260,0x10);
p_Var1 = local_c0;
local_258 = local_c8;
p_Var3 = local_250;
local_c0 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
local_c8 = 0;
local_250 = p_Var1;
if (p_Var3 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = p_Var3 + 8;
if (*(long *)(p_Var3 + 8) == 0x100000001) {
*(int4 *)(p_Var3 + 8) = 0;
*(int4 *)(p_Var3 + 0xc) = 0;
(**(code **)(*(long *)p_Var3 + 0x10))(p_Var3);
(**(code **)(*(long *)p_Var3 + 0x18))(p_Var3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar6 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)(p_Var3 + 8);
*(int *)(p_Var3 + 8) = iVar6 + -1;
}
if (iVar6 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(p_Var3);
}
}
}
local_268[0] = 0x10;
std::
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
::~_Deque_base(local_98);
if (local_b8 != local_a8) {
operator_delete(local_b8,local_a8[0] + 1);
}
p_Var3 = local_c0;
if (local_c0 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_c0 + 8;
if (*(long *)(local_c0 + 8) == 0x100000001) {
*(int4 *)(local_c0 + 8) = 0;
*(int4 *)(local_c0 + 0xc) = 0;
(**(code **)(*(long *)local_c0 + 0x10))(local_c0);
(**(code **)(*(long *)p_Var3 + 0x18))(p_Var3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar6 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)(local_c0 + 8);
*(int *)(local_c0 + 8) = iVar6 + -1;
}
if (iVar6 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_c0);
}
}
}
if (local_f8 != local_e8) {
operator_delete(local_f8,local_e8[0] + 1);
}
local_248 = *in_RSI;
local_240 = local_248 + in_RSI[1];
local_238 = (regex *)local_268;
local_230 = 0;
local_228 = (int8 *)0x0;
local_220 = (int8 *)0x0;
local_218 = 0;
local_210 = 0;
/* try { // try from 00104a0b to 00104a0f has its CatchHandler @ 00104ce2 */
bVar4 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)local_248,(__normal_iterator)local_240,
(match_results *)&local_228,local_238,0,0,false);
if (!bVar4) {
local_1f8 = 0;
local_1f0 = 0;
local_208 = 0;
local_200 = 0;
local_1e8 = 0;
local_1e0 = 0;
local_1d8 = 0;
local_1d0 = 0;
local_248 = 0;
local_240 = 0;
local_238 = (regex *)0x0;
local_230 = 0;
/* try { // try from 00104c97 to 00104c9b has its CatchHandler @ 00104caf */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator=((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)&local_228,(vector *)&local_1e8);
local_210 = local_1d0;
}
local_1f8 = 0;
local_1f0 = 0;
local_208 = 0;
local_200 = 0;
local_1e8 = 0;
local_1e0 = 0;
local_1d8 = 0;
local_1d0 = 0;
do {
cVar5 = std::
regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
::operator==((regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
*)&local_248,(regex_iterator *)&local_208);
if (cVar5 != '\0') {
if (local_228 != (int8 *)0x0) {
operator_delete(local_228,local_218 - (long)local_228);
}
if (local_250 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release(local_250);
}
std::locale::~locale(local_260);
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
if ((local_220 == local_228) || (puVar8 = local_228, (long)local_220 - (long)local_228 == 0x48))
{
puVar8 = local_220 + -9;
}
if (*(char *)(puVar8 + 2) == '\0') {
local_1c8 = local_1b8;
local_1c0 = 0;
local_1b8[0] = (ulong)local_1b8[0]._1_7_ << 8;
}
else {
__src = (int *)*puVar8;
local_1c8 = local_1b8;
local_1c0 = 0;
uVar9 = puVar8[1] - (long)__src;
local_270 = uVar9;
if (uVar9 < 0x10) {
if (uVar9 == 1) {
local_1b8[0] = CONCAT71(local_1b8[0]._1_7_,*__src);
}
else if (uVar9 != 0) goto LAB_00104d7a;
}
else {
/* try { // try from 00104d5d to 00104d61 has its CatchHandler @ 00104f0b */
local_1c8 = (ulong *)std::string::_M_create((ulong *)&local_1c8,(ulong)&local_270);
local_1b8[0] = local_270;
LAB_00104d7a:
memcpy(local_1c8,__src,uVar9);
}
local_1c0 = local_270;
*(int *)((long)local_1c8 + local_270) = 0;
}
plVar2 = *(long **)(param_1 + 8);
if (plVar2 == *(long **)(param_1 + 0x10)) {
/* try { // try from 00104e48 to 00104e4c has its CatchHandler @ 00104ed8 */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar2,(string *)&local_1c8);
if (local_1c8 != local_1b8) {
operator_delete(local_1c8,local_1b8[0] + 1);
}
}
else {
*plVar2 = (long)(plVar2 + 2);
if (local_1c8 == local_1b8) {
uVar9 = local_1c0 + 1;
uVar7 = (uint)uVar9;
if (uVar7 < 8) {
if ((uVar9 & 4) == 0) {
if (uVar7 != 0) {
*(int *)(plVar2 + 2) = (int)local_1b8[0];
if ((uVar9 & 2) != 0) {
*(int2 *)((long)plVar2 + (uVar9 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1b8 + ((uVar9 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar2 + 2) = (int4)local_1b8[0];
*(int4 *)((long)plVar2 + (uVar9 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1b8 + ((uVar9 & 0xffffffff) - 4));
}
}
else {
plVar2[2] = local_1b8[0];
*(int8 *)((long)plVar2 + (uVar9 & 0xffffffff) + 8) =
*(int8 *)((long)local_1b8 + ((uVar9 & 0xffffffff) - 8));
lVar11 = (long)(plVar2 + 2) - ((ulong)(plVar2 + 3) & 0xfffffffffffffff8);
uVar7 = uVar7 + (int)lVar11 & 0xfffffff8;
if (7 < uVar7) {
uVar10 = 0;
do {
*(int8 *)(((ulong)(plVar2 + 3) & 0xfffffffffffffff8) + (ulong)uVar10) =
*(int8 *)((long)local_1b8 + ((ulong)uVar10 - lVar11));
uVar10 = uVar10 + 8;
} while (uVar10 < uVar7);
}
}
}
else {
*plVar2 = (long)local_1c8;
plVar2[2] = local_1b8[0];
}
plVar2[1] = local_1c0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
/* try { // try from 00104e77 to 00104e7b has its CatchHandler @ 00104f0b */
std::regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>::
operator++((regex_iterator<__normal_iterator<char_const*,std::string>,char,std::regex_traits<char>>
*)&local_248);
} while( true );
} |
1,014 | func0 | #include <iostream>
#include <regex>
#include <vector>
#include <string>
#include <cassert>
using namespace std;
| vector<string> func0(const string &text) {
vector<string> result;
regex pattern("[ae]\\w+");
auto iter = sregex_iterator(text.begin(), text.end(), pattern);
auto end = sregex_iterator();
for (; iter != end; ++iter) {
result.push_back(iter->str());
}
return result;
}
| int main() {
{
vector<string> expected = {"ame"};
vector<string> result = func0("python programe");
assert(result == expected);
}
{
vector<string> expected = {"ame", "anguage"};
vector<string> result = func0("python programe language");
assert(result == expected);
}
{
vector<string> expected = {"assert", "atement"};
vector<string> result = func0("assert statement");
assert(result == expected);
}
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x278,%rsp
mov %fs:0x28,%rax
mov %rax,0x268(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
lea 0x90(%rsp),%r15
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %r15,%rdi
mov %r15,(%rsp)
callq 4750 <_ZNSt6localeC1Ev@plt>
lea 0x38(%rsp),%rax
mov %r15,%rsi
movl $0x10,0x30(%rsp)
mov %rax,%rdi
mov %rax,%r15
mov %rax,0x8(%rsp)
callq 44f0 <_ZNSt6localeC1ERKS_@plt>
lea 0xd0(%rsp),%rax
mov 0x30(%rsp),%r8d
mov %r15,%rcx
lea 0x16896(%rip),%rdx
mov %rax,%rdi
mov %rax,0x10(%rsp)
lea -0x7(%rdx),%rsi
callq 19b80 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x1d0(%rsp),%rax
lea 0x200(%rsp),%rdi
movq $0x0,0x1d0(%rsp)
mov %rax,0x40(%rsp)
mov 0x1d8(%rsp),%rax
movq $0x0,0x1d8(%rsp)
mov %rax,0x48(%rsp)
callq 7240 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x1e0(%rsp),%rdi
lea 0x1f0(%rsp),%rax
cmp %rax,%rdi
je 4e8a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xfa>
callq 4590 <_ZdlPv@plt>
mov 0x1d8(%rsp),%rbp
test %rbp,%rbp
je 4ec0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x1d112(%rip),%r13
test %r13,%r13
je 5268 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4d8>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 527a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4ea>
nopw 0x0(%rax,%rax,1)
mov 0x1a0(%rsp),%rdi
lea 0x1b0(%rsp),%rax
cmp %rax,%rdi
je 4eda <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14a>
callq 4590 <_ZdlPv@plt>
mov (%rsp),%rdi
lea 0x70(%rsp),%rbp
callq 4680 <_ZNSt6localeD1Ev@plt>
mov (%rbx),%rdi
mov 0x8(%rbx),%rsi
xor %r8d,%r8d
lea 0x30(%rsp),%rcx
mov %rbp,%rdx
movl $0x0,0x68(%rsp)
add %rdi,%rsi
mov %rdi,0x50(%rsp)
mov %rsi,0x58(%rsp)
mov %rcx,0x28(%rsp)
mov %rcx,0x60(%rsp)
movq $0x0,0x70(%rsp)
movq $0x0,0x78(%rsp)
movq $0x0,0x80(%rsp)
movq $0x0,0x88(%rsp)
callq ac80 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 53a0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x610>
lea 0xe0(%rsp),%rbp
jmpq 4ff7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x267>
nopl (%rax)
mov 0x78(%rsp),%rax
mov %rax,%rdx
sub %rdi,%rdx
cmp %rdi,%rax
je 5080 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2f0>
cmp $0x48,%rdx
je 5080 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2f0>
cmpb $0x0,0x10(%rdi)
jne 508f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2ff>
mov %rbp,0xd0(%rsp)
mov 0x8(%r12),%rbx
movq $0x0,0xd8(%rsp)
movb $0x0,0xe0(%rsp)
cmp 0x10(%r12),%rbx
je 50e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x358>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
mov 0xd0(%rsp),%rax
cmp %rbp,%rax
je 51e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x458>
mov %rax,(%rbx)
mov 0xe0(%rsp),%rax
mov %rax,0x10(%rbx)
mov 0xd8(%rsp),%rax
mov %rax,0x8(%rbx)
addq $0x20,0x8(%r12)
lea 0x50(%rsp),%rdi
callq b2b0 <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv>
cmpq $0x0,0x60(%rsp)
mov 0x70(%rsp),%rdi
jne 4f60 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1d0>
test %rdi,%rdi
je 5012 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x282>
callq 4590 <_ZdlPv@plt>
mov 0x48(%rsp),%rbp
test %rbp,%rbp
je 5040 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
mov 0x1cf8d(%rip),%r13
test %r13,%r13
je 52b0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x520>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 52c2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x532>
mov 0x8(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x268(%rsp),%rax
xor %fs:0x28,%rax
jne 54b2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x722>
add $0x278,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
lea -0x48(%rdi,%rdx,1),%rdi
cmpb $0x0,0x10(%rdi)
je 4f88 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f8>
mov (%rdi),%r14
mov 0x8(%rdi),%r13
mov %rbp,0xd0(%rsp)
sub %r14,%r13
mov %r13,0x90(%rsp)
cmp $0xf,%r13
ja 5218 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x488>
cmp $0x1,%r13
jne 5200 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x470>
movzbl (%r14),%eax
mov %al,0xe0(%rsp)
mov %rbp,%rax
mov %r13,0xd8(%rsp)
movb $0x0,(%rax,%r13,1)
mov 0x8(%r12),%rbx
cmp 0x10(%r12),%rbx
jne 4fb4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x224>
mov (%r12),%r15
mov %rbx,%r13
movabs $0x3ffffffffffffff,%rcx
sub %r15,%r13
mov %r13,%rax
sar $0x5,%rax
cmp %rcx,%rax
je 54a6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x716>
test %rax,%rax
je 5358 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5c8>
lea (%rax,%rax,1),%r14
cmp %rax,%r14
jb 5390 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x600>
test %r14,%r14
jne 5470 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x6e0>
mov $0x20,%edx
xor %r14d,%r14d
xor %eax,%eax
add %rax,%r13
lea 0x10(%r13),%rcx
mov %rcx,0x0(%r13)
mov 0xd0(%rsp),%rcx
cmp %rbp,%rcx
je 5378 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5e8>
mov %rcx,0x0(%r13)
mov 0xe0(%rsp),%rcx
mov %rcx,0x10(%r13)
mov 0xd8(%rsp),%rcx
mov %rbp,0xd0(%rsp)
movq $0x0,0xd8(%rsp)
mov %rcx,0x8(%r13)
movb $0x0,0xe0(%rsp)
cmp %r15,%rbx
je 5308 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x578>
mov %rax,%rcx
mov %r15,%rdx
jmp 51c4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x434>
nopw 0x0(%rax,%rax,1)
mov %rsi,(%rcx)
mov 0x10(%rdx),%rsi
mov %rsi,0x10(%rcx)
mov 0x8(%rdx),%rsi
add $0x20,%rdx
add $0x20,%rcx
mov %rsi,-0x18(%rcx)
cmp %rdx,%rbx
je 5300 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x570>
lea 0x10(%rcx),%rsi
lea 0x10(%rdx),%rdi
mov %rsi,(%rcx)
mov (%rdx),%rsi
cmp %rdi,%rsi
jne 51a0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x410>
movdqu 0x10(%rdx),%xmm0
movups %xmm0,0x10(%rcx)
jmp 51ab <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x41b>
nopw 0x0(%rax,%rax,1)
movdqa 0xe0(%rsp),%xmm1
movups %xmm1,0x10(%rbx)
jmpq 4fdb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x24b>
nopw 0x0(%rax,%rax,1)
test %r13,%r13
jne 54b7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x727>
mov %rbp,%rax
jmpq 50cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x33b>
nopl 0x0(%rax)
mov (%rsp),%rsi
mov 0x10(%rsp),%rdi
xor %edx,%edx
callq 46f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0xd0(%rsp)
mov %rax,%rdi
mov 0x90(%rsp),%rax
mov %rax,0xe0(%rsp)
mov %r13,%rdx
mov %r14,%rsi
callq 4560 <memcpy@plt>
mov 0x90(%rsp),%r13
mov 0xd0(%rsp),%rax
jmpq 50cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x33b>
nopl 0x0(%rax,%rax,1)
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 4ec0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %r13,%r13
je 548a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x6fa>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4ec0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4ec0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 5040 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %r13,%r13
je 5498 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x708>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 5040 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 5040 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2b0>
nopw 0x0(%rax,%rax,1)
sub %r15,%rbx
lea 0x20(%rax,%rbx,1),%rdx
test %r15,%r15
je 5329 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x599>
mov %r15,%rdi
mov %rdx,0x20(%rsp)
mov %rax,0x18(%rsp)
callq 4590 <_ZdlPv@plt>
mov 0x20(%rsp),%rdx
mov 0x18(%rsp),%rax
mov 0xd0(%rsp),%rdi
mov %rax,(%r12)
mov %rdx,0x8(%r12)
mov %r14,0x10(%r12)
cmp %rbp,%rdi
je 4fed <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x25d>
callq 4590 <_ZdlPv@plt>
jmpq 4fed <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x25d>
nopw 0x0(%rax,%rax,1)
mov $0x20,%r14d
mov %r14,%rdi
callq 45a0 <_Znwm@plt>
add %rax,%r14
lea 0x20(%rax),%rdx
jmpq 5135 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3a5>
nopw 0x0(%rax,%rax,1)
movdqa 0xe0(%rsp),%xmm2
movups %xmm2,0x10(%r13)
jmpq 5161 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3d1>
nopl 0x0(%rax,%rax,1)
movabs $0x7fffffffffffffe0,%r14
jmp 535e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5ce>
nopl 0x0(%rax)
lea 0xb0(%rsp),%rsi
mov %rbp,%rdi
movl $0x0,0xac(%rsp)
movq $0x0,0x90(%rsp)
movq $0x0,0x98(%rsp)
movq $0x0,0xa0(%rsp)
movl $0x0,0xa8(%rsp)
movq $0x0,0xb0(%rsp)
movq $0x0,0xb8(%rsp)
movq $0x0,0xc0(%rsp)
movq $0x0,0xc8(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movq $0x0,0x60(%rsp)
movl $0x0,0x68(%rsp)
callq 6330 <_ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE_>
mov 0xc8(%rsp),%rax
mov 0xb0(%rsp),%rdi
mov %rax,0x88(%rsp)
test %rdi,%rdi
je 4f50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c0>
callq 4590 <_ZdlPv@plt>
jmpq 4f50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1c0>
nopl 0x0(%rax,%rax,1)
movabs $0x3ffffffffffffff,%rax
cmp %rax,%r14
cmova %rax,%r14
shl $0x5,%r14
jmpq 535e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5ce>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 5297 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x507>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 52df <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x54f>
lea 0x15d45(%rip),%rdi
callq 44d0 <_ZSt20__throw_length_errorPKc@plt>
callq 45f0 <__stack_chk_fail@plt>
mov %rbp,%rdi
jmpq 5243 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4b3>
endbr64
mov %rax,%rbx
jmpq 47d5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x12>
endbr64
mov %rax,%rbx
jmpq 47d5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x12>
endbr64
mov %rax,%rbx
jmpq 47c3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%rbp
jmpq 47f3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x30>
endbr64
mov %rax,%rbx
jmpq 4816 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x53>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
push r14
lea r14, [rbp+var_268]
lea r15, [rbp+var_1D0]
push r13
mov r13, rsi
push r12
push rbx
mov rbx, rdi
sub rsp, 278h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, r14; this
mov [rbp+var_290], r14
call __ZNSt6localeC1Ev; std::locale::locale(void)
pxor xmm0, xmm0
mov rcx, r14
mov rdi, r15
lea rdx, aAeW+7; ""
mov r8d, 10h
movaps [rbp+var_260], xmm0
lea rsi, [rdx-7]
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rbp+var_D0]
mov r12, qword ptr [rbp+var_260+8]
pxor xmm1, xmm1
movaps [rbp+var_D0], xmm1
movaps [rbp+var_260], xmm0
test r12, r12
jz short loc_4E06
mov rdx, [r12+8]
lea rcx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_5418
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5458
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_4DFD:
cmp eax, 1
jz loc_54AF
loc_4E06:
lea rdi, [rbp+var_A0]
mov [rbp+var_270], 10h
call _ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED2Ev; std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base()
mov rdi, [rbp+var_C0]; void *
lea rax, [rbp+var_B0]
cmp rdi, rax
jz short loc_4E3F
mov rax, [rbp+var_B0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4E3F:
mov r12, qword ptr [rbp+var_D0+8]
test r12, r12
jz short loc_4E8B
mov rdx, [r12+8]
lea rcx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_53F0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5470
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_4E82:
cmp eax, 1
jz loc_54BC
loc_4E8B:
mov rdi, [rbp+var_100]; void *
lea rax, [rbp+var_F0]
cmp rdi, rax
jz short loc_4EAE
mov rax, [rbp+var_F0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4EAE:
mov rax, [r13+0]
mov rdx, [r13+8]
sub rsp, 8
xor r9d, r9d
lea rcx, [rbp+var_270]
lea r14, [rbp+var_230]
xor r8d, r8d
mov [rbp+var_238], 0
add rdx, rax
movq xmm0, rax
mov [rbp+var_298], rcx
movq xmm2, rdx
mov [rbp+var_240], rcx
mov rdx, r14
punpcklqdq xmm0, xmm2
movaps [rbp+var_250], xmm0
movq rdi, xmm0
pxor xmm0, xmm0
mov rsi, qword ptr [rbp+var_250+8]
movaps xmmword ptr [rbp+var_230], xmm0
movaps [rbp+var_220], xmm0
push 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop r8
pop r9
test al, al
jz loc_5378
loc_4F32:
lea rax, [rbp+var_1C0]
pxor xmm0, xmm0
mov [rbp+var_288], rax
movaps [rbp+var_200], xmm0
pxor xmm0, xmm0
movaps [rbp+var_210], xmm0
movaps [rbp+var_1F0], xmm0
movaps [rbp+var_1E0], xmm0
nop dword ptr [rax+00h]
loc_4F68:
cmp [rbp+var_240], 0
jz loc_50B6
loc_4F76:
mov rdx, [rbp+var_230+8]
mov rax, [rbp+var_230]
mov rcx, rdx
sub rcx, rax
cmp rdx, rax
jz short loc_4F95
cmp rcx, 48h ; 'H'
jnz short loc_4F9A
loc_4F95:
lea rax, [rax+rcx-48h]
loc_4F9A:
cmp byte ptr [rax+10h], 0
jnz loc_5150
mov rax, [rbp+var_288]
mov rsi, [rbx+8]
mov byte ptr [rbp+var_1C0], 0
mov [rbp+var_1C8], 0
mov [rbp+var_1D0], rax
cmp rsi, [rbx+10h]
jz loc_51BA
loc_4FD2:
lea rdx, [rsi+10h]
mov rdi, [rbp+var_288]
mov [rsi], rdx
mov rax, [rbp+var_1D0]
cmp rax, rdi
jz loc_5260
mov [rsi], rax
mov rax, [rbp+var_1C0]
mov [rsi+10h], rax
mov rax, [rbp+var_1C8]
loc_5005:
mov [rsi+8], rax
add qword ptr [rbx+8], 20h ; ' '
loc_500E:
mov rdx, [rbp+var_230+8]
mov rax, [rbp+var_230]
mov rcx, rdx
sub rcx, rax
cmp rdx, rax
jz short loc_502D
cmp rcx, 48h ; 'H'
jnz short loc_5032
loc_502D:
lea rax, [rax+rcx-48h]
loc_5032:
cmp byte ptr [rax+10h], 0
jz loc_4F68
mov r12, [rax+8]
mov rdi, r12
cmp r12, [rax]
jz loc_5210
loc_504C:
mov r8d, [rbp+var_238]
sub rsp, 8
xor r9d, r9d
mov rdx, r14
mov rcx, [rbp+var_240]
mov rsi, qword ptr [rbp+var_250+8]
or r8b, 80h
mov [rbp+var_238], r8d
push 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop rdx
pop rcx
test al, al
jz loc_51F8
loc_5087:
mov rax, [rbp+var_230+8]
cmp [rax-28h], r12
mov [rax-30h], r12
setnz byte ptr [rax-20h]
mov rax, qword ptr [rbp+var_250]
cmp [rbp+var_240], 0
mov qword ptr [rbp+var_220+8], rax
jnz loc_4F76
loc_50B6:
mov rdi, [rbp+var_230]; void *
mov rsi, qword ptr [rbp+var_220]
sub rsi, rdi; unsigned __int64
test rdi, rdi
jz short loc_50D1
call __ZdlPvm; operator delete(void *,ulong)
loc_50D1:
mov rax, qword ptr [rbp+var_260+8]
mov rdi, rax
test rax, rax
jz short loc_511A
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_5490
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5480
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_5111:
cmp eax, 1
jz loc_54C9
loc_511A:
mov rdi, [rbp+var_290]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_54D3
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5150:
mov r13, [rax]
mov r12, [rax+8]
mov [rbp+var_1C8], 0
mov rax, [rbp+var_288]
sub r12, r13
mov [rbp+var_1D0], rax
mov [rbp+var_278], r12
cmp r12, 0Fh
ja loc_52D0
cmp r12, 1
jnz loc_52B8
movzx eax, byte ptr [r13+0]
mov byte ptr [rbp+var_1C0], al
loc_5199:
mov rax, [rbp+var_288]
loc_51A0:
mov [rbp+var_1C8], r12
mov byte ptr [rax+r12], 0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_4FD2
loc_51BA:
mov rdx, r15
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string &&)
mov rdi, [rbp+var_1D0]; void *
mov rax, [rbp+var_288]
cmp rdi, rax
jz loc_500E
mov rax, [rbp+var_1C0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_500E
loc_51F8:
mov [rbp+var_240], 0
jmp loc_4F68
loc_5210:
cmp r12, qword ptr [rbp+var_250+8]
jz short loc_51F8
sub rsp, 8
xor r9d, r9d
mov rdx, r14
mov r8d, [rbp+var_238]
mov rcx, [rbp+var_240]
mov rsi, qword ptr [rbp+var_250+8]
push 0
or r8d, 60h
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop rsi
pop rdi
lea rdi, [r12+1]
test al, al
jz loc_504C
jmp loc_5087
loc_5260:
mov rax, [rbp+var_1C8]
lea rcx, [rax+1]
cmp ecx, 8
jnb loc_5320
test cl, 4
jnz loc_543A
test ecx, ecx
jz loc_5005
mov rdi, [rbp+var_288]
movzx edi, byte ptr [rdi]
mov [rsi+10h], dil
test cl, 2
jz loc_5005
mov rdi, [rbp+var_288]
mov ecx, ecx
movzx edi, word ptr [rdi+rcx-2]
mov [rdx+rcx-2], di
jmp loc_5005
loc_52B8:
test r12, r12
jz loc_5199
mov rdi, [rbp+var_288]
jmp short loc_52F9
loc_52D0:
lea rsi, [rbp+var_278]
xor edx, edx
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+var_1D0], rax
mov rdi, rax; dest
mov rax, [rbp+var_278]
mov [rbp+var_1C0], rax
loc_52F9:
mov rdx, r12; n
mov rsi, r13; src
call _memcpy
mov r12, [rbp+var_278]
mov rax, [rbp+var_1D0]
jmp loc_51A0
loc_5320:
mov r11, [rbp+var_288]
mov rdi, [r11]
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [r11+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rsi+18h]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
add ecx, edx
sub r11, rdx
and ecx, 0FFFFFFF8h
mov r8, r11
cmp ecx, 8
jb loc_5005
and ecx, 0FFFFFFF8h
xor edx, edx
loc_535E:
mov r9d, edx
add edx, 8
mov r10, [r8+r9]
mov [rdi+r9], r10
cmp edx, ecx
jb short loc_535E
jmp loc_5005
loc_5378:
pxor xmm0, xmm0
mov rdi, r14
lea rax, [rbp+var_1F0]
mov qword ptr [rbp+var_250], 0
movaps [rbp+var_200], xmm0
mov rsi, rax
pxor xmm0, xmm0
mov r13, rax
mov qword ptr [rbp+var_250+8], 0
mov [rbp+var_240], 0
mov [rbp+var_238], 0
movaps [rbp+var_210], xmm0
movaps [rbp+var_1F0], xmm0
movaps [rbp+var_1E0], xmm0
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE__isra_0; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>> const&) [clone]
mov rax, qword ptr [rbp+var_1E0+8]
mov qword ptr [rbp+var_220+8], rax
jmp loc_4F32
loc_53F0:
mov qword ptr [r12+8], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_4E8B
loc_5418:
mov qword ptr [r12+8], 0
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+10h]
mov rax, [r12]
mov rdi, r12
call qword ptr [rax+18h]
jmp loc_4E06
loc_543A:
mov r10, rdi
mov edi, [rdi]
mov ecx, ecx
mov [rsi+10h], edi
mov edi, [r10+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_5005
loc_5458:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4DFD
loc_5470:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4E82
loc_5480:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_5111
loc_5490:
mov rax, [rdi]
mov r15, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r15]
mov rdi, r15
call qword ptr [rax+18h]
jmp loc_511A
loc_54AF:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_4E06
loc_54BC:
mov rdi, r12
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_4E8B
loc_54C9:
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE24_M_release_last_use_coldEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(void)
jmp loc_511A
loc_54D3:
call ___stack_chk_fail
endbr64
mov r12, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov r15, rax
jmp loc_37A5
endbr64
mov r13, rax
jmp loc_37C4
endbr64
mov r15, rax
jmp loc_3772
endbr64
mov r15, rax
jmp loc_37CF | long long func0(long long a1, unsigned long long *a2)
{
char *v4; // rsi
__m128i v5; // xmm0
volatile signed __int32 *v6; // r12
long long v7; // rdx
volatile signed __int32 *v8; // rcx
signed __int32 v9; // eax
long long v10; // r12
long long v11; // rdx
volatile signed __int32 *v12; // rcx
signed __int32 v13; // eax
unsigned long long v14; // rax
unsigned long long v15; // rdx
char v16; // al
long long v17; // rdx
long long v18; // rcx
char *v19; // r8
long long v20; // r9
char *v21; // rax
signed long long v22; // rcx
void **v23; // rsi
_QWORD *v24; // rdx
void *v25; // rax
char *v26; // rax
long long v27; // r12
int v28; // edi
int v29; // r8d
char *v30; // rax
bool v31; // zf
unsigned long long v32; // rsi
long long v33; // rdi
long long v34; // rdx
volatile signed __int32 *v35; // rcx
signed __int32 v36; // eax
_BYTE *v38; // r13
long long v39; // r12
size_t v40; // r12
_QWORD *v41; // rax
unsigned int v42; // ecx
_QWORD *v43; // rdi
unsigned long long v44; // rdi
char *v45; // rdx
char *v46; // r11
unsigned int v47; // ecx
unsigned int v48; // ecx
unsigned int v49; // edx
long long v50; // rax
char *v51; // [rsp-10h] [rbp-2B0h]
long long v52; // [rsp-8h] [rbp-2A8h]
size_t v53; // [rsp+28h] [rbp-278h] BYREF
int v54; // [rsp+30h] [rbp-270h] BYREF
char v55[8]; // [rsp+38h] [rbp-268h] BYREF
__m128i v56; // [rsp+40h] [rbp-260h]
__m128i v57; // [rsp+50h] [rbp-250h]
int *v58; // [rsp+60h] [rbp-240h]
int v59; // [rsp+68h] [rbp-238h]
void *v60[2]; // [rsp+70h] [rbp-230h] BYREF
__int128 v61; // [rsp+80h] [rbp-220h]
__int128 v62; // [rsp+90h] [rbp-210h]
__int128 v63; // [rsp+A0h] [rbp-200h]
__int128 v64; // [rsp+B0h] [rbp-1F0h] BYREF
__int128 v65; // [rsp+C0h] [rbp-1E0h]
void *v66; // [rsp+D0h] [rbp-1D0h] BYREF
size_t v67; // [rsp+D8h] [rbp-1C8h]
_QWORD v68[24]; // [rsp+E0h] [rbp-1C0h] BYREF
void *v69; // [rsp+1A0h] [rbp-100h]
long long v70; // [rsp+1B0h] [rbp-F0h] BYREF
__m128i v71; // [rsp+1D0h] [rbp-D0h] BYREF
void *v72; // [rsp+1E0h] [rbp-C0h]
long long v73; // [rsp+1F0h] [rbp-B0h] BYREF
char v74[104]; // [rsp+200h] [rbp-A0h] BYREF
unsigned long long v75; // [rsp+268h] [rbp-38h]
v75 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::locale::locale((std::locale *)v55);
v56 = 0LL;
v4 = "[ae]\\w+";
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v66, "[ae]\\w+", "", v55, 16LL);
v5 = _mm_load_si128(&v71);
v6 = (volatile signed __int32 *)v56.m128i_i64[1];
v71 = 0LL;
v56 = v5;
if ( v6 )
{
v7 = *((_QWORD *)v6 + 1);
v8 = v6 + 2;
if ( v7 == 0x100000001LL )
{
*((_QWORD *)v6 + 1) = 0LL;
(*(void ( **)(volatile signed __int32 *, char *, long long, volatile signed __int32 *))(*(_QWORD *)v6 + 16LL))(
v6,
v4,
0x100000001LL,
v8);
(*(void ( **)(volatile signed __int32 *))(*(_QWORD *)v6 + 24LL))(v6);
}
else
{
if ( _libc_single_threaded )
{
v9 = *((_DWORD *)v6 + 2);
v7 = (unsigned int)(v9 - 1);
*((_DWORD *)v6 + 2) = v7;
}
else
{
v9 = _InterlockedExchangeAdd(v8, 0xFFFFFFFF);
}
if ( v9 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v6, v4, v7, v8);
}
}
v54 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v74);
if ( v72 != &v73 )
{
v4 = (char *)(v73 + 1);
operator delete(v72, v73 + 1);
}
v10 = v71.m128i_i64[1];
if ( v71.m128i_i64[1] )
{
v11 = *(_QWORD *)(v71.m128i_i64[1] + 8);
v12 = (volatile signed __int32 *)(v71.m128i_i64[1] + 8);
if ( v11 == 0x100000001LL )
{
*(_QWORD *)(v71.m128i_i64[1] + 8) = 0LL;
(*(void ( **)(long long, char *, long long, volatile signed __int32 *))(*(_QWORD *)v10 + 16LL))(
v10,
v4,
0x100000001LL,
v12);
(*(void ( **)(long long))(*(_QWORD *)v10 + 24LL))(v10);
}
else
{
if ( _libc_single_threaded )
{
v13 = *(_DWORD *)(v71.m128i_i64[1] + 8);
v11 = (unsigned int)(v13 - 1);
*(_DWORD *)(v71.m128i_i64[1] + 8) = v11;
}
else
{
v13 = _InterlockedExchangeAdd(v12, 0xFFFFFFFF);
}
if ( v13 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v10, v4, v11, v12);
}
}
if ( v69 != &v70 )
operator delete(v69, v70 + 1);
v14 = *a2;
v15 = a2[1];
v59 = 0;
v58 = &v54;
v57 = _mm_unpacklo_epi64((__m128i)v14, (__m128i)(v14 + v15));
*(_OWORD *)v60 = 0LL;
v61 = 0LL;
v16 = std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v57.m128i_i32[0],
v57.m128i_i32[2],
(unsigned int)v60,
(unsigned int)&v54,
0,
0,
0);
v19 = v51;
v20 = v52;
if ( !v16 )
{
v57 = 0uLL;
v63 = 0LL;
v58 = 0LL;
v59 = 0;
v62 = 0LL;
v64 = 0LL;
v65 = 0LL;
((void ( *)(void **, __int128 *, long long, long long, char *))std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=)(
v60,
&v64,
v17,
v18,
v51);
*((_QWORD *)&v61 + 1) = *((_QWORD *)&v65 + 1);
}
v63 = 0LL;
v62 = 0LL;
v64 = 0LL;
v65 = 0LL;
while ( v58 )
{
v21 = (char *)v60[0];
v22 = (char *)v60[1] - (char *)v60[0];
if ( v60[1] == v60[0] || v22 == 72 )
v21 = (char *)v60[1] - 72;
if ( !v21[16] )
{
v23 = *(void ***)(a1 + 8);
LOBYTE(v68[0]) = 0;
v67 = 0LL;
v66 = v68;
if ( v23 == *(void ***)(a1 + 16) )
goto LABEL_50;
goto LABEL_26;
}
v38 = *(_BYTE **)v21;
v39 = *((_QWORD *)v21 + 1);
v67 = 0LL;
v40 = v39 - (_QWORD)v38;
v66 = v68;
v53 = v40;
if ( v40 > 0xF )
{
v66 = (void *)std::string::_M_create(&v66, &v53, 0LL, v22, v19, v20);
v43 = v66;
v68[0] = v53;
}
else
{
if ( v40 == 1 )
{
LOBYTE(v68[0]) = *v38;
LABEL_48:
v41 = v68;
goto LABEL_49;
}
if ( !v40 )
goto LABEL_48;
v43 = v68;
}
memcpy(v43, v38, v40);
v40 = v53;
v41 = v66;
LABEL_49:
v67 = v40;
*((_BYTE *)v41 + v40) = 0;
v23 = *(void ***)(a1 + 8);
if ( v23 == *(void ***)(a1 + 16) )
{
LABEL_50:
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v23, &v66, v22, v19, v20);
if ( v66 != v68 )
operator delete(v66, v68[0] + 1LL);
goto LABEL_29;
}
LABEL_26:
v24 = v23 + 2;
*v23 = v23 + 2;
if ( v66 == v68 )
{
v25 = (void *)v67;
v42 = v67 + 1;
if ( (unsigned int)(v67 + 1) >= 8 )
{
v23[2] = (void *)v68[0];
*(_QWORD *)((char *)v24 + v42 - 8) = *(_QWORD *)((char *)&v68[-1] + v42);
v44 = (unsigned long long)(v23 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v45 = (char *)v24 - v44;
v46 = (char *)((char *)v68 - v45);
v47 = ((_DWORD)v45 + v42) & 0xFFFFFFF8;
v19 = (char *)((char *)v68 - v45);
if ( v47 >= 8 )
{
v48 = v47 & 0xFFFFFFF8;
v49 = 0;
do
{
v20 = v49;
v49 += 8;
*(_QWORD *)(v44 + v20) = *(_QWORD *)&v46[v20];
}
while ( v49 < v48 );
}
}
else if ( (v42 & 4) != 0 )
{
*((_DWORD *)v23 + 4) = v68[0];
*(_DWORD *)((char *)v24 + v42 - 4) = *(_DWORD *)((char *)&v67 + v42 + 4);
}
else if ( (_DWORD)v67 != -1 )
{
*((_BYTE *)v23 + 16) = v68[0];
if ( (v42 & 2) != 0 )
*(_WORD *)((char *)v24 + v42 - 2) = *(_WORD *)((char *)&v67 + v42 + 6);
}
}
else
{
*v23 = v66;
v23[2] = (void *)v68[0];
v25 = (void *)v67;
}
v23[1] = v25;
*(_QWORD *)(a1 + 8) += 32LL;
LABEL_29:
v26 = (char *)v60[0];
if ( v60[1] == v60[0] || (long long *)((char *)v60[1] - (char *)v60[0]) == &qword_48 )
v26 = (char *)v60[1] - 72;
if ( !v26[16] )
continue;
v27 = *((_QWORD *)v26 + 1);
v28 = v27;
if ( v27 != *(_QWORD *)v26 )
goto LABEL_34;
if ( v27 == v57.m128i_i64[1] )
{
LABEL_52:
v58 = 0LL;
continue;
}
v28 = v27 + 1;
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v27,
v57.m128i_i32[2],
(unsigned int)v60,
(_DWORD)v58,
v59 | 0x60u,
0,
0) )
{
LABEL_34:
v29 = v59;
LOBYTE(v29) = v59 | 0x80;
v59 = v29;
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v28,
v57.m128i_i32[2],
(unsigned int)v60,
(_DWORD)v58,
v29,
0,
0) )
goto LABEL_52;
}
v30 = (char *)v60[1];
v31 = *((_QWORD *)v60[1] - 5) == v27;
*((_QWORD *)v60[1] - 6) = v27;
*(v30 - 32) = !v31;
*((_QWORD *)&v61 + 1) = v57.m128i_i64[0];
}
v32 = v61 - (unsigned long long)v60[0];
if ( v60[0] )
operator delete(v60[0], v32);
v33 = v56.m128i_i64[1];
if ( v56.m128i_i64[1] )
{
v34 = *(_QWORD *)(v56.m128i_i64[1] + 8);
v35 = (volatile signed __int32 *)(v56.m128i_i64[1] + 8);
if ( v34 == 0x100000001LL )
{
v50 = *(_QWORD *)v56.m128i_i64[1];
*(_QWORD *)(v56.m128i_i64[1] + 8) = 0LL;
(*(void ( **)(long long, unsigned long long, long long, volatile signed __int32 *, char *, long long))(v50 + 16))(
v33,
v32,
0x100000001LL,
v35,
v19,
v20);
(*(void ( **)(long long))(*(_QWORD *)v33 + 24LL))(v33);
}
else
{
if ( _libc_single_threaded )
{
v36 = *(_DWORD *)(v56.m128i_i64[1] + 8);
v34 = (unsigned int)(v36 - 1);
*(_DWORD *)(v56.m128i_i64[1] + 8) = v34;
}
else
{
v36 = _InterlockedExchangeAdd(v35, 0xFFFFFFFF);
}
if ( v36 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v33, v32, v34, v35);
}
}
std::locale::~locale((std::locale *)v55);
return a1;
} | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R14,[RBP + -0x268]
LEA R15,[RBP + -0x1d0]
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x278
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,R14
MOV qword ptr [RBP + -0x290],R14
CALL 0x001036d0
PXOR XMM0,XMM0
MOV RCX,R14
MOV RDI,R15
LEA RDX,[0x1195e6]
MOV R8D,0x10
MOVAPS xmmword ptr [RBP + -0x260],XMM0
LEA RSI,[RDX + -0x7]
LAB_00104d9b:
CALL 0x00117e80
MOVDQA XMM0,xmmword ptr [RBP + -0xd0]
MOV R12,qword ptr [RBP + -0x258]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0x260],XMM0
TEST R12,R12
JZ 0x00104e06
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00105418
CMP byte ptr [0x0011f460],0x0
JZ 0x00105458
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_00104dfd:
CMP EAX,0x1
JZ 0x001054af
LAB_00104e06:
LEA RDI,[RBP + -0xa0]
MOV dword ptr [RBP + -0x270],0x10
CALL 0x001072d0
MOV RDI,qword ptr [RBP + -0xc0]
LEA RAX,[RBP + -0xb0]
CMP RDI,RAX
JZ 0x00104e3f
MOV RAX,qword ptr [RBP + -0xb0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
LAB_00104e3f:
MOV R12,qword ptr [RBP + -0xc8]
TEST R12,R12
JZ 0x00104e8b
MOV RDX,qword ptr [R12 + 0x8]
LEA RCX,[R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001053f0
CMP byte ptr [0x0011f460],0x0
JZ 0x00105470
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_00104e82:
CMP EAX,0x1
JZ 0x001054bc
LAB_00104e8b:
MOV RDI,qword ptr [RBP + -0x100]
LEA RAX,[RBP + -0xf0]
CMP RDI,RAX
JZ 0x00104eae
MOV RAX,qword ptr [RBP + -0xf0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
LAB_00104eae:
MOV RAX,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
SUB RSP,0x8
XOR R9D,R9D
LEA RCX,[RBP + -0x270]
LEA R14,[RBP + -0x230]
XOR R8D,R8D
MOV dword ptr [RBP + -0x238],0x0
ADD RDX,RAX
MOVQ XMM0,RAX
MOV qword ptr [RBP + -0x298],RCX
MOVQ XMM2,RDX
MOV qword ptr [RBP + -0x240],RCX
MOV RDX,R14
PUNPCKLQDQ XMM0,XMM2
MOVAPS xmmword ptr [RBP + -0x250],XMM0
MOVQ RDI,XMM0
PXOR XMM0,XMM0
MOV RSI,qword ptr [RBP + -0x248]
MOVAPS xmmword ptr [RBP + -0x230],XMM0
MOVAPS xmmword ptr [RBP + -0x220],XMM0
PUSH 0x0
LAB_00104f21:
CALL 0x0010da80
POP R8
POP R9
TEST AL,AL
JZ 0x00105378
LAB_00104f32:
LEA RAX,[RBP + -0x1c0]
PXOR XMM0,XMM0
MOV qword ptr [RBP + -0x288],RAX
MOVAPS xmmword ptr [RBP + -0x200],XMM0
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x1f0],XMM0
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
NOP dword ptr [RAX]
LAB_00104f68:
CMP qword ptr [RBP + -0x240],0x0
JZ 0x001050b6
LAB_00104f76:
MOV RDX,qword ptr [RBP + -0x228]
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,RDX
SUB RCX,RAX
CMP RDX,RAX
JZ 0x00104f95
CMP RCX,0x48
JNZ 0x00104f9a
LAB_00104f95:
LEA RAX,[RAX + RCX*0x1 + -0x48]
LAB_00104f9a:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00105150
MOV RAX,qword ptr [RBP + -0x288]
MOV RSI,qword ptr [RBX + 0x8]
MOV byte ptr [RBP + -0x1c0],0x0
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x1d0],RAX
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x001051ba
LAB_00104fd2:
LEA RDX,[RSI + 0x10]
MOV RDI,qword ptr [RBP + -0x288]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RBP + -0x1d0]
CMP RAX,RDI
JZ 0x00105260
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RSI + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x1c8]
LAB_00105005:
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [RBX + 0x8],0x20
LAB_0010500e:
MOV RDX,qword ptr [RBP + -0x228]
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,RDX
SUB RCX,RAX
CMP RDX,RAX
JZ 0x0010502d
CMP RCX,0x48
JNZ 0x00105032
LAB_0010502d:
LEA RAX,[RAX + RCX*0x1 + -0x48]
LAB_00105032:
CMP byte ptr [RAX + 0x10],0x0
JZ 0x00104f68
MOV R12,qword ptr [RAX + 0x8]
MOV RDI,R12
CMP R12,qword ptr [RAX]
JZ 0x00105210
LAB_0010504c:
MOV R8D,dword ptr [RBP + -0x238]
SUB RSP,0x8
XOR R9D,R9D
MOV RDX,R14
MOV RCX,qword ptr [RBP + -0x240]
MOV RSI,qword ptr [RBP + -0x248]
OR R8B,0x80
MOV dword ptr [RBP + -0x238],R8D
PUSH 0x0
LAB_00105078:
CALL 0x0010da80
POP RDX
POP RCX
TEST AL,AL
JZ 0x001051f8
LAB_00105087:
MOV RAX,qword ptr [RBP + -0x228]
CMP qword ptr [RAX + -0x28],R12
MOV qword ptr [RAX + -0x30],R12
SETNZ byte ptr [RAX + -0x20]
MOV RAX,qword ptr [RBP + -0x250]
CMP qword ptr [RBP + -0x240],0x0
MOV qword ptr [RBP + -0x218],RAX
JNZ 0x00104f76
LAB_001050b6:
MOV RDI,qword ptr [RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x220]
SUB RSI,RDI
TEST RDI,RDI
JZ 0x001050d1
CALL 0x00103540
LAB_001050d1:
MOV RAX,qword ptr [RBP + -0x258]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010511a
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00105490
CMP byte ptr [0x0011f460],0x0
JZ 0x00105480
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00105111:
CMP EAX,0x1
JZ 0x001054c9
LAB_0010511a:
MOV RDI,qword ptr [RBP + -0x290]
CALL 0x00103620
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001054d3
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00105150:
MOV R13,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x1c8],0x0
MOV RAX,qword ptr [RBP + -0x288]
SUB R12,R13
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x278],R12
CMP R12,0xf
JA 0x001052d0
CMP R12,0x1
JNZ 0x001052b8
MOVZX EAX,byte ptr [R13]
MOV byte ptr [RBP + -0x1c0],AL
LAB_00105199:
MOV RAX,qword ptr [RBP + -0x288]
LAB_001051a0:
MOV qword ptr [RBP + -0x1c8],R12
MOV byte ptr [RAX + R12*0x1],0x0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x00104fd2
LAB_001051ba:
MOV RDX,R15
MOV RDI,RBX
LAB_001051c0:
CALL 0x00106dc0
MOV RDI,qword ptr [RBP + -0x1d0]
MOV RAX,qword ptr [RBP + -0x288]
CMP RDI,RAX
JZ 0x0010500e
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
JMP 0x0010500e
LAB_001051f8:
MOV qword ptr [RBP + -0x240],0x0
JMP 0x00104f68
LAB_00105210:
CMP R12,qword ptr [RBP + -0x248]
JZ 0x001051f8
SUB RSP,0x8
XOR R9D,R9D
MOV RDX,R14
MOV R8D,dword ptr [RBP + -0x238]
MOV RCX,qword ptr [RBP + -0x240]
MOV RSI,qword ptr [RBP + -0x248]
PUSH 0x0
OR R8D,0x60
LAB_0010523e:
CALL 0x0010da80
POP RSI
POP RDI
LEA RDI,[R12 + 0x1]
TEST AL,AL
JZ 0x0010504c
JMP 0x00105087
LAB_00105260:
MOV RAX,qword ptr [RBP + -0x1c8]
LEA RCX,[RAX + 0x1]
CMP ECX,0x8
JNC 0x00105320
TEST CL,0x4
JNZ 0x0010543a
TEST ECX,ECX
JZ 0x00105005
MOV RDI,qword ptr [RBP + -0x288]
MOVZX EDI,byte ptr [RDI]
MOV byte ptr [RSI + 0x10],DIL
TEST CL,0x2
JZ 0x00105005
MOV RDI,qword ptr [RBP + -0x288]
MOV ECX,ECX
MOVZX EDI,word ptr [RDI + RCX*0x1 + -0x2]
MOV word ptr [RDX + RCX*0x1 + -0x2],DI
JMP 0x00105005
LAB_001052b8:
TEST R12,R12
JZ 0x00105199
MOV RDI,qword ptr [RBP + -0x288]
JMP 0x001052f9
LAB_001052d0:
LEA RSI,[RBP + -0x278]
XOR EDX,EDX
MOV RDI,R15
CALL 0x00103680
MOV qword ptr [RBP + -0x1d0],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x278]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_001052f9:
MOV RDX,R12
MOV RSI,R13
CALL 0x00103520
MOV R12,qword ptr [RBP + -0x278]
MOV RAX,qword ptr [RBP + -0x1d0]
JMP 0x001051a0
LAB_00105320:
MOV R11,qword ptr [RBP + -0x288]
MOV RDI,qword ptr [R11]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,ECX
MOV R8,qword ptr [R11 + RDI*0x1 + -0x8]
MOV qword ptr [RDX + RDI*0x1 + -0x8],R8
LEA RDI,[RSI + 0x18]
AND RDI,-0x8
SUB RDX,RDI
ADD ECX,EDX
SUB R11,RDX
AND ECX,0xfffffff8
MOV R8,R11
CMP ECX,0x8
JC 0x00105005
AND ECX,0xfffffff8
XOR EDX,EDX
LAB_0010535e:
MOV R9D,EDX
ADD EDX,0x8
MOV R10,qword ptr [R8 + R9*0x1]
MOV qword ptr [RDI + R9*0x1],R10
CMP EDX,ECX
JC 0x0010535e
JMP 0x00105005
LAB_00105378:
PXOR XMM0,XMM0
MOV RDI,R14
LEA RAX,[RBP + -0x1f0]
MOV qword ptr [RBP + -0x250],0x0
MOVAPS xmmword ptr [RBP + -0x200],XMM0
MOV RSI,RAX
PXOR XMM0,XMM0
MOV R13,RAX
MOV qword ptr [RBP + -0x248],0x0
MOV qword ptr [RBP + -0x240],0x0
MOV dword ptr [RBP + -0x238],0x0
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x1f0],XMM0
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
LAB_001053d7:
CALL 0x00104100
MOV RAX,qword ptr [RBP + -0x1d8]
MOV qword ptr [RBP + -0x218],RAX
JMP 0x00104f32
LAB_001053f0:
MOV qword ptr [R12 + 0x8],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x00104e8b
LAB_00105418:
MOV qword ptr [R12 + 0x8],0x0
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX + 0x18]
JMP 0x00104e06
LAB_0010543a:
MOV R10,RDI
MOV EDI,dword ptr [RDI]
MOV ECX,ECX
MOV dword ptr [RSI + 0x10],EDI
MOV EDI,dword ptr [R10 + RCX*0x1 + -0x4]
MOV dword ptr [RDX + RCX*0x1 + -0x4],EDI
JMP 0x00105005
LAB_00105458:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104dfd
LAB_00105470:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104e82
LAB_00105480:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00105111
LAB_00105490:
MOV RAX,qword ptr [RDI]
MOV R15,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R15]
MOV RDI,R15
CALL qword ptr [RAX + 0x18]
JMP 0x0010511a
LAB_001054af:
MOV RDI,R12
CALL 0x001067a0
JMP 0x00104e06
LAB_001054bc:
MOV RDI,R12
CALL 0x001067a0
JMP 0x00104e8b
LAB_001054c9:
CALL 0x001067a0
JMP 0x0010511a
LAB_001054d3:
CALL 0x00103580 | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
long lVar2;
int *__src;
int8 uVar3;
int auVar4 [16];
bool bVar5;
int iVar6;
long *plVar7;
uint uVar8;
uint uVar9;
long lVar10;
long *in_RSI;
ulong uVar11;
long in_FS_OFFSET;
ulong local_280;
int4 local_278 [2];
locale local_270 [2];
int local_268 [16];
long local_258;
long lStack_250;
regex *local_248;
uint local_240;
int local_238 [16];
int local_228 [16];
int local_218 [16];
int local_208 [16];
vector local_1f8 [16];
int local_1e8 [16];
ulong *local_1d8;
int8 local_1d0;
ulong local_1c8 [24];
long *local_108;
long local_f8 [4];
int local_d8 [16];
long *local_c8;
long local_b8 [2];
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
std::locale::locale(local_270);
local_268 = (int [16])0x0;
/* try { // try from 00104d9b to 00104d9f has its CatchHandler @ 001054e4 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,"[ae]\\w+","",local_270,0x10);
auVar4 = local_d8;
uVar3 = local_268._8_8_;
local_d8 = (int [16])0x0;
local_268 = auVar4;
if ((_Sp_counted_base<(_Lock_policy)2> *)uVar3 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(uVar3 + 8);
if (*(long *)(uVar3 + 8) == 0x100000001) {
*(int8 *)(uVar3 + 8) = 0;
(**(code **)(*(long *)uVar3 + 0x10))(uVar3);
(**(code **)(*(long *)uVar3 + 0x18))(uVar3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar6 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)(uVar3 + 8);
*(int *)(uVar3 + 8) = iVar6 + -1;
}
if (iVar6 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)uVar3);
}
}
}
local_278[0] = 0x10;
std::
_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>,std::allocator<std::__detail::_StateSeq<std::regex_traits<char>>>>
::~_Deque_base(local_a8);
if (local_c8 != local_b8) {
operator_delete(local_c8,local_b8[0] + 1);
}
uVar3 = local_d8._8_8_;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_d8._8_8_ + 8);
if (*(long *)(local_d8._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_d8._8_8_ + 8) = 0;
(**(code **)(*(long *)local_d8._8_8_ + 0x10))(local_d8._8_8_);
(**(code **)(*(long *)uVar3 + 0x18))(uVar3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar6 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)(local_d8._8_8_ + 8);
*(int *)(local_d8._8_8_ + 8) = iVar6 + -1;
}
if (iVar6 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
}
}
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
local_258 = *in_RSI;
local_248 = (regex *)local_278;
local_240 = 0;
lStack_250 = in_RSI[1] + local_258;
local_238 = (int [16])0x0;
local_228 = (int [16])0x0;
/* try { // try from 00104f21 to 00104f25 has its CatchHandler @ 001054fc */
bVar5 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)local_258,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,0,0,false);
if (!bVar5) {
local_258 = 0;
local_208 = (int [16])0x0;
lStack_250 = 0;
local_248 = (regex *)0x0;
local_240 = 0;
local_218 = (int [16])0x0;
local_1f8[0] = (vector)0x0;
local_1f8[1] = (vector)0x0;
local_1f8[2] = (vector)0x0;
local_1f8[3] = (vector)0x0;
local_1f8[4] = (vector)0x0;
local_1f8[5] = (vector)0x0;
local_1f8[6] = (vector)0x0;
local_1f8[7] = (vector)0x0;
local_1f8[8] = (vector)0x0;
local_1f8[9] = (vector)0x0;
local_1f8[10] = (vector)0x0;
local_1f8[0xb] = (vector)0x0;
local_1f8[0xc] = (vector)0x0;
local_1f8[0xd] = (vector)0x0;
local_1f8[0xe] = (vector)0x0;
local_1f8[0xf] = (vector)0x0;
local_1e8 = (int [16])0x0;
/* try { // try from 001053d7 to 001053db has its CatchHandler @ 001054d8 */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator=((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_238,local_1f8);
local_228._8_8_ = local_1e8._8_8_;
}
local_208 = (int [16])0x0;
local_218 = (int [16])0x0;
local_1f8[0] = (vector)0x0;
local_1f8[1] = (vector)0x0;
local_1f8[2] = (vector)0x0;
local_1f8[3] = (vector)0x0;
local_1f8[4] = (vector)0x0;
local_1f8[5] = (vector)0x0;
local_1f8[6] = (vector)0x0;
local_1f8[7] = (vector)0x0;
local_1f8[8] = (vector)0x0;
local_1f8[9] = (vector)0x0;
local_1f8[10] = (vector)0x0;
local_1f8[0xb] = (vector)0x0;
local_1f8[0xc] = (vector)0x0;
local_1f8[0xd] = (vector)0x0;
local_1f8[0xe] = (vector)0x0;
local_1f8[0xf] = (vector)0x0;
local_1e8 = (int [16])0x0;
auVar4 = local_238;
joined_r0x00104f70:
do {
local_238._0_8_ = auVar4._0_8_;
local_238 = auVar4;
if (local_248 == (regex *)0x0) {
uVar11 = local_228._0_8_ - local_238._0_8_;
if ((int8 *)local_238._0_8_ != (int8 *)0x0) {
uVar3 = local_238._0_8_;
operator_delete((void *)uVar3,uVar11);
auVar4 = local_238;
}
local_238 = auVar4;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_268._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_268._8_8_ + 8);
if (*(long *)(local_268._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_268._8_8_ + 8) = 0;
(**(code **)(*(long *)local_268._8_8_ + 0x10))();
(**(code **)(*(long *)local_268._8_8_ + 0x18))(local_268._8_8_);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar6 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)(local_268._8_8_ + 8);
*(int *)(local_268._8_8_ + 8) = iVar6 + -1;
}
if (iVar6 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_268._8_8_);
}
}
}
std::locale::~locale(local_270);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_238._8_8_ = auVar4._8_8_;
if ((local_238._8_8_ == local_238._0_8_) || (local_238._8_8_ - local_238._0_8_ == 0x48)) {
local_238._0_8_ = local_238._0_8_ + (local_238._8_8_ - local_238._0_8_) + -0x48;
}
local_1c8[0]._1_7_ = (uint7)(local_1c8[0] >> 8);
local_1d8 = local_1c8;
if (*(char *)(local_238._0_8_ + 0x10) == '\0') {
plVar7 = *(long **)(param_1 + 8);
local_1c8[0] = (ulong)local_1c8[0]._1_7_ << 8;
local_1d0 = 0;
if (plVar7 != *(long **)(param_1 + 0x10)) goto LAB_00104fd2;
LAB_001051ba:
/* try { // try from 001051c0 to 001051c4 has its CatchHandler @ 001054f0 */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar7,(string *)&local_1d8);
if (local_1d8 != local_1c8) {
operator_delete(local_1d8,local_1c8[0] + 1);
}
}
else {
__src = *(int **)local_238._0_8_;
local_1d0 = 0;
uVar11 = *(long *)(local_238._0_8_ + 8) - (long)__src;
local_280 = uVar11;
if (uVar11 < 0x10) {
if (uVar11 == 1) {
local_1c8[0] = CONCAT71(local_1c8[0]._1_7_,*__src);
}
else if (uVar11 != 0) goto LAB_001052f9;
}
else {
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_280);
local_1c8[0] = local_280;
LAB_001052f9:
memcpy(local_1d8,__src,uVar11);
}
*(int *)((long)local_1d8 + local_280) = 0;
plVar7 = *(long **)(param_1 + 8);
local_1d0 = local_280;
if (plVar7 == *(long **)(param_1 + 0x10)) goto LAB_001051ba;
LAB_00104fd2:
*plVar7 = (long)(plVar7 + 2);
if (local_1d8 == local_1c8) {
uVar11 = local_1d0 + 1;
uVar8 = (uint)uVar11;
if (uVar8 < 8) {
if ((uVar11 & 4) == 0) {
if (uVar8 != 0) {
*(int *)(plVar7 + 2) = (int)local_1c8[0];
if ((uVar11 & 2) != 0) {
*(int2 *)((long)plVar7 + (uVar11 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1c8 + ((uVar11 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar7 + 2) = (int4)local_1c8[0];
*(int4 *)((long)plVar7 + (uVar11 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1c8 + ((uVar11 & 0xffffffff) - 4));
}
}
else {
plVar7[2] = local_1c8[0];
*(int8 *)((long)plVar7 + (uVar11 & 0xffffffff) + 8) =
*(int8 *)((long)local_1c8 + ((uVar11 & 0xffffffff) - 8));
lVar10 = (long)(plVar7 + 2) - ((ulong)(plVar7 + 3) & 0xfffffffffffffff8);
uVar8 = uVar8 + (int)lVar10 & 0xfffffff8;
if (7 < uVar8) {
uVar9 = 0;
do {
uVar11 = (ulong)uVar9;
uVar9 = uVar9 + 8;
*(int8 *)(((ulong)(plVar7 + 3) & 0xfffffffffffffff8) + uVar11) =
*(int8 *)((long)local_1c8 + (uVar11 - lVar10));
} while (uVar9 < uVar8);
}
}
}
else {
*plVar7 = (long)local_1d8;
plVar7[2] = local_1c8[0];
}
plVar7[1] = local_1d0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
if ((local_238._8_8_ == local_238._0_8_) ||
(plVar7 = (long *)local_238._0_8_, local_238._8_8_ - local_238._0_8_ == 0x48)) {
plVar7 = (long *)(local_238._0_8_ + (local_238._8_8_ - local_238._0_8_) + -0x48);
}
auVar4 = local_238;
} while (*(char *)(plVar7 + 2) == '\0');
lVar2 = plVar7[1];
lVar10 = lVar2;
if (lVar2 == *plVar7) {
if (lVar2 == lStack_250) goto LAB_001051f8;
/* try { // try from 0010523e to 001052e0 has its CatchHandler @ 00105508 */
bVar5 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)lVar2,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,local_240 | 0x60,0,false);
lVar10 = lVar2 + 1;
if (!bVar5) goto LAB_0010504c;
}
else {
LAB_0010504c:
local_240 = local_240 | 0x80;
/* try { // try from 00105078 to 0010507c has its CatchHandler @ 00105508 */
bVar5 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)lVar10,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,local_240,0,false);
if (!bVar5) {
LAB_001051f8:
local_248 = (regex *)0x0;
auVar4 = local_238;
goto joined_r0x00104f70;
}
}
*(long *)(local_238._8_8_ + -0x30) = lVar2;
*(bool *)(local_238._8_8_ + -0x20) = *(long *)(local_238._8_8_ + -0x28) != lVar2;
local_228._8_8_ = local_258;
auVar4 = local_238;
goto joined_r0x00104f70;
} |
1,015 | func0 | #include <iostream>
#include <regex>
#include <vector>
#include <string>
#include <cassert>
using namespace std;
| vector<string> func0(const string &text) {
vector<string> result;
regex pattern("[ae]\\w+");
auto iter = sregex_iterator(text.begin(), text.end(), pattern);
auto end = sregex_iterator();
for (; iter != end; ++iter) {
result.push_back(iter->str());
}
return result;
}
| int main() {
{
vector<string> expected = {"ame"};
vector<string> result = func0("python programe");
assert(result == expected);
}
{
vector<string> expected = {"ame", "anguage"};
vector<string> result = func0("python programe language");
assert(result == expected);
}
{
vector<string> expected = {"assert", "atement"};
vector<string> result = func0("assert statement");
assert(result == expected);
}
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rsi,%rbp
push %rbx
sub $0x278,%rsp
mov %fs:0x28,%rax
mov %rax,0x268(%rsp)
xor %eax,%eax
lea 0x90(%rsp),%rbx
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov %rbx,%rdi
mov %rbx,0x8(%rsp)
callq 47b0 <_ZNSt6localeC1Ev@plt>
lea 0x38(%rsp),%rax
mov %rbx,%rsi
movl $0x10,0x30(%rsp)
mov %rax,%rdi
mov %rax,%rbx
mov %rax,0x10(%rsp)
callq 4530 <_ZNSt6localeC1ERKS_@plt>
lea 0xd0(%rsp),%rax
mov 0x30(%rsp),%r8d
mov %rbx,%rcx
lea 0x15e6d(%rip),%rdx
mov %rax,%rdi
mov %rax,0x18(%rsp)
lea -0x7(%rdx),%rsi
callq 1a000 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
movdqa 0x1d0(%rsp),%xmm3
mov 0x200(%rsp),%rdi
pxor %xmm0,%xmm0
movaps %xmm0,0x1d0(%rsp)
movaps %xmm3,0x40(%rsp)
test %rdi,%rdi
je 593f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xff>
mov 0x248(%rsp),%rax
mov 0x228(%rsp),%r13
lea 0x8(%rax),%rbx
cmp %r13,%rbx
jbe 593a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xfa>
nopw 0x0(%rax,%rax,1)
mov 0x0(%r13),%rdi
add $0x8,%r13
callq 45e0 <_ZdlPv@plt>
cmp %r13,%rbx
ja 5920 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe0>
mov 0x200(%rsp),%rdi
callq 45e0 <_ZdlPv@plt>
mov 0x1e0(%rsp),%rdi
lea 0x1f0(%rsp),%rax
cmp %rax,%rdi
je 5959 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x119>
callq 45e0 <_ZdlPv@plt>
mov 0x1d8(%rsp),%r13
test %r13,%r13
je 5990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov 0x1c65b(%rip),%rbx
test %rbx,%rbx
je 5d38 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f8>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r13)
cmp $0x1,%eax
je 5d4c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x50c>
nopw 0x0(%rax,%rax,1)
mov 0x1a0(%rsp),%rdi
lea 0x1b0(%rsp),%rax
cmp %rax,%rdi
je 59aa <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16a>
callq 45e0 <_ZdlPv@plt>
mov 0x8(%rsp),%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rdx
xor %r8d,%r8d
lea 0x70(%rsp),%rbp
lea 0x30(%rsp),%rcx
movl $0x0,0x68(%rsp)
add %rax,%rdx
movq %rax,%xmm0
mov %rcx,0x28(%rsp)
movq %rdx,%xmm4
mov %rbp,%rdx
mov %rcx,0x60(%rsp)
punpcklqdq %xmm4,%xmm0
movaps %xmm0,0x50(%rsp)
mov 0x58(%rsp),%rsi
movq %xmm0,%rdi
pxor %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
callq bd40 <_ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEELNS_20_RegexExecutorPolicyE0ELb0EEEbT_SI_RNS5_13match_resultsISI_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5e78 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x638>
lea 0xe0(%rsp),%rbp
jmpq 5ac7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x287>
nopl 0x0(%rax)
mov 0x78(%rsp),%rax
mov %rax,%rdx
sub %rdi,%rdx
cmp %rdi,%rax
je 5b50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x310>
cmp $0x48,%rdx
je 5b50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x310>
cmpb $0x0,0x10(%rdi)
jne 5b5f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x31f>
mov %rbp,0xd0(%rsp)
mov 0x8(%r12),%rbx
movq $0x0,0xd8(%rsp)
movb $0x0,0xe0(%rsp)
cmp 0x10(%r12),%rbx
je 5bb8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x378>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
mov 0xd0(%rsp),%rax
cmp %rbp,%rax
je 5cb8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x478>
mov %rax,(%rbx)
mov 0xe0(%rsp),%rax
mov %rax,0x10(%rbx)
mov 0xd8(%rsp),%rax
mov %rax,0x8(%rbx)
addq $0x20,0x8(%r12)
lea 0x50(%rsp),%rdi
callq c3b0 <_ZNSt7__cxx1114regex_iteratorIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEcNS_12regex_traitsIcEEEppEv>
cmpq $0x0,0x60(%rsp)
mov 0x70(%rsp),%rdi
jne 5a30 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f0>
test %rdi,%rdi
je 5ae2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2a2>
callq 45e0 <_ZdlPv@plt>
mov 0x48(%rsp),%rbp
test %rbp,%rbp
je 5b10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
mov 0x1c4d5(%rip),%rbx
test %rbx,%rbx
je 5d88 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x548>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 5d9a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x55a>
mov 0x10(%rsp),%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x268(%rsp),%rax
xor %fs:0x28,%rax
jne 5f64 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x724>
add $0x278,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
lea -0x48(%rdi,%rdx,1),%rdi
cmpb $0x0,0x10(%rdi)
je 5a58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x218>
mov (%rdi),%r14
mov 0x8(%rdi),%r13
mov %rbp,0xd0(%rsp)
sub %r14,%r13
mov %r13,0x90(%rsp)
cmp $0xf,%r13
ja 5ce8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4a8>
cmp $0x1,%r13
jne 5cd0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x490>
movzbl (%r14),%eax
mov %al,0xe0(%rsp)
mov %rbp,%rax
mov %r13,0xd8(%rsp)
movb $0x0,(%rax,%r13,1)
mov 0x8(%r12),%rbx
cmp 0x10(%r12),%rbx
jne 5a84 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x244>
mov (%r12),%r15
mov %rbx,%r13
movabs $0x3ffffffffffffff,%rcx
sub %r15,%r13
mov %r13,%rax
sar $0x5,%rax
cmp %rcx,%rax
je 5f58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x718>
test %rax,%rax
je 5e28 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5e8>
lea (%rax,%rax,1),%r14
cmp %r14,%rax
ja 5e68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x628>
test %r14,%r14
jne 5f20 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x6e0>
movq $0x20,(%rsp)
xor %r14d,%r14d
xor %eax,%eax
add %rax,%r13
lea 0x10(%r13),%rdx
mov %rdx,0x0(%r13)
mov 0xd0(%rsp),%rdx
cmp %rbp,%rdx
je 5e50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x610>
mov %rdx,0x0(%r13)
mov 0xe0(%rsp),%rdx
mov %rdx,0x10(%r13)
mov 0xd8(%rsp),%rdx
mov %rbp,0xd0(%rsp)
movq $0x0,0xd8(%rsp)
mov %rdx,0x8(%r13)
movb $0x0,0xe0(%rsp)
cmp %r15,%rbx
je 5ddc <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x59c>
mov %rax,%rcx
mov %r15,%rdx
jmp 5c94 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x454>
nopl (%rax)
mov %rsi,(%rcx)
mov 0x10(%rdx),%rsi
mov %rsi,0x10(%rcx)
mov 0x8(%rdx),%rsi
add $0x20,%rdx
add $0x20,%rcx
mov %rsi,-0x18(%rcx)
cmp %rdx,%rbx
je 5dd0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x590>
lea 0x10(%rcx),%rsi
lea 0x10(%rdx),%rdi
mov %rsi,(%rcx)
mov (%rdx),%rsi
cmp %rdi,%rsi
jne 5c70 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x430>
movdqu 0x10(%rdx),%xmm1
movups %xmm1,0x10(%rcx)
jmp 5c7b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x43b>
nopw 0x0(%rax,%rax,1)
movdqa 0xe0(%rsp),%xmm2
movups %xmm2,0x10(%rbx)
jmpq 5aab <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x26b>
nopw 0x0(%rax,%rax,1)
test %r13,%r13
jne 5f69 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x729>
mov %rbp,%rax
jmpq 5b9b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x35b>
nopl 0x0(%rax)
mov 0x8(%rsp),%rsi
mov 0x18(%rsp),%rdi
xor %edx,%edx
callq 4750 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0xd0(%rsp)
mov %rax,%rdi
mov 0x90(%rsp),%rax
mov %rax,0xe0(%rsp)
mov %r13,%rdx
mov %r14,%rsi
callq 45a0 <memcpy@plt>
mov 0x90(%rsp),%r13
mov 0xd0(%rsp),%rax
jmpq 5b9b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x35b>
nopl 0x0(%rax)
mov 0x8(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r13)
cmp $0x1,%eax
jne 5990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5f3a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x6fa>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r13)
cmp $0x1,%eax
jne 5990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x18(%rax)
jmpq 5990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 5b10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5f4a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x70a>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 5b10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 5b10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2d0>
sub %r15,%rbx
lea 0x20(%rax,%rbx,1),%rcx
mov %rcx,(%rsp)
test %r15,%r15
je 5df3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5b3>
mov %r15,%rdi
mov %rax,0x20(%rsp)
callq 45e0 <_ZdlPv@plt>
mov 0x20(%rsp),%rax
movq %rax,%xmm0
mov 0xd0(%rsp),%rdi
mov %r14,0x10(%r12)
movhps (%rsp),%xmm0
movups %xmm0,(%r12)
cmp %rbp,%rdi
je 5abd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x27d>
callq 45e0 <_ZdlPv@plt>
jmpq 5abd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x27d>
nopl 0x0(%rax)
mov $0x20,%r14d
mov %r14,%rdi
callq 45f0 <_Znwm@plt>
lea 0x20(%rax),%rcx
add %rax,%r14
mov %rcx,(%rsp)
jmpq 5c08 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c8>
nopw %cs:0x0(%rax,%rax,1)
movdqa 0xe0(%rsp),%xmm5
movups %xmm5,0x10(%r13)
jmpq 5c34 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3f4>
nopl 0x0(%rax,%rax,1)
movabs $0x7fffffffffffffe0,%r14
jmp 5e2e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5ee>
nopl 0x0(%rax)
pxor %xmm0,%xmm0
mov %rbp,%rdi
lea 0xb0(%rsp),%rsi
movl $0x0,0xac(%rsp)
movaps %xmm0,0x90(%rsp)
mov 0x98(%rsp),%rax
movq $0x0,0xa0(%rsp)
movl $0x0,0xa8(%rsp)
movq $0x0,0x50(%rsp)
mov %rax,0x58(%rsp)
movq $0x0,0x60(%rsp)
movl $0x0,0x68(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
callq 7bf0 <_ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE_>
mov 0xc8(%rsp),%rax
mov 0xb0(%rsp),%rdi
mov %rax,0x88(%rsp)
test %rdi,%rdi
je 5a1c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1dc>
callq 45e0 <_ZdlPv@plt>
jmpq 5a1c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1dc>
nopl 0x0(%rax,%rax,1)
movabs $0x3ffffffffffffff,%rax
cmp %rax,%r14
cmova %rax,%r14
shl $0x5,%r14
jmpq 5e2e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5ee>
mov 0xc(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r13)
jmpq 5d6a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x52a>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 5db7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x577>
lea 0x152db(%rip),%rdi
callq 4500 <_ZSt20__throw_length_errorPKc@plt>
callq 4640 <__stack_chk_fail@plt>
mov %rbp,%rdi
jmpq 5d14 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4d4>
endbr64
mov %rax,%rbx
jmpq 4848 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x12>
endbr64
mov %rax,%rbx
jmpq 4848 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x12>
endbr64
mov %rax,%rbx
jmpq 4836 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%rbp
jmpq 4866 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x30>
endbr64
mov %rax,%rbx
jmpq 488a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x54>
nopl (%rax)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
push r14
lea r14, [rbp+var_268]
lea r15, [rbp+var_1D0]
push r13
mov r13, rsi
push r12
push rbx
mov rbx, rdi
sub rsp, 278h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, r14; this
mov [rbp+var_290], r14
call __ZNSt6localeC1Ev; std::locale::locale(void)
pxor xmm0, xmm0
mov rcx, r14
mov rdi, r15
lea rdx, aAeW+7; ""
mov r8d, 10h
movaps [rbp+var_260], xmm0
lea rsi, [rdx-7]
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rbp+var_D0]
mov rdi, qword ptr [rbp+var_260+8]
pxor xmm1, xmm1
movaps [rbp+var_D0], xmm1
movaps [rbp+var_260], xmm0
test rdi, rdi
jz short loc_5E5B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5E5B:
mov rdi, [rbp+var_A0]
mov [rbp+var_270], 10h
test rdi, rdi
jz short loc_5EBF
mov rax, [rbp+var_58]
lea r12, [rax+8]
mov rax, [rbp+var_78]
cmp rax, r12
jnb short loc_5EAB
nop word ptr [rax+rax+00h]
loc_5E88:
mov r14, rax
mov rdi, [rax]; void *
mov esi, 1F8h; unsigned __int64
add r14, 8
call __ZdlPvm; operator delete(void *,ulong)
mov rax, r14
cmp r14, r12
jb short loc_5E88
mov rdi, [rbp+var_A0]; void *
loc_5EAB:
mov rax, [rbp+var_98]
lea rsi, ds:0[rax*8]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5EBF:
lea rdi, [rbp+var_C0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, qword ptr [rbp+var_D0+8]
test rdi, rdi
jz short loc_5EDC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5EDC:
lea rdi, [rbp+var_100]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rax, [r13+0]
mov rdx, [r13+8]
xor r9d, r9d
lea rcx, [rbp+var_270]
sub rsp, 8
xor r8d, r8d
mov [rbp+var_238], 0
add rdx, rax
movq xmm0, rax
mov [rbp+var_2A0], rcx
lea r13, [rbp+var_230]
movq xmm2, rdx
mov [rbp+var_240], rcx
mov rdx, r13
punpcklqdq xmm0, xmm2
movaps [rbp+var_250], xmm0
movq rdi, xmm0
pxor xmm0, xmm0
mov rsi, qword ptr [rbp+var_250+8]
movaps [rbp+var_230], xmm0
movaps [rbp+var_220], xmm0
push 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
lea rdx, [rbp+var_1F0]
pop r8
pop r9
mov [rbp+var_298], rdx
test al, al
jz loc_63B8
loc_5F7A:
lea rdx, [rbp+var_1C0]
pxor xmm0, xmm0
mov rax, [rbp+var_240]
mov [rbp+var_288], rdx
movaps [rbp+var_200], xmm0
pxor xmm0, xmm0
movaps [rbp+var_210], xmm0
movaps [rbp+var_1F0], xmm0
movaps [rbp+var_1E0], xmm0
loc_5FB3:
test rax, rax
jz loc_61CB
loc_5FBC:
mov rdx, qword ptr [rbp+var_230+8]
mov rax, qword ptr [rbp+var_230]
mov rcx, rdx
sub rcx, rax
cmp rdx, rax
jz short loc_5FDB
cmp rcx, 48h ; 'H'
jnz short loc_5FE0
loc_5FDB:
lea rax, [rax+rcx-48h]
loc_5FE0:
cmp byte ptr [rax+10h], 0
jnz loc_6120
mov rax, [rbp+var_288]
mov rsi, [rbx+8]
mov byte ptr [rbp+var_1C0], 0
mov [rbp+var_1C8], 0
mov [rbp+var_1D0], rax
cmp rsi, [rbx+10h]
jz loc_6189
loc_6018:
lea rdx, [rsi+10h]
mov rdi, [rbp+var_288]
mov [rsi], rdx
mov rax, [rbp+var_1D0]
cmp rax, rdi
jz loc_62B0
mov [rsi], rax
mov rax, [rbp+var_1C0]
mov [rsi+10h], rax
mov rax, [rbp+var_1C8]
loc_604B:
mov [rsi+8], rax
add qword ptr [rbx+8], 20h ; ' '
loc_6054:
mov rdx, qword ptr [rbp+var_230+8]
mov rax, qword ptr [rbp+var_230]
mov rcx, rdx
sub rcx, rax
cmp rdx, rax
jz short loc_6076
mov rsi, rax
cmp rcx, 48h ; 'H'
jnz short loc_607B
loc_6076:
lea rsi, [rax+rcx-48h]
loc_607B:
cmp byte ptr [rsi+10h], 0
jz loc_6105
cmp rdx, rax
jz loc_62A0
mov r12, [rax+8]
cmp rcx, 48h ; 'H'
jnz short loc_609D
loc_6098:
lea rax, [rax+rcx-48h]
loc_609D:
cmp [rax], r12
jz loc_6228
mov rcx, [rbp+var_240]
mov rdi, r12
loc_60B0:
mov r8d, [rbp+var_238]
sub rsp, 8
xor r9d, r9d
mov rdx, r13
mov rsi, qword ptr [rbp+var_250+8]
or r8b, 80h
mov [rbp+var_238], r8d
push 0
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
pop rdx
pop rcx
test al, al
jz loc_61C0
mov rax, qword ptr [rbp+var_230+8]
cmp [rax-28h], r12
mov [rax-30h], r12
setnz byte ptr [rax-20h]
mov rax, qword ptr [rbp+var_250]
mov qword ptr [rbp+var_220+8], rax
loc_6105:
mov rax, [rbp+var_240]
test rax, rax
jnz loc_5FBC
jmp loc_61CB
loc_6120:
mov r14, [rax]
mov r12, [rax+8]
mov [rbp+var_1C8], 0
mov rax, [rbp+var_288]
sub r12, r14
mov [rbp+var_1D0], rax
mov [rbp+var_278], r12
cmp r12, 0Fh
ja loc_6318
cmp r12, 1
jnz loc_6300
movzx eax, byte ptr [r14]
mov byte ptr [rbp+var_1C0], al
loc_6168:
mov rax, [rbp+var_288]
loc_616F:
mov [rbp+var_1C8], r12
mov byte ptr [rax+r12], 0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_6018
loc_6189:
mov rdx, r15
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string &&)
mov rdi, [rbp+var_1D0]; void *
mov rax, [rbp+var_288]
cmp rdi, rax
jz loc_6054
mov rax, [rbp+var_1C0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_6054
loc_61C0:
mov [rbp+var_240], 0
loc_61CB:
mov rdi, [rbp+var_298]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rdi, r13
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rdi, qword ptr [rbp+var_260+8]
test rdi, rdi
jz short loc_61F0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_61F0:
mov rdi, [rbp+var_290]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_6448
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6228:
cmp qword ptr [rbp+var_250+8], r12
jz short loc_61C0
sub rsp, 8
xor r9d, r9d
mov rdx, r13
mov rdi, r12
mov r8d, [rbp+var_238]
mov rcx, [rbp+var_240]
push 0
mov rsi, qword ptr [rbp+var_250+8]
or r8d, 60h
call _ZNSt8__detail17__regex_algo_implIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEEcNS5_12regex_traitsIcEEEEbT_SH_RNS5_13match_resultsISH_T0_EERKNS5_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeENS_20_RegexExecutorPolicyEb; std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>> &,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type,std::__detail::_RegexExecutorPolicy,bool)
mov edx, eax
mov rax, [rbp+var_240]
pop rsi
pop rdi
lea rdi, [r12+1]
mov rcx, rax
test dl, dl
jz loc_60B0
mov rdx, qword ptr [rbp+var_230+8]
cmp [rdx-28h], r12
mov [rdx-30h], r12
setnz byte ptr [rdx-20h]
mov rdx, qword ptr [rbp+var_250]
mov qword ptr [rbp+var_220+8], rdx
jmp loc_5FB3
loc_62A0:
mov r12, [rax-40h]
jmp loc_6098
loc_62B0:
mov rax, [rbp+var_1C8]
lea rcx, [rax+1]
cmp ecx, 8
jnb loc_6360
test cl, 4
jnz loc_6430
test ecx, ecx
jz loc_604B
movzx edi, byte ptr [rdi]
mov [rsi+10h], dil
test cl, 2
jz loc_604B
mov rdi, [rbp+var_288]
mov ecx, ecx
movzx edi, word ptr [rdi+rcx-2]
mov [rdx+rcx-2], di
jmp loc_604B
loc_6300:
test r12, r12
jz loc_6168
mov rdi, [rbp+var_288]
jmp short loc_6341
loc_6318:
lea rsi, [rbp+var_278]
xor edx, edx
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+var_1D0], rax
mov rdi, rax; dest
mov rax, [rbp+var_278]
mov [rbp+var_1C0], rax
loc_6341:
mov rdx, r12; n
mov rsi, r14; src
call _memcpy
mov r12, [rbp+var_278]
mov rax, [rbp+var_1D0]
jmp loc_616F
loc_6360:
mov r11, rdi
mov rdi, [rdi]
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [r11+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rsi+18h]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
add ecx, edx
sub r11, rdx
and ecx, 0FFFFFFF8h
mov r8, r11
cmp ecx, 8
jb loc_604B
and ecx, 0FFFFFFF8h
xor edx, edx
loc_639A:
mov r9d, edx
add edx, 8
mov r10, [r8+r9]
mov [rdi+r9], r10
cmp edx, ecx
jb short loc_639A
jmp loc_604B
loc_63B8:
pxor xmm0, xmm0
mov rsi, rdx
mov rdi, r13
mov r14, rdx
movaps [rbp+var_200], xmm0
pxor xmm0, xmm0
mov qword ptr [rbp+var_250], 0
mov qword ptr [rbp+var_250+8], 0
mov [rbp+var_240], 0
mov [rbp+var_238], 0
movaps [rbp+var_210], xmm0
movaps [rbp+var_1F0], xmm0
movaps [rbp+var_1E0], xmm0
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EEaSERKSE__isra_0; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>> const&) [clone]
mov rax, qword ptr [rbp+var_1E0+8]
mov rdi, r14
mov qword ptr [rbp+var_220+8], rax
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
jmp loc_5F7A
loc_6430:
mov r10, rdi
mov edi, [rdi]
mov ecx, ecx
mov [rsi+10h], edi
mov edi, [r10+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_604B
loc_6448:
call ___stack_chk_fail
endbr64
mov r15, rax
jmp loc_47C1
endbr64
mov r15, rax
jmp loc_47B5
endbr64
mov r14, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov r15, rax
jmp loc_47F4
endbr64
mov r15, rax
jmp loc_4813 | long long func0(long long a1, unsigned long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
unsigned long long v6; // r12
void **v7; // rax
void **v8; // r14
unsigned long long v9; // rax
unsigned long long v10; // rdx
char v11; // al
long long v12; // rcx
char *v13; // r8
long long v14; // r9
int *v15; // rax
long long v16; // rax
long long v17; // rcx
void **v18; // rsi
_QWORD *v19; // rdx
void *v20; // rax
_QWORD *v21; // rax
long long v22; // rcx
long long v23; // rsi
long long v24; // r12
int v25; // ecx
int v26; // edi
int v27; // r8d
long long v28; // rax
bool v29; // zf
_BYTE *v30; // r14
long long v31; // r12
size_t v32; // r12
_QWORD *v33; // rax
char v35; // dl
long long v36; // rdx
unsigned int v37; // ecx
_QWORD *v38; // rdi
unsigned long long v39; // rdi
char *v40; // rdx
char *v41; // r11
unsigned int v42; // ecx
unsigned int v43; // ecx
unsigned int v44; // edx
char *v45; // [rsp-10h] [rbp-2B0h]
long long v46; // [rsp-8h] [rbp-2A8h]
size_t v47; // [rsp+28h] [rbp-278h] BYREF
int v48; // [rsp+30h] [rbp-270h] BYREF
char v49[8]; // [rsp+38h] [rbp-268h] BYREF
__m128i v50; // [rsp+40h] [rbp-260h]
__m128i v51; // [rsp+50h] [rbp-250h]
int *v52; // [rsp+60h] [rbp-240h]
int v53; // [rsp+68h] [rbp-238h]
__int128 v54; // [rsp+70h] [rbp-230h] BYREF
__int128 v55; // [rsp+80h] [rbp-220h]
__int128 v56; // [rsp+90h] [rbp-210h]
__int128 v57; // [rsp+A0h] [rbp-200h]
__int128 v58; // [rsp+B0h] [rbp-1F0h] BYREF
__int128 v59; // [rsp+C0h] [rbp-1E0h]
void *v60; // [rsp+D0h] [rbp-1D0h] BYREF
size_t v61; // [rsp+D8h] [rbp-1C8h]
_QWORD v62[24]; // [rsp+E0h] [rbp-1C0h] BYREF
char v63[48]; // [rsp+1A0h] [rbp-100h] BYREF
__m128i v64; // [rsp+1D0h] [rbp-D0h] BYREF
char v65[32]; // [rsp+1E0h] [rbp-C0h] BYREF
void *v66; // [rsp+200h] [rbp-A0h]
long long v67; // [rsp+208h] [rbp-98h]
unsigned long long v68; // [rsp+228h] [rbp-78h]
long long v69; // [rsp+248h] [rbp-58h]
unsigned long long v70; // [rsp+268h] [rbp-38h]
v70 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::locale::locale((std::locale *)v49);
v50 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v60, "[ae]\\w+", "", v49, 16LL);
v3 = _mm_load_si128(&v64);
v4 = v50.m128i_i64[1];
v64 = 0LL;
v50 = v3;
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v5 = v66;
v48 = 16;
if ( v66 )
{
v6 = v69 + 8;
v7 = (void **)v68;
if ( v68 < v69 + 8 )
{
do
{
v8 = v7 + 1;
operator delete(*v7, 0x1F8uLL);
v7 = v8;
}
while ( (unsigned long long)v8 < v6 );
v5 = v66;
}
operator delete(v5, 8 * v67);
}
std::string::_M_dispose(v65);
if ( v64.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::string::_M_dispose(v63);
v9 = *a2;
v10 = a2[1];
v53 = 0;
v52 = &v48;
v51 = _mm_unpacklo_epi64((__m128i)v9, (__m128i)(v9 + v10));
v54 = 0LL;
v55 = 0LL;
v11 = std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v51.m128i_i32[0],
v51.m128i_i32[2],
(unsigned int)&v54,
(unsigned int)&v48,
0,
0,
0);
v13 = v45;
v14 = v46;
if ( !v11 )
{
v57 = 0LL;
v51 = 0uLL;
v52 = 0LL;
v53 = 0;
v56 = 0LL;
v58 = 0LL;
v59 = 0LL;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(
&v54,
&v58,
&v58,
v12,
v45,
v46,
&v48);
*((_QWORD *)&v55 + 1) = *((_QWORD *)&v59 + 1);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v58);
}
v15 = v52;
v57 = 0LL;
v56 = 0LL;
v58 = 0LL;
v59 = 0LL;
LABEL_13:
if ( v15 )
{
do
{
v16 = v54;
v17 = *((_QWORD *)&v54 + 1) - v54;
if ( *((_QWORD *)&v54 + 1) == (_QWORD)v54 || v17 == 72 )
v16 = *((_QWORD *)&v54 + 1) - 72LL;
if ( !*(_BYTE *)(v16 + 16) )
{
v18 = *(void ***)(a1 + 8);
LOBYTE(v62[0]) = 0;
v61 = 0LL;
v60 = v62;
if ( v18 != *(void ***)(a1 + 16) )
goto LABEL_19;
goto LABEL_40;
}
v30 = *(_BYTE **)v16;
v31 = *(_QWORD *)(v16 + 8);
v61 = 0LL;
v32 = v31 - (_QWORD)v30;
v60 = v62;
v47 = v32;
if ( v32 > 0xF )
{
v60 = (void *)std::string::_M_create(&v60, &v47, 0LL, v17, v13, v14);
v38 = v60;
v62[0] = v47;
}
else
{
if ( v32 == 1 )
{
LOBYTE(v62[0]) = *v30;
LABEL_38:
v33 = v62;
goto LABEL_39;
}
if ( !v32 )
goto LABEL_38;
v38 = v62;
}
memcpy(v38, v30, v32);
v32 = v47;
v33 = v60;
LABEL_39:
v61 = v32;
*((_BYTE *)v33 + v32) = 0;
v18 = *(void ***)(a1 + 8);
if ( v18 != *(void ***)(a1 + 16) )
{
LABEL_19:
v19 = v18 + 2;
*v18 = v18 + 2;
if ( v60 == v62 )
{
v20 = (void *)v61;
v37 = v61 + 1;
if ( (unsigned int)(v61 + 1) >= 8 )
{
v18[2] = (void *)v62[0];
*(_QWORD *)((char *)v19 + v37 - 8) = *(_QWORD *)((char *)&v62[-1] + v37);
v39 = (unsigned long long)(v18 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v40 = (char *)v19 - v39;
v41 = (char *)((char *)v62 - v40);
v42 = ((_DWORD)v40 + v37) & 0xFFFFFFF8;
v13 = (char *)((char *)v62 - v40);
if ( v42 >= 8 )
{
v43 = v42 & 0xFFFFFFF8;
v44 = 0;
do
{
v14 = v44;
v44 += 8;
*(_QWORD *)(v39 + v14) = *(_QWORD *)&v41[v14];
}
while ( v44 < v43 );
}
}
else if ( (v37 & 4) != 0 )
{
*((_DWORD *)v18 + 4) = v62[0];
*(_DWORD *)((char *)v19 + v37 - 4) = *(_DWORD *)((char *)&v61 + v37 + 4);
}
else if ( (_DWORD)v61 != -1 )
{
*((_BYTE *)v18 + 16) = v62[0];
if ( (v37 & 2) != 0 )
*(_WORD *)((char *)v19 + v37 - 2) = *(_WORD *)((char *)&v61 + v37 + 6);
}
}
else
{
*v18 = v60;
v18[2] = (void *)v62[0];
v20 = (void *)v61;
}
v18[1] = v20;
*(_QWORD *)(a1 + 8) += 32LL;
goto LABEL_22;
}
LABEL_40:
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v18, &v60, v17, v13, v14);
if ( v60 != v62 )
operator delete(v60, v62[0] + 1LL);
LABEL_22:
v21 = (_QWORD *)v54;
v22 = *((_QWORD *)&v54 + 1) - v54;
if ( *((_QWORD *)&v54 + 1) == (_QWORD)v54 || (v23 = v54, v22 == 72) )
v23 = *((_QWORD *)&v54 + 1) - 72LL;
if ( !*(_BYTE *)(v23 + 16) )
continue;
if ( *((_QWORD *)&v54 + 1) == (_QWORD)v54 )
{
v24 = *(_QWORD *)(v54 - 64);
LABEL_28:
v21 = (_QWORD *)(*((_QWORD *)&v54 + 1) - 72LL);
goto LABEL_29;
}
v24 = *(_QWORD *)(v54 + 8);
if ( v22 == 72 )
goto LABEL_28;
LABEL_29:
if ( *v21 == v24 )
{
if ( v51.m128i_i64[1] == v24 )
{
LABEL_42:
v52 = 0LL;
break;
}
v35 = std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v24,
v51.m128i_i32[2],
(unsigned int)&v54,
(_DWORD)v52,
v53 | 0x60u,
0,
0);
v15 = v52;
v26 = v24 + 1;
v25 = (int)v52;
if ( v35 )
{
v36 = *((_QWORD *)&v54 + 1);
v29 = *(_QWORD *)(*((_QWORD *)&v54 + 1) - 40LL) == v24;
*(_QWORD *)(*((_QWORD *)&v54 + 1) - 48LL) = v24;
*(_BYTE *)(v36 - 32) = !v29;
*((_QWORD *)&v55 + 1) = v51.m128i_i64[0];
goto LABEL_13;
}
}
else
{
v25 = (int)v52;
v26 = v24;
}
v27 = v53;
LOBYTE(v27) = v53 | 0x80;
v53 = v27;
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
v26,
v51.m128i_i32[2],
(unsigned int)&v54,
v25,
v27,
0,
0) )
goto LABEL_42;
v28 = *((_QWORD *)&v54 + 1);
v29 = *(_QWORD *)(*((_QWORD *)&v54 + 1) - 40LL) == v24;
*(_QWORD *)(*((_QWORD *)&v54 + 1) - 48LL) = v24;
*(_BYTE *)(v28 - 32) = !v29;
*((_QWORD *)&v55 + 1) = v51.m128i_i64[0];
}
while ( v52 );
}
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v58);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v54);
if ( v50.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale((std::locale *)v49);
return a1;
} | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R14,[RBP + -0x268]
LEA R15,[RBP + -0x1d0]
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x278
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,R14
MOV qword ptr [RBP + -0x290],R14
CALL 0x00104710
PXOR XMM0,XMM0
MOV RCX,R14
MOV RDI,R15
LEA RDX,[0x11b61f]
MOV R8D,0x10
MOVAPS xmmword ptr [RBP + -0x260],XMM0
LEA RSI,[RDX + -0x7]
LAB_00105e2b:
CALL 0x00119df0
MOVDQA XMM0,xmmword ptr [RBP + -0xd0]
MOV RDI,qword ptr [RBP + -0x258]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOVAPS xmmword ptr [RBP + -0x260],XMM0
TEST RDI,RDI
JZ 0x00105e5b
CALL 0x00107770
LAB_00105e5b:
MOV RDI,qword ptr [RBP + -0xa0]
MOV dword ptr [RBP + -0x270],0x10
TEST RDI,RDI
JZ 0x00105ebf
MOV RAX,qword ptr [RBP + -0x58]
LEA R12,[RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x78]
CMP RAX,R12
JNC 0x00105eab
NOP word ptr [RAX + RAX*0x1]
LAB_00105e88:
MOV R14,RAX
MOV RDI,qword ptr [RAX]
MOV ESI,0x1f8
ADD R14,0x8
CALL 0x00104580
MOV RAX,R14
CMP R14,R12
JC 0x00105e88
MOV RDI,qword ptr [RBP + -0xa0]
LAB_00105eab:
MOV RAX,qword ptr [RBP + -0x98]
LEA RSI,[RAX*0x8]
CALL 0x00104580
LAB_00105ebf:
LEA RDI,[RBP + -0xc0]
CALL 0x00104600
MOV RDI,qword ptr [RBP + -0xc8]
TEST RDI,RDI
JZ 0x00105edc
CALL 0x00107770
LAB_00105edc:
LEA RDI,[RBP + -0x100]
CALL 0x00104600
MOV RAX,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
XOR R9D,R9D
LEA RCX,[RBP + -0x270]
SUB RSP,0x8
XOR R8D,R8D
MOV dword ptr [RBP + -0x238],0x0
ADD RDX,RAX
MOVQ XMM0,RAX
MOV qword ptr [RBP + -0x2a0],RCX
LEA R13,[RBP + -0x230]
MOVQ XMM2,RDX
MOV qword ptr [RBP + -0x240],RCX
MOV RDX,R13
PUNPCKLQDQ XMM0,XMM2
MOVAPS xmmword ptr [RBP + -0x250],XMM0
MOVQ RDI,XMM0
PXOR XMM0,XMM0
MOV RSI,qword ptr [RBP + -0x248]
MOVAPS xmmword ptr [RBP + -0x230],XMM0
MOVAPS xmmword ptr [RBP + -0x220],XMM0
PUSH 0x0
LAB_00105f5b:
CALL 0x00111ec0
LEA RDX,[RBP + -0x1f0]
POP R8
POP R9
MOV qword ptr [RBP + -0x298],RDX
TEST AL,AL
JZ 0x001063b8
LAB_00105f7a:
LEA RDX,[RBP + -0x1c0]
PXOR XMM0,XMM0
MOV RAX,qword ptr [RBP + -0x240]
MOV qword ptr [RBP + -0x288],RDX
MOVAPS xmmword ptr [RBP + -0x200],XMM0
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x1f0],XMM0
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
LAB_00105fb3:
TEST RAX,RAX
JZ 0x001061cb
LAB_00105fbc:
MOV RDX,qword ptr [RBP + -0x228]
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,RDX
SUB RCX,RAX
CMP RDX,RAX
JZ 0x00105fdb
CMP RCX,0x48
JNZ 0x00105fe0
LAB_00105fdb:
LEA RAX,[RAX + RCX*0x1 + -0x48]
LAB_00105fe0:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00106120
MOV RAX,qword ptr [RBP + -0x288]
MOV RSI,qword ptr [RBX + 0x8]
MOV byte ptr [RBP + -0x1c0],0x0
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x1d0],RAX
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x00106189
LAB_00106018:
LEA RDX,[RSI + 0x10]
MOV RDI,qword ptr [RBP + -0x288]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RBP + -0x1d0]
CMP RAX,RDI
JZ 0x001062b0
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RSI + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x1c8]
LAB_0010604b:
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [RBX + 0x8],0x20
LAB_00106054:
MOV RDX,qword ptr [RBP + -0x228]
MOV RAX,qword ptr [RBP + -0x230]
MOV RCX,RDX
SUB RCX,RAX
CMP RDX,RAX
JZ 0x00106076
MOV RSI,RAX
CMP RCX,0x48
JNZ 0x0010607b
LAB_00106076:
LEA RSI,[RAX + RCX*0x1 + -0x48]
LAB_0010607b:
CMP byte ptr [RSI + 0x10],0x0
JZ 0x00106105
CMP RDX,RAX
JZ 0x001062a0
MOV R12,qword ptr [RAX + 0x8]
CMP RCX,0x48
JNZ 0x0010609d
LAB_00106098:
LEA RAX,[RAX + RCX*0x1 + -0x48]
LAB_0010609d:
CMP qword ptr [RAX],R12
JZ 0x00106228
MOV RCX,qword ptr [RBP + -0x240]
MOV RDI,R12
LAB_001060b0:
MOV R8D,dword ptr [RBP + -0x238]
SUB RSP,0x8
XOR R9D,R9D
MOV RDX,R13
MOV RSI,qword ptr [RBP + -0x248]
OR R8B,0x80
MOV dword ptr [RBP + -0x238],R8D
PUSH 0x0
LAB_001060d5:
CALL 0x00111ec0
POP RDX
POP RCX
TEST AL,AL
JZ 0x001061c0
MOV RAX,qword ptr [RBP + -0x228]
CMP qword ptr [RAX + -0x28],R12
MOV qword ptr [RAX + -0x30],R12
SETNZ byte ptr [RAX + -0x20]
MOV RAX,qword ptr [RBP + -0x250]
MOV qword ptr [RBP + -0x218],RAX
LAB_00106105:
MOV RAX,qword ptr [RBP + -0x240]
TEST RAX,RAX
JNZ 0x00105fbc
JMP 0x001061cb
LAB_00106120:
MOV R14,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x1c8],0x0
MOV RAX,qword ptr [RBP + -0x288]
SUB R12,R14
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x278],R12
CMP R12,0xf
JA 0x00106318
CMP R12,0x1
JNZ 0x00106300
MOVZX EAX,byte ptr [R14]
MOV byte ptr [RBP + -0x1c0],AL
LAB_00106168:
MOV RAX,qword ptr [RBP + -0x288]
LAB_0010616f:
MOV qword ptr [RBP + -0x1c8],R12
MOV byte ptr [RAX + R12*0x1],0x0
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JNZ 0x00106018
LAB_00106189:
MOV RDX,R15
MOV RDI,RBX
LAB_0010618f:
CALL 0x00107c50
MOV RDI,qword ptr [RBP + -0x1d0]
MOV RAX,qword ptr [RBP + -0x288]
CMP RDI,RAX
JZ 0x00106054
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RSI,[RAX + 0x1]
CALL 0x00104580
JMP 0x00106054
LAB_001061c0:
MOV qword ptr [RBP + -0x240],0x0
LAB_001061cb:
MOV RDI,qword ptr [RBP + -0x298]
CALL 0x00107920
MOV RDI,R13
CALL 0x00107920
MOV RDI,qword ptr [RBP + -0x258]
TEST RDI,RDI
JZ 0x001061f0
CALL 0x00107770
LAB_001061f0:
MOV RDI,qword ptr [RBP + -0x290]
CALL 0x00104660
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106448
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00106228:
CMP qword ptr [RBP + -0x248],R12
JZ 0x001061c0
SUB RSP,0x8
XOR R9D,R9D
MOV RDX,R13
MOV RDI,R12
MOV R8D,dword ptr [RBP + -0x238]
MOV RCX,qword ptr [RBP + -0x240]
PUSH 0x0
MOV RSI,qword ptr [RBP + -0x248]
OR R8D,0x60
LAB_00106259:
CALL 0x00111ec0
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x240]
POP RSI
POP RDI
LEA RDI,[R12 + 0x1]
MOV RCX,RAX
TEST DL,DL
JZ 0x001060b0
MOV RDX,qword ptr [RBP + -0x228]
CMP qword ptr [RDX + -0x28],R12
MOV qword ptr [RDX + -0x30],R12
SETNZ byte ptr [RDX + -0x20]
MOV RDX,qword ptr [RBP + -0x250]
MOV qword ptr [RBP + -0x218],RDX
JMP 0x00105fb3
LAB_001062a0:
MOV R12,qword ptr [RAX + -0x40]
JMP 0x00106098
LAB_001062b0:
MOV RAX,qword ptr [RBP + -0x1c8]
LEA RCX,[RAX + 0x1]
CMP ECX,0x8
JNC 0x00106360
TEST CL,0x4
JNZ 0x00106430
TEST ECX,ECX
JZ 0x0010604b
MOVZX EDI,byte ptr [RDI]
MOV byte ptr [RSI + 0x10],DIL
TEST CL,0x2
JZ 0x0010604b
MOV RDI,qword ptr [RBP + -0x288]
MOV ECX,ECX
MOVZX EDI,word ptr [RDI + RCX*0x1 + -0x2]
MOV word ptr [RDX + RCX*0x1 + -0x2],DI
JMP 0x0010604b
LAB_00106300:
TEST R12,R12
JZ 0x00106168
MOV RDI,qword ptr [RBP + -0x288]
JMP 0x00106341
LAB_00106318:
LEA RSI,[RBP + -0x278]
XOR EDX,EDX
MOV RDI,R15
CALL 0x001046c0
MOV qword ptr [RBP + -0x1d0],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x278]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_00106341:
MOV RDX,R12
MOV RSI,R14
CALL 0x00104550
MOV R12,qword ptr [RBP + -0x278]
MOV RAX,qword ptr [RBP + -0x1d0]
JMP 0x0010616f
LAB_00106360:
MOV R11,RDI
MOV RDI,qword ptr [RDI]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,ECX
MOV R8,qword ptr [R11 + RDI*0x1 + -0x8]
MOV qword ptr [RDX + RDI*0x1 + -0x8],R8
LEA RDI,[RSI + 0x18]
AND RDI,-0x8
SUB RDX,RDI
ADD ECX,EDX
SUB R11,RDX
AND ECX,0xfffffff8
MOV R8,R11
CMP ECX,0x8
JC 0x0010604b
AND ECX,0xfffffff8
XOR EDX,EDX
LAB_0010639a:
MOV R9D,EDX
ADD EDX,0x8
MOV R10,qword ptr [R8 + R9*0x1]
MOV qword ptr [RDI + R9*0x1],R10
CMP EDX,ECX
JC 0x0010639a
JMP 0x0010604b
LAB_001063b8:
PXOR XMM0,XMM0
MOV RSI,RDX
MOV RDI,R13
MOV R14,RDX
MOVAPS xmmword ptr [RBP + -0x200],XMM0
PXOR XMM0,XMM0
MOV qword ptr [RBP + -0x250],0x0
MOV qword ptr [RBP + -0x248],0x0
MOV qword ptr [RBP + -0x240],0x0
MOV dword ptr [RBP + -0x238],0x0
MOVAPS xmmword ptr [RBP + -0x210],XMM0
MOVAPS xmmword ptr [RBP + -0x1f0],XMM0
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
LAB_00106410:
CALL 0x001050b0
MOV RAX,qword ptr [RBP + -0x1d8]
MOV RDI,R14
MOV qword ptr [RBP + -0x218],RAX
CALL 0x00107920
JMP 0x00105f7a
LAB_00106430:
MOV R10,RDI
MOV EDI,dword ptr [RDI]
MOV ECX,ECX
MOV dword ptr [RSI + 0x10],EDI
MOV EDI,dword ptr [R10 + RCX*0x1 + -0x4]
MOV dword ptr [RDX + RCX*0x1 + -0x4],EDI
JMP 0x0010604b
LAB_00106448:
CALL 0x001045c0 | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string const&) */
string * func0(string *param_1)
{
int *__src;
int8 this;
int auVar1 [16];
bool bVar2;
long *plVar3;
uint uVar4;
long lVar5;
uint uVar6;
long *in_RSI;
long lVar7;
ulong uVar8;
int8 *puVar9;
long in_FS_OFFSET;
ulong local_280;
int4 local_278 [2];
locale local_270 [2];
int local_268 [16];
long local_258;
long lStack_250;
regex *local_248;
uint local_240;
int local_238 [16];
int local_228 [16];
int local_218 [16];
int local_208 [16];
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_1f8 [16];
int local_1e8 [16];
ulong *local_1d8;
int8 local_1d0;
ulong local_1c8 [30];
int local_d8 [48];
void *local_a8;
long local_a0;
int8 *local_80;
long local_60;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
std::locale::locale(local_270);
local_268 = (int [16])0x0;
/* try { // try from 00105e2b to 00105e2f has its CatchHandler @ 00106471 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,"[ae]\\w+","",local_270,0x10);
auVar1 = local_d8._0_16_;
this = local_268._8_8_;
local_d8._0_16_ = (int [16])0x0;
local_268 = auVar1;
if ((_Sp_counted_base<(_Lock_policy)2> *)this != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release((_Sp_counted_base<(_Lock_policy)2> *)this);
}
local_278[0] = 0x10;
if (local_a8 != (void *)0x0) {
for (puVar9 = local_80; puVar9 < (int8 *)(local_60 + 8U); puVar9 = puVar9 + 1) {
operator_delete((void *)*puVar9,0x1f8);
}
operator_delete(local_a8,local_a0 * 8);
}
std::string::_M_dispose();
if ((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
std::string::_M_dispose();
local_258 = *in_RSI;
local_248 = (regex *)local_278;
local_240 = 0;
lStack_250 = in_RSI[1] + local_258;
local_238 = (int [16])0x0;
local_228 = (int [16])0x0;
/* try { // try from 00105f5b to 00105f5f has its CatchHandler @ 0010644d */
bVar2 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)local_258,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,0,0,false);
if (!bVar2) {
local_208 = (int [16])0x0;
local_258 = 0;
lStack_250 = 0;
local_248 = (regex *)0x0;
local_240 = 0;
local_218 = (int [16])0x0;
local_1f8[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1e8 = (int [16])0x0;
/* try { // try from 00106410 to 00106414 has its CatchHandler @ 0010647d */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator=((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_238,(vector *)local_1f8);
local_228._8_8_ = local_1e8._8_8_;
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_1f8);
}
local_208 = (int [16])0x0;
local_218 = (int [16])0x0;
local_1f8[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1f8[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_1e8 = (int [16])0x0;
do {
joined_r0x00105fb6:
if (local_248 == (regex *)0x0) goto LAB_001061cb;
if ((local_238._8_8_ == local_238._0_8_) || (local_238._8_8_ - local_238._0_8_ == 0x48)) {
local_238._0_8_ = local_238._0_8_ + (local_238._8_8_ - local_238._0_8_) + -0x48;
}
local_1c8[0]._1_7_ = (uint7)(local_1c8[0] >> 8);
local_1d8 = local_1c8;
if (*(char *)(local_238._0_8_ + 0x10) == '\0') {
plVar3 = *(long **)(param_1 + 8);
local_1c8[0] = (ulong)local_1c8[0]._1_7_ << 8;
local_1d0 = 0;
if (plVar3 != *(long **)(param_1 + 0x10)) goto LAB_00106018;
LAB_00106189:
/* try { // try from 0010618f to 00106193 has its CatchHandler @ 00106465 */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar3,(string *)&local_1d8);
if (local_1d8 != local_1c8) {
operator_delete(local_1d8,local_1c8[0] + 1);
}
}
else {
__src = *(int **)local_238._0_8_;
local_1d0 = 0;
uVar8 = *(long *)(local_238._0_8_ + 8) - (long)__src;
local_280 = uVar8;
if (uVar8 < 0x10) {
if (uVar8 == 1) {
local_1c8[0] = CONCAT71(local_1c8[0]._1_7_,*__src);
}
else if (uVar8 != 0) goto LAB_00106341;
}
else {
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_280);
local_1c8[0] = local_280;
LAB_00106341:
memcpy(local_1d8,__src,uVar8);
}
*(int *)((long)local_1d8 + local_280) = 0;
plVar3 = *(long **)(param_1 + 8);
local_1d0 = local_280;
if (plVar3 == *(long **)(param_1 + 0x10)) goto LAB_00106189;
LAB_00106018:
*plVar3 = (long)(plVar3 + 2);
if (local_1d8 == local_1c8) {
uVar8 = local_1d0 + 1;
uVar4 = (uint)uVar8;
if (uVar4 < 8) {
if ((uVar8 & 4) == 0) {
if (uVar4 != 0) {
*(int *)(plVar3 + 2) = (int)local_1c8[0];
if ((uVar8 & 2) != 0) {
*(int2 *)((long)plVar3 + (uVar8 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1c8 + ((uVar8 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar3 + 2) = (int4)local_1c8[0];
*(int4 *)((long)plVar3 + (uVar8 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1c8 + ((uVar8 & 0xffffffff) - 4));
}
}
else {
plVar3[2] = local_1c8[0];
*(int8 *)((long)plVar3 + (uVar8 & 0xffffffff) + 8) =
*(int8 *)((long)local_1c8 + ((uVar8 & 0xffffffff) - 8));
lVar5 = (long)(plVar3 + 2) - ((ulong)(plVar3 + 3) & 0xfffffffffffffff8);
uVar4 = uVar4 + (int)lVar5 & 0xfffffff8;
if (7 < uVar4) {
uVar6 = 0;
do {
uVar8 = (ulong)uVar6;
uVar6 = uVar6 + 8;
*(int8 *)(((ulong)(plVar3 + 3) & 0xfffffffffffffff8) + uVar8) =
*(int8 *)((long)local_1c8 + (uVar8 - lVar5));
} while (uVar6 < uVar4);
}
}
}
else {
*plVar3 = (long)local_1d8;
plVar3[2] = local_1c8[0];
}
plVar3[1] = local_1d0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
lVar5 = local_238._8_8_ - local_238._0_8_;
if ((local_238._8_8_ == local_238._0_8_) || (plVar3 = (long *)local_238._0_8_, lVar5 == 0x48)) {
plVar3 = (long *)(local_238._0_8_ + lVar5 + -0x48);
}
if (*(char *)(plVar3 + 2) == '\0') {
LAB_00106105:
goto joined_r0x00105fb6;
}
if (local_238._8_8_ == local_238._0_8_) {
lVar7 = *(long *)(local_238._0_8_ + -0x40);
LAB_00106098:
plVar3 = (long *)(local_238._0_8_ + lVar5 + -0x48);
}
else {
lVar7 = *(long *)(local_238._0_8_ + 8);
plVar3 = (long *)local_238._0_8_;
if (lVar5 == 0x48) goto LAB_00106098;
}
lVar5 = lVar7;
if (*plVar3 != lVar7) {
LAB_001060b0:
local_240 = local_240 | 0x80;
/* try { // try from 001060d5 to 001060d9 has its CatchHandler @ 00106459 */
bVar2 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)lVar5,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,local_240,0,false);
if (bVar2) {
*(long *)(local_238._8_8_ + -0x30) = lVar7;
*(bool *)(local_238._8_8_ + -0x20) = *(long *)(local_238._8_8_ + -0x28) != lVar7;
local_228._8_8_ = local_258;
goto LAB_00106105;
}
LAB_001061c0:
local_248 = (regex *)0x0;
LAB_001061cb:
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_1f8);
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_238);
if ((_Sp_counted_base<(_Lock_policy)2> *)local_268._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release
((_Sp_counted_base<(_Lock_policy)2> *)local_268._8_8_);
}
std::locale::~locale(local_270);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (lStack_250 == lVar7) goto LAB_001061c0;
/* try { // try from 00106259 to 00106328 has its CatchHandler @ 00106459 */
bVar2 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)lVar7,(__normal_iterator)lStack_250,
(match_results *)local_238,local_248,local_240 | 0x60,0,false);
lVar5 = lVar7 + 1;
if (!bVar2) goto LAB_001060b0;
*(long *)(local_238._8_8_ + -0x30) = lVar7;
*(bool *)(local_238._8_8_ + -0x20) = *(long *)(local_238._8_8_ + -0x28) != lVar7;
local_228._8_8_ = local_258;
} while( true );
} |
1,016 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
#include <string>
#include <functional>
| std::vector<std::vector<std::string>> func0(std::vector<std::string> l, int n) {
int size = l.size();
std::vector<std::vector<std::string>> result;
// Helper function to generate combinations
std::function<void(int, std::vector<std::string>&, int)> generate =
[&](int index, std::vector<std::string>& current, int depth) {
if(depth == n) {
result.push_back(current);
return;
}
for(int i = index; i < size; i++) {
current.push_back(l[i]);
generate(i, current, depth + 1);
current.pop_back();
}
};
std::vector<std::string> current;
generate(0, current, 0);
return result;
}
| int main() {
std::vector<std::vector<std::string>> expected;
expected = {{"Red"}, {"Green"}, {"Blue"}};
assert(func0({"Red", "Green", "Blue"}, 1) == expected);
expected = {{"Red", "Red"}, {"Red", "Green"}, {"Red", "Blue"}, {"Green", "Green"}, {"Green", "Blue"}, {"Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 2) == expected);
expected = {{"Red", "Red", "Red"}, {"Red", "Red", "Green"}, {"Red", "Red", "Blue"}, {"Red", "Green", "Green"}, {"Red", "Green", "Blue"},
{"Red", "Blue", "Blue"}, {"Green", "Green", "Green"}, {"Green", "Green", "Blue"}, {"Green", "Blue", "Blue"}, {"Blue", "Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 3) == expected);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int)::{lambda(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int)#1}::operator()(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int) const:
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x18(%rbp),%rax
mov (%rax),%rax
mov (%rax),%eax
cmp %eax,-0x20(%rbp)
jne 25e7 <_ZZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUliRS7_iE_clEiS8_i+0x3d>
mov -0x18(%rbp),%rax
mov 0x8(%rax),%rax
mov -0x28(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 5a0e <_ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE9push_backERKS7_>
jmp 2656 <_ZZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUliRS7_iE_clEiS8_i+0xac>
mov -0x1c(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%rax
mov 0x10(%rax),%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jge 2656 <_ZZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUliRS7_iE_clEiS8_i+0xac>
mov -0x18(%rbp),%rax
mov 0x18(%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 5a8e <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 5ab2 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_>
mov -0x18(%rbp),%rax
mov 0x20(%rax),%rax
mov -0x20(%rbp),%edx
lea 0x1(%rdx),%ecx
mov -0x28(%rbp),%rdx
mov -0x4(%rbp),%esi
mov %rax,%rdi
callq 5b32 <_ZNKSt8functionIFviRSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEiEEclEiS9_i>
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 5bb6 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE8pop_backEv>
addl $0x1,-0x4(%rbp)
jmp 25ed <_ZZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUliRS7_iE_clEiS8_i+0x43>
leaveq
retq
| _ZZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiENKUliRS7_iE_clEiS8_i:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_20], ecx
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
cmp [rbp+var_20], eax
jnz short loc_2567
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov rdx, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE9push_backERKS7_; std::vector<std::vector<std::string>>::push_back(std::vector<std::string> const&)
jmp short locret_25D6
loc_2567:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp short loc_25C7
loc_256F:
mov rax, [rbp+var_18]
mov rax, [rax+18h]
mov edx, [rbp+var_4]
movsxd rdx, edx
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdx, rax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
mov rax, [rbp+var_18]
mov rax, [rax+20h]
mov edx, [rbp+var_20]
lea ecx, [rdx+1]
mov rdx, [rbp+var_28]
mov esi, [rbp+var_4]
mov rdi, rax
call _ZNKSt8functionIFviRSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEiEEclEiS9_i; std::function<void ()(int,std::vector<std::string> &,int)>::operator()(int,std::vector<std::string> &,int)
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE8pop_backEv; std::vector<std::string>::pop_back(void)
add [rbp+var_4], 1
loc_25C7:
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov eax, [rax]
cmp [rbp+var_4], eax
jl short loc_256F
locret_25D6:
leave
retn | long long func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1}::operator()(
long long a1,
int a2,
long long a3,
int a4)
{
long long result; // rax
long long v5; // rax
if ( a4 == **(_DWORD **)a1 )
return std::vector<std::vector<std::string>>::push_back(*(_QWORD *)(a1 + 8), a3);
while ( 1 )
{
result = **(unsigned int **)(a1 + 16);
if ( a2 >= (int)result )
break;
v5 = std::vector<std::string>::operator[](*(_QWORD *)(a1 + 24), a2);
std::vector<std::string>::push_back(a3, v5);
std::function<void ()(int,std::vector<std::string> &,int)>::operator()(
*(_QWORD *)(a1 + 32),
(unsigned int)a2,
a3,
(unsigned int)(a4 + 1));
std::vector<std::string>::pop_back(a3);
++a2;
}
return result;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV dword ptr [RBP + -0x94],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x90]
MOV RDI,RAX
CALL 0x00103dbe
MOV dword ptr [RBP + -0x74],EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,RAX
CALL 0x00103c50
LEA RAX,[RBP + -0x94]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[RBP + -0x74]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x58],RAX
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
LEA RDX,[RBP + -0x70]
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010266b:
CALL 0x001034ec
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00103cd8
LEA RDX,[RBP + -0x70]
LEA RAX,[RBP + -0x40]
MOV ECX,0x0
MOV ESI,0x0
MOV RDI,RAX
LAB_00102691:
CALL 0x0010410a
NOP
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x0010429a
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00103c70
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010271c
JMP 0x00102717
LAB_00102717:
CALL 0x001023c0
LAB_0010271c:
MOV RAX,qword ptr [RBP + -0x88]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::string, std::allocator<std::string > >, int) */
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
* func0(vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
*param_1,vector<std::string,std::allocator<std::string>> *param_2,int4 param_3)
{
long in_FS_OFFSET;
int4 local_9c;
vector<std::string,std::allocator<std::string>> *local_98;
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
*local_90;
int4 local_7c;
int4 *local_78;
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
*local_70;
int4 *local_68;
vector<std::string,std::allocator<std::string>> *local_60;
function<void(int,std::vector<std::string,std::allocator<std::string>>&,int)> *local_58;
function<void(int,std::vector<std::string,std::allocator<std::string>>&,int)> local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_9c = param_3;
local_98 = param_2;
local_90 = param_1;
local_7c = std::vector<std::string,std::allocator<std::string>>::size(param_2);
std::
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
::vector(local_90);
local_78 = &local_9c;
local_70 = local_90;
local_68 = &local_7c;
local_60 = local_98;
local_58 = local_48;
/* try { // try from 0010266b to 0010266f has its CatchHandler @ 001026e2 */
std::function<void(int,std::vector<std::string,std::allocator<std::string>>&,int)>::
function<func0(std::vector<std::string,std::allocator<std::string>>,int)::_lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)_1_,void>
(local_48,(_lambda_int_std__vector<std::string,std::allocator<std::string_>_>__int__1_ *
)&local_78);
std::vector<std::string,std::allocator<std::string>>::vector
((vector<std::string,std::allocator<std::string>> *)&local_78);
/* try { // try from 00102691 to 00102695 has its CatchHandler @ 001026c1 */
std::function<void(int,std::vector<std::string,std::allocator<std::string>>&,int)>::operator()
(local_48,0,(vector *)&local_78,0);
std::vector<std::string,std::allocator<std::string>>::~vector
((vector<std::string,std::allocator<std::string>> *)&local_78);
std::function<void(int,std::vector<std::string,std::allocator<std::string>>&,int)>::~function
(local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_90;
} |
1,017 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
#include <string>
#include <functional>
| std::vector<std::vector<std::string>> func0(std::vector<std::string> l, int n) {
int size = l.size();
std::vector<std::vector<std::string>> result;
// Helper function to generate combinations
std::function<void(int, std::vector<std::string>&, int)> generate =
[&](int index, std::vector<std::string>& current, int depth) {
if(depth == n) {
result.push_back(current);
return;
}
for(int i = index; i < size; i++) {
current.push_back(l[i]);
generate(i, current, depth + 1);
current.pop_back();
}
};
std::vector<std::string> current;
generate(0, current, 0);
return result;
}
| int main() {
std::vector<std::vector<std::string>> expected;
expected = {{"Red"}, {"Green"}, {"Blue"}};
assert(func0({"Red", "Green", "Blue"}, 1) == expected);
expected = {{"Red", "Red"}, {"Red", "Green"}, {"Red", "Blue"}, {"Green", "Green"}, {"Green", "Blue"}, {"Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 2) == expected);
expected = {{"Red", "Red", "Red"}, {"Red", "Red", "Green"}, {"Red", "Red", "Blue"}, {"Red", "Green", "Green"}, {"Red", "Green", "Blue"},
{"Red", "Blue", "Blue"}, {"Green", "Green", "Green"}, {"Green", "Green", "Blue"}, {"Green", "Blue", "Blue"}, {"Blue", "Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 3) == expected);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O1 | cpp | std::_Function_base::_Base_manager<func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int)::{lambda(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int)#1}>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
cmp $0x2,%edx
je 1418 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x4f>
ja 13e9 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x20>
test %edx,%edx
je 1402 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x39>
mov (%rsi),%rax
mov %rax,(%rdi)
jmp 140c <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x43>
cmp $0x3,%edx
jne 140c <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x43>
mov (%rdi),%rdi
test %rdi,%rdi
je 140c <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x43>
mov $0x28,%esi
callq 1260 <_ZdlPvm@plt>
jmp 140c <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x43>
lea 0x48e7(%rip),%rax
mov %rax,(%rdi)
mov $0x0,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
mov (%rsi),%rbp
mov $0x28,%edi
callq 1250 <_Znwm@plt>
movdqu 0x0(%rbp),%xmm0
movups %xmm0,(%rax)
movdqu 0x10(%rbp),%xmm1
movups %xmm1,0x10(%rax)
mov 0x20(%rbp),%rdx
mov %rdx,0x20(%rax)
mov %rax,(%rbx)
jmp 140c <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x43>
| _ZNSt17_Function_handlerIFviRSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEiEZ5func0S8_iEUliS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
test edx, edx
jz short loc_13DD
cmp edx, 1
jz short loc_13F3
cmp edx, 2
jz short loc_13FB
cmp edx, 3
jnz short loc_13E7
mov rdi, [rdi]; void *
test rdi, rdi
jz short loc_13E7
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_13E7
loc_13DD:
lea rax, _ZTIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiEUliRS7_iE_; `typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1}
mov [rdi], rax
loc_13E7:
mov eax, 0
add rsp, 8
pop rbx
pop rbp
retn
loc_13F3:
mov rax, [rsi]
mov [rdi], rax
jmp short loc_13E7
loc_13FB:
mov rbp, [rsi]
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
movdqu xmm0, xmmword ptr [rbp+0]
movups xmmword ptr [rax], xmm0
movdqu xmm1, xmmword ptr [rbp+10h]
movups xmmword ptr [rax+10h], xmm1
mov rdx, [rbp+20h]
mov [rax+20h], rdx
mov [rbx], rax
jmp short loc_13E7 | long long std::_Function_handler<void ()(int,std::vector<std::string> &,int),func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string> &,int)#1}>::_M_manager(
__m128i **a1,
const __m128i **a2,
int a3)
{
__m128i *v3; // rdi
const __m128i *v5; // rbp
__m128i *v6; // rax
if ( a3 )
{
switch ( a3 )
{
case 1:
*a1 = (__m128i *)*a2;
break;
case 2:
v5 = *a2;
v6 = (__m128i *)operator new(0x28uLL);
*v6 = _mm_loadu_si128(v5);
v6[1] = _mm_loadu_si128(v5 + 1);
v6[2].m128i_i64[0] = v5[2].m128i_i64[0];
*a1 = v6;
break;
case 3:
v3 = *a1;
if ( v3 )
operator delete(v3, 0x28uLL);
break;
}
}
else
{
*a1 = (__m128i *)&`typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1};
}
return 0LL;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x70
MOV R12,RDI
MOV RBX,RSI
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,qword ptr [RSI]
SAR RAX,0x5
MOV dword ptr [RSP + 0x14],EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV EDI,0x28
LAB_00101492:
CALL 0x00101240
LEA RDX,[RSP + 0xc]
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],R12
LEA RDX,[RSP + 0x14]
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],RBX
LEA RDI,[RSP + 0x40]
MOV qword ptr [RAX + 0x20],RDI
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x1015f5]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[0x1013a9]
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV dword ptr [RSP + 0x18],0x0
MOV dword ptr [RSP + 0x1c],0x0
LEA RCX,[RSP + 0x1c]
LEA RDX,[RSP + 0x20]
LEA RSI,[RSP + 0x18]
LAB_00101510:
CALL 0x001015f5
JMP 0x00101549
LAB_00101549:
MOV RBP,qword ptr [RSP + 0x28]
MOV RBX,qword ptr [RSP + 0x20]
CMP RBP,RBX
JNZ 0x001015ad
LAB_00101558:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0010156f
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x00101250
LAB_0010156f:
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x00101588
LEA RDI,[RSP + 0x40]
MOV EDX,0x3
MOV RSI,RDI
CALL RAX
LAB_00101588:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001015f0
MOV RAX,R12
ADD RSP,0x70
POP RBX
POP RBP
POP R12
RET
LAB_001015a4:
ADD RBX,0x20
CMP RBP,RBX
JZ 0x00101558
LAB_001015ad:
MOV RDI,qword ptr [RBX]
LEA RAX,[RBX + 0x10]
CMP RDI,RAX
JZ 0x001015a4
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CALL 0x00101250
JMP 0x001015a4
LAB_001015f0:
CALL 0x00101260 | /* func0(std::vector<std::string, std::allocator<std::string > >, int) */
int8 * func0(vector param_1,int param_2)
{
int8 *puVar1;
long *plVar2;
int8 *puVar3;
int4 in_register_00000034;
long *plVar4;
int4 in_register_0000003c;
int8 *puVar5;
long in_FS_OFFSET;
int local_7c [8];
int4 local_74;
int local_70;
int local_6c;
int8 *local_68;
int8 *local_60;
long local_58;
int local_48 [16];
code *local_38;
code *local_30;
long local_20;
puVar5 = (int8 *)CONCAT44(in_register_0000003c,param_1);
plVar4 = (long *)CONCAT44(in_register_00000034,param_2);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_74 = (int4)(plVar4[1] - *plVar4 >> 5);
*puVar5 = 0;
puVar5[1] = 0;
puVar5[2] = 0;
local_48 = (int [16])0x0;
local_38 = (code *)0x0;
local_30 = (code *)0x0;
/* try { // try from 00101492 to 00101496 has its CatchHandler @ 00101517 */
plVar2 = (long *)operator_new(0x28);
*plVar2 = (long)local_7c;
plVar2[1] = (long)puVar5;
plVar2[2] = (long)&local_74;
plVar2[3] = (long)plVar4;
plVar2[4] = (long)local_48;
local_48._0_8_ = plVar2;
local_30 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke;
local_38 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_manager;
local_68 = (int8 *)0x0;
local_60 = (int8 *)0x0;
local_58 = 0;
local_70 = 0;
local_6c = 0;
/* try { // try from 00101510 to 00101514 has its CatchHandler @ 001015c8 */
std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke((_Any_data *)local_48,&local_70,(vector *)&local_68,&local_6c);
puVar1 = local_60;
for (puVar3 = local_68; puVar1 != puVar3; puVar3 = puVar3 + 4) {
if ((int8 *)*puVar3 != puVar3 + 2) {
operator_delete((int8 *)*puVar3,puVar3[2] + 1);
}
}
if (local_68 != (int8 *)0x0) {
operator_delete(local_68,local_58 - (long)local_68);
}
if (local_38 != (code *)0x0) {
(*local_38)(local_48,local_48,3);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return puVar5;
} |
1,018 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
#include <string>
#include <functional>
| std::vector<std::vector<std::string>> func0(std::vector<std::string> l, int n) {
int size = l.size();
std::vector<std::vector<std::string>> result;
// Helper function to generate combinations
std::function<void(int, std::vector<std::string>&, int)> generate =
[&](int index, std::vector<std::string>& current, int depth) {
if(depth == n) {
result.push_back(current);
return;
}
for(int i = index; i < size; i++) {
current.push_back(l[i]);
generate(i, current, depth + 1);
current.pop_back();
}
};
std::vector<std::string> current;
generate(0, current, 0);
return result;
}
| int main() {
std::vector<std::vector<std::string>> expected;
expected = {{"Red"}, {"Green"}, {"Blue"}};
assert(func0({"Red", "Green", "Blue"}, 1) == expected);
expected = {{"Red", "Red"}, {"Red", "Green"}, {"Red", "Blue"}, {"Green", "Green"}, {"Green", "Blue"}, {"Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 2) == expected);
expected = {{"Red", "Red", "Red"}, {"Red", "Red", "Green"}, {"Red", "Red", "Blue"}, {"Red", "Green", "Green"}, {"Red", "Green", "Blue"},
{"Red", "Blue", "Blue"}, {"Green", "Green", "Green"}, {"Green", "Green", "Blue"}, {"Green", "Blue", "Blue"}, {"Blue", "Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 3) == expected);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O2 | cpp | std::_Function_base::_Base_manager<func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int)::{lambda(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int)#1}>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation):
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x2,%edx
je 2760 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x50>
ja 2740 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x30>
test %edx,%edx
je 2798 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x88>
mov (%rsi),%rax
mov %rax,(%rdi)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
cmp $0x3,%edx
jne 272e <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x1e>
mov (%rdi),%rdi
test %rdi,%rdi
je 272e <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x1e>
mov $0x28,%esi
callq 1280 <_ZdlPvm@plt>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
mov (%rsi),%rbp
mov $0x28,%edi
callq 1270 <_Znwm@plt>
movdqu 0x0(%rbp),%xmm0
movups %xmm0,(%rax)
movdqu 0x10(%rbp),%xmm1
movups %xmm1,0x10(%rax)
mov 0x20(%rbp),%rdx
mov %rdx,0x20(%rax)
mov %rax,(%rbx)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
lea 0x3549(%rip),%rax
mov %rax,(%rdi)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
| _ZNSt17_Function_handlerIFviRSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEiEZ5func0S8_iEUliS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
test edx, edx
jz short loc_3120
cmp edx, 1
jz short loc_3108
cmp edx, 2
jz short loc_3138
cmp edx, 3
jnz short loc_310E
mov rdi, [rdi]; void *
test rdi, rdi
jz short loc_310E
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_310E
loc_3108:
mov rax, [rsi]
mov [rdi], rax
loc_310E:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_3120:
lea rax, _ZTIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiEUliRS7_iE_; `typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1}
mov [rdi], rax
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_3138:
mov rbp, [rsi]
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
movdqu xmm0, xmmword ptr [rbp+0]
movups xmmword ptr [rax], xmm0
movdqu xmm1, xmmword ptr [rbp+10h]
movups xmmword ptr [rax+10h], xmm1
mov rdx, [rbp+20h]
mov [rax+20h], rdx
mov [rbx], rax
jmp short loc_310E | long long std::_Function_handler<void ()(int,std::vector<std::string> &,int),func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string> &,int)#1}>::_M_manager(
__m128i **a1,
const __m128i **a2,
int a3)
{
__m128i *v3; // rdi
const __m128i *v5; // rbp
__m128i *v6; // rax
if ( a3 )
{
switch ( a3 )
{
case 1:
*a1 = (__m128i *)*a2;
break;
case 2:
v5 = *a2;
v6 = (__m128i *)operator new(0x28uLL);
*v6 = _mm_loadu_si128(v5);
v6[1] = _mm_loadu_si128(v5 + 1);
v6[2].m128i_i64[0] = v5[2].m128i_i64[0];
*a1 = v6;
break;
case 3:
v3 = *a1;
if ( v3 )
operator delete(v3, 0x28uLL);
break;
}
return 0LL;
}
else
{
*a1 = (__m128i *)&`typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1};
return 0LL;
}
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x78
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
SUB RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
SAR RAX,0x5
PXOR XMM0,XMM0
MOV EDI,0x28
MOV dword ptr [RSP + 0x14],EAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
LAB_00103354:
CALL 0x001022a0
LEA RDX,[RSP + 0xc]
LEA R13,[RSP + 0x40]
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [RAX],RDX
LEA RDX,[RSP + 0x14]
LEA RBX,[RSP + 0x20]
MOV RDI,R13
MOV qword ptr [RAX + 0x10],RDX
LEA RCX,[0x1030d0]
LEA RSI,[RSP + 0x18]
MOV RDX,RBX
MOV qword ptr [RAX + 0x8],R12
MOVQ XMM0,RCX
LEA RCX,[RSP + 0x1c]
MOV qword ptr [RAX + 0x20],R13
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x1036f0]
MOVQ XMM1,RAX
MOV dword ptr [RSP + 0x18],0x0
PUNPCKLQDQ XMM0,XMM1
MOV dword ptr [RSP + 0x1c],0x0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x30],0x0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LAB_001033d8:
CALL 0x001036f0
MOV RBP,qword ptr [RSP + 0x28]
MOV RBX,qword ptr [RSP + 0x20]
CMP RBP,RBX
JZ 0x00103417
NOP dword ptr [RAX]
LAB_001033f0:
MOV RDI,qword ptr [RBX]
LEA RAX,[RBX + 0x10]
CMP RDI,RAX
JZ 0x00103409
MOV RAX,qword ptr [RBX + 0x10]
LEA RSI,[RAX + 0x1]
CALL 0x001022b0
LAB_00103409:
ADD RBX,0x20
CMP RBP,RBX
JNZ 0x001033f0
MOV RBX,qword ptr [RSP + 0x20]
LAB_00103417:
TEST RBX,RBX
JZ 0x0010342c
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,RBX
SUB RSI,RBX
CALL 0x001022b0
LAB_0010342c:
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x00103443
MOV EDX,0x3
MOV RSI,R13
MOV RDI,R13
CALL RAX
LAB_00103443:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00103461
ADD RSP,0x78
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00103461:
CALL 0x001022c0 | /* func0(std::vector<std::string, std::allocator<std::string > >, int) */
int (*) [16] func0(vector param_1,int param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
long *plVar4;
int8 *puVar5;
int4 in_register_00000034;
long *plVar6;
int4 in_register_0000003c;
int (*pauVar7) [16];
long in_FS_OFFSET;
int local_8c [8];
int4 local_84;
int local_80 [2];
int local_78 [16];
long local_68;
int local_58 [16];
code *local_48;
code *pcStack_40;
long local_30;
pauVar7 = (int (*) [16])CONCAT44(in_register_0000003c,param_1);
plVar6 = (long *)CONCAT44(in_register_00000034,param_2);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = plVar6[1];
local_48 = (code *)0x0;
pcStack_40 = (code *)0x0;
lVar2 = *plVar6;
*(int8 *)pauVar7[1] = 0;
*pauVar7 = (int [16])0x0;
local_84 = (int4)(lVar1 - lVar2 >> 5);
local_58 = (int [16])0x0;
/* try { // try from 00103354 to 00103358 has its CatchHandler @ 00103472 */
plVar4 = (long *)operator_new(0x28);
plVar4[3] = (long)plVar6;
*plVar4 = (long)local_8c;
plVar4[2] = (long)&local_84;
plVar4[1] = (long)pauVar7;
plVar4[4] = (long)local_58;
local_58._0_8_ = plVar4;
local_80[0] = 0;
local_80[1] = 0;
local_48 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_manager;
pcStack_40 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke;
local_68 = 0;
local_78 = (int [16])0x0;
/* try { // try from 001033d8 to 001033dc has its CatchHandler @ 00103466 */
std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke((_Any_data *)local_58,local_80,(vector *)local_78,local_80 + 1);
uVar3 = local_78._8_8_;
puVar5 = (int8 *)local_78._0_8_;
if (local_78._8_8_ != local_78._0_8_) {
do {
if ((int8 *)*puVar5 != puVar5 + 2) {
operator_delete((int8 *)*puVar5,puVar5[2] + 1);
}
puVar5 = puVar5 + 4;
} while ((int8 *)uVar3 != puVar5);
}
if ((int8 *)local_78._0_8_ != (int8 *)0x0) {
operator_delete((void *)local_78._0_8_,local_68 - local_78._0_8_);
}
if (local_48 != (code *)0x0) {
(*local_48)((_Any_data *)local_58,(_Any_data *)local_58,3);
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return pauVar7;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,019 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
#include <string>
#include <functional>
| std::vector<std::vector<std::string>> func0(std::vector<std::string> l, int n) {
int size = l.size();
std::vector<std::vector<std::string>> result;
// Helper function to generate combinations
std::function<void(int, std::vector<std::string>&, int)> generate =
[&](int index, std::vector<std::string>& current, int depth) {
if(depth == n) {
result.push_back(current);
return;
}
for(int i = index; i < size; i++) {
current.push_back(l[i]);
generate(i, current, depth + 1);
current.pop_back();
}
};
std::vector<std::string> current;
generate(0, current, 0);
return result;
}
| int main() {
std::vector<std::vector<std::string>> expected;
expected = {{"Red"}, {"Green"}, {"Blue"}};
assert(func0({"Red", "Green", "Blue"}, 1) == expected);
expected = {{"Red", "Red"}, {"Red", "Green"}, {"Red", "Blue"}, {"Green", "Green"}, {"Green", "Blue"}, {"Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 2) == expected);
expected = {{"Red", "Red", "Red"}, {"Red", "Red", "Green"}, {"Red", "Red", "Blue"}, {"Red", "Green", "Green"}, {"Red", "Green", "Blue"},
{"Red", "Blue", "Blue"}, {"Green", "Green", "Green"}, {"Green", "Green", "Blue"}, {"Green", "Blue", "Blue"}, {"Blue", "Blue", "Blue"}};
assert(func0({"Red", "Green", "Blue"}, 3) == expected);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O3 | cpp | std::_Function_base::_Base_manager<func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, int)::{lambda(int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >&, int)#1}>::_M_manager(std::_Any_data&, std::_Any_data const&, std::_Manager_operation):
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
cmp $0x2,%edx
je 28e0 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x50>
ja 28c0 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x30>
test %edx,%edx
je 2918 <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x88>
mov (%rsi),%rax
mov %rax,(%rdi)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
cmp $0x3,%edx
jne 28ae <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x1e>
mov (%rdi),%rdi
test %rdi,%rdi
je 28ae <_ZNSt14_Function_base13_Base_managerIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEiEUliRS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation+0x1e>
mov $0x28,%esi
callq 1280 <_ZdlPvm@plt>
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
mov (%rsi),%rbp
mov $0x28,%edi
callq 1270 <_Znwm@plt>
movdqu 0x0(%rbp),%xmm0
movups %xmm0,(%rax)
movdqu 0x10(%rbp),%xmm1
movups %xmm1,0x10(%rax)
mov 0x20(%rbp),%rdx
mov %rdx,0x20(%rax)
mov %rax,(%rbx)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopw 0x0(%rax,%rax,1)
lea 0x43c9(%rip),%rax
mov %rax,(%rdi)
add $0x8,%rsp
xor %eax,%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
| _ZNSt17_Function_handlerIFviRSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEiEZ5func0S8_iEUliS9_iE_E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
test edx, edx
jz short loc_3290
cmp edx, 1
jz short loc_3278
cmp edx, 2
jz short loc_32A8
cmp edx, 3
jnz short loc_327E
mov rdi, [rdi]; void *
test rdi, rdi
jz short loc_327E
mov esi, 28h ; '('; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_327E
loc_3278:
mov rax, [rsi]
mov [rdi], rax
loc_327E:
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_3290:
lea rax, _ZTIZ5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEiEUliRS7_iE_; `typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1}
mov [rdi], rax
add rsp, 8
xor eax, eax
pop rbx
pop rbp
retn
loc_32A8:
mov rbp, [rsi]
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
movdqu xmm0, xmmword ptr [rbp+0]
movups xmmword ptr [rax], xmm0
movdqu xmm1, xmmword ptr [rbp+10h]
movups xmmword ptr [rax+10h], xmm1
mov rdx, [rbp+20h]
mov [rax+20h], rdx
mov [rbx], rax
jmp short loc_327E | long long std::_Function_handler<void ()(int,std::vector<std::string> &,int),func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string> &,int)#1}>::_M_manager(
__m128i **a1,
const __m128i **a2,
int a3)
{
__m128i *v3; // rdi
const __m128i *v5; // rbp
__m128i *v6; // rax
if ( a3 )
{
switch ( a3 )
{
case 1:
*a1 = (__m128i *)*a2;
break;
case 2:
v5 = *a2;
v6 = (__m128i *)operator new(0x28uLL);
*v6 = _mm_loadu_si128(v5);
v6[1] = _mm_loadu_si128(v5 + 1);
v6[2].m128i_i64[0] = v5[2].m128i_i64[0];
*a1 = v6;
break;
case 3:
v3 = *a1;
if ( v3 )
operator delete(v3, 0x28uLL);
break;
}
return 0LL;
}
else
{
*a1 = (__m128i *)&`typeinfo for'func0(std::vector<std::string>,int)::{lambda(int,std::vector<std::string>&,int)#1};
return 0LL;
}
} | func0:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RSI
SUB RSP,0x78
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
SUB RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
SAR RAX,0x5
PXOR XMM0,XMM0
MOV EDI,0x28
MOV dword ptr [RSP + 0x14],EAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
LAB_00103414:
CALL 0x00102290
LEA RDX,[RSP + 0xc]
LEA R13,[RSP + 0x40]
MOV qword ptr [RAX + 0x18],RBX
MOV qword ptr [RAX],RDX
LEA RDX,[RSP + 0x14]
LEA RBX,[RSP + 0x20]
MOV RDI,R13
MOV qword ptr [RAX + 0x10],RDX
LEA RCX,[0x103240]
LEA RSI,[RSP + 0x18]
MOV RDX,RBX
MOV qword ptr [RAX + 0x8],R12
MOVQ XMM0,RCX
LEA RCX,[RSP + 0x1c]
MOV qword ptr [RAX + 0x20],R13
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[0x103b60]
MOVQ XMM1,RAX
MOV dword ptr [RSP + 0x18],0x0
PUNPCKLQDQ XMM0,XMM1
MOV dword ptr [RSP + 0x1c],0x0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x30],0x0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LAB_00103498:
CALL 0x00103b60
MOV RBP,qword ptr [RSP + 0x28]
MOV RBX,qword ptr [RSP + 0x20]
CMP RBP,RBX
JZ 0x001034d7
NOP dword ptr [RAX]
LAB_001034b0:
MOV RDI,qword ptr [RBX]
LEA RAX,[RBX + 0x10]
CMP RDI,RAX
JZ 0x00103528
MOV RAX,qword ptr [RBX + 0x10]
ADD RBX,0x20
LEA RSI,[RAX + 0x1]
CALL 0x001022a0
CMP RBP,RBX
JNZ 0x001034b0
LAB_001034d2:
MOV RBX,qword ptr [RSP + 0x20]
LAB_001034d7:
TEST RBX,RBX
JZ 0x001034ec
MOV RSI,qword ptr [RSP + 0x30]
MOV RDI,RBX
SUB RSI,RBX
CALL 0x001022a0
LAB_001034ec:
MOV RAX,qword ptr [RSP + 0x50]
TEST RAX,RAX
JZ 0x00103503
MOV EDX,0x3
MOV RSI,R13
MOV RDI,R13
CALL RAX
LAB_00103503:
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00103537
ADD RSP,0x78
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00103528:
ADD RBX,0x20
CMP RBP,RBX
JNZ 0x001034b0
JMP 0x001034d2
LAB_00103537:
CALL 0x001022b0 | /* func0(std::vector<std::string, std::allocator<std::string > >, int) */
int (*) [16] func0(vector param_1,int param_2)
{
long lVar1;
long lVar2;
int8 *puVar3;
int8 uVar4;
long *plVar5;
int8 *puVar6;
int4 in_register_00000034;
long *plVar7;
int4 in_register_0000003c;
int (*pauVar8) [16];
long in_FS_OFFSET;
int local_8c [8];
int4 local_84;
int local_80 [2];
int local_78 [16];
long local_68;
int local_58 [16];
code *local_48;
code *pcStack_40;
long local_30;
pauVar8 = (int (*) [16])CONCAT44(in_register_0000003c,param_1);
plVar7 = (long *)CONCAT44(in_register_00000034,param_2);
local_30 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = plVar7[1];
local_48 = (code *)0x0;
pcStack_40 = (code *)0x0;
lVar2 = *plVar7;
*(int8 *)pauVar8[1] = 0;
*pauVar8 = (int [16])0x0;
local_84 = (int4)(lVar1 - lVar2 >> 5);
local_58 = (int [16])0x0;
/* try { // try from 00103414 to 00103418 has its CatchHandler @ 00103548 */
plVar5 = (long *)operator_new(0x28);
plVar5[3] = (long)plVar7;
*plVar5 = (long)local_8c;
plVar5[2] = (long)&local_84;
plVar5[1] = (long)pauVar8;
plVar5[4] = (long)local_58;
local_58._0_8_ = plVar5;
local_80[0] = 0;
local_80[1] = 0;
local_48 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_manager;
pcStack_40 = std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke;
local_68 = 0;
local_78 = (int [16])0x0;
/* try { // try from 00103498 to 0010349c has its CatchHandler @ 0010353c */
std::
_Function_handler<void(int,std::vector<std::string,std::allocator<std::string>>&,int),func0(std::vector<std::string,std::allocator<std::string>>,int)::{lambda(int,std::vector<std::string,std::allocator<std::string>>&,int)#1}>
::_M_invoke((_Any_data *)local_58,local_80,(vector *)local_78,local_80 + 1);
uVar4 = local_78._8_8_;
puVar6 = (int8 *)local_78._0_8_;
if (local_78._8_8_ != local_78._0_8_) {
do {
while (puVar3 = (int8 *)*puVar6, puVar3 == puVar6 + 2) {
puVar6 = puVar6 + 4;
if ((int8 *)uVar4 == puVar6) goto LAB_001034d2;
}
plVar5 = puVar6 + 2;
puVar6 = puVar6 + 4;
operator_delete(puVar3,*plVar5 + 1);
} while ((int8 *)uVar4 != puVar6);
LAB_001034d2:
}
if ((int8 *)local_78._0_8_ != (int8 *)0x0) {
operator_delete((void *)local_78._0_8_,local_68 - local_78._0_8_);
}
if (local_48 != (code *)0x0) {
(*local_48)((_Any_data *)local_58,(_Any_data *)local_58,3);
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return pauVar8;
} |
1,020 | func0 |
#include <assert.h>
| int func0(int n) {
int ctr = 0;
for (int num = 2; num < n; num++) {
bool isPrime = true;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0(5) == 2);
assert(func0(10) == 4);
assert(func0(100) == 25);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x2,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 11a9 <_Z5func0i+0x60>
movb $0x1,-0xd(%rbp)
movl $0x2,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x8(%rbp)
jl 1199 <_Z5func0i+0x50>
mov -0x8(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1193 <_Z5func0i+0x4a>
movb $0x0,-0xd(%rbp)
jmp 1199 <_Z5func0i+0x50>
addl $0x1,-0x4(%rbp)
jmp 1175 <_Z5func0i+0x2c>
cmpb $0x0,-0xd(%rbp)
je 11a3 <_Z5func0i+0x5a>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
jmp 1162 <_Z5func0i+0x19>
mov -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], 2
jmp short loc_11A1
loc_1164:
mov [rbp+var_D], 1
mov [rbp+var_4], 2
jmp short loc_1188
loc_1171:
mov eax, [rbp+var_8]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1184
mov [rbp+var_D], 0
jmp short loc_1193
loc_1184:
add [rbp+var_4], 1
loc_1188:
mov eax, [rbp+var_4]
imul eax, eax
cmp [rbp+var_8], eax
jge short loc_1171
loc_1193:
cmp [rbp+var_D], 0
jz short loc_119D
add [rbp+var_C], 1
loc_119D:
add [rbp+var_8], 1
loc_11A1:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_14]
jl short loc_1164
mov eax, [rbp+var_C]
pop rbp
retn | long long func0(int a1)
{
char v2; // [rsp+7h] [rbp-Dh]
unsigned int v3; // [rsp+8h] [rbp-Ch]
int i; // [rsp+Ch] [rbp-8h]
int j; // [rsp+10h] [rbp-4h]
v3 = 0;
for ( i = 2; i < a1; ++i )
{
v2 = 1;
for ( j = 2; i >= j * j; ++j )
{
if ( !(i % j) )
{
v2 = 0;
break;
}
}
if ( v2 )
++v3;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x2
JMP 0x001011a1
LAB_00101164:
MOV byte ptr [RBP + -0xd],0x1
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101188
LAB_00101171:
MOV EAX,dword ptr [RBP + -0x8]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101184
MOV byte ptr [RBP + -0xd],0x0
JMP 0x00101193
LAB_00101184:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x8],EAX
JGE 0x00101171
LAB_00101193:
CMP byte ptr [RBP + -0xd],0x0
JZ 0x0010119d
ADD dword ptr [RBP + -0xc],0x1
LAB_0010119d:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011a1:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101164
MOV EAX,dword ptr [RBP + -0xc]
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
bool bVar1;
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 2;
do {
if (param_1 <= local_10) {
return local_14;
}
bVar1 = true;
for (local_c = 2; local_c * local_c <= local_10; local_c = local_c + 1) {
if (local_10 % local_c == 0) {
bVar1 = false;
break;
}
}
if (bVar1) {
local_14 = local_14 + 1;
}
local_10 = local_10 + 1;
} while( true );
} |
1,021 | func0 |
#include <assert.h>
| int func0(int n) {
int ctr = 0;
for (int num = 2; num < n; num++) {
bool isPrime = true;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0(5) == 2);
assert(func0(10) == 4);
assert(func0(100) == 25);
return 0;
}
| O1 | cpp | func0(int):
endbr64
cmp $0x2,%edi
jle 115f <_Z5func0i+0x16>
mov $0x2,%esi
mov $0x0,%r8d
jmp 1174 <_Z5func0i+0x2b>
mov $0x0,%r8d
mov %r8d,%eax
retq
add $0x1,%r8d
add $0x1,%esi
cmp %esi,%edi
je 1165 <_Z5func0i+0x1c>
cmp $0x3,%esi
jle 1169 <_Z5func0i+0x20>
test $0x1,%sil
je 116d <_Z5func0i+0x24>
mov $0x2,%ecx
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jg 1169 <_Z5func0i+0x20>
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1184 <_Z5func0i+0x3b>
jmp 116d <_Z5func0i+0x24>
| _Z5func0i:
endbr64
mov esi, 2
mov r8d, 0
cmp edi, 2
jg short loc_116C
loc_115D:
mov eax, r8d
retn
loc_1161:
add r8d, 1
loc_1165:
add esi, 1
cmp edi, esi
jz short loc_115D
loc_116C:
cmp esi, 3
jle short loc_1161
test sil, 1
jz short loc_1165
mov ecx, 2
loc_117C:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jg short loc_1161
mov eax, esi
cdq
idiv ecx
test edx, edx
jnz short loc_117C
jmp short loc_1165 | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // r8d
int v4; // ecx
v1 = 2;
v2 = 0;
if ( a1 > 2 )
{
do
{
if ( v1 > 3 )
{
if ( (v1 & 1) == 0 )
goto LABEL_4;
v4 = 2;
while ( 1 )
{
++v4;
if ( v4 * v4 > v1 )
break;
if ( !(v1 % v4) )
goto LABEL_4;
}
}
++v2;
LABEL_4:
++v1;
}
while ( a1 != v1 );
}
return v2;
} | func0:
ENDBR64
MOV ESI,0x2
MOV R8D,0x0
CMP EDI,0x2
JG 0x0010116c
LAB_0010115d:
MOV EAX,R8D
RET
LAB_00101161:
ADD R8D,0x1
LAB_00101165:
ADD ESI,0x1
CMP EDI,ESI
JZ 0x0010115d
LAB_0010116c:
CMP ESI,0x3
JLE 0x00101161
TEST SIL,0x1
JZ 0x00101165
MOV ECX,0x2
LAB_0010117c:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JG 0x00101161
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x0010117c
JMP 0x00101165 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
uint uVar2;
int iVar3;
uVar2 = 2;
iVar3 = 0;
if (2 < param_1) {
do {
if ((int)uVar2 < 4) {
LAB_00101161:
iVar3 = iVar3 + 1;
}
else if ((uVar2 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)uVar2 < iVar1 * iVar1) goto LAB_00101161;
} while ((int)uVar2 % iVar1 != 0);
}
uVar2 = uVar2 + 1;
} while (param_1 != uVar2);
}
return iVar3;
} |
1,022 | func0 |
#include <assert.h>
| int func0(int n) {
int ctr = 0;
for (int num = 2; num < n; num++) {
bool isPrime = true;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0(5) == 2);
assert(func0(10) == 4);
assert(func0(100) == 25);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x2,%edi
jle 1274 <_Z5func0i+0x54>
mov $0x2,%esi
xor %r8d,%r8d
nopl 0x0(%rax)
cmp $0x3,%esi
jle 1265 <_Z5func0i+0x45>
test $0x1,%sil
je 1269 <_Z5func0i+0x49>
mov $0x2,%ecx
jmp 1259 <_Z5func0i+0x39>
nopw 0x0(%rax,%rax,1)
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1269 <_Z5func0i+0x49>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %esi,%eax
jle 1250 <_Z5func0i+0x30>
add $0x1,%r8d
add $0x1,%esi
cmp %esi,%edi
jne 1238 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
mov esi, 2
xor r8d, r8d
cmp edi, 2
jle short loc_1240
nop dword ptr [rax+00000000h]
loc_1208:
cmp esi, 3
jle short loc_1235
test sil, 1
jz short loc_1239
mov ecx, 2
jmp short loc_1229
loc_1220:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1239
loc_1229:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp eax, esi
jle short loc_1220
loc_1235:
add r8d, 1
loc_1239:
add esi, 1
cmp edi, esi
jnz short loc_1208
loc_1240:
mov eax, r8d
retn | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // r8d
int v3; // ecx
v1 = 2;
v2 = 0;
if ( a1 > 2 )
{
while ( 1 )
{
if ( v1 <= 3 )
goto LABEL_7;
if ( (v1 & 1) != 0 )
break;
LABEL_8:
if ( a1 == ++v1 )
return v2;
}
v3 = 2;
while ( 1 )
{
++v3;
if ( v3 * v3 > v1 )
break;
if ( !(v1 % v3) )
goto LABEL_8;
}
LABEL_7:
++v2;
goto LABEL_8;
}
return v2;
} | func0:
ENDBR64
MOV ESI,0x2
XOR R8D,R8D
CMP EDI,0x2
JLE 0x00101240
NOP dword ptr [RAX]
LAB_00101208:
CMP ESI,0x3
JLE 0x00101235
TEST SIL,0x1
JZ 0x00101239
MOV ECX,0x2
JMP 0x00101229
LAB_00101220:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101239
LAB_00101229:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP EAX,ESI
JLE 0x00101220
LAB_00101235:
ADD R8D,0x1
LAB_00101239:
ADD ESI,0x1
CMP EDI,ESI
JNZ 0x00101208
LAB_00101240:
MOV EAX,R8D
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
uint uVar2;
int iVar3;
uVar2 = 2;
iVar3 = 0;
if (2 < param_1) {
do {
if ((int)uVar2 < 4) {
LAB_00101235:
iVar3 = iVar3 + 1;
}
else if ((uVar2 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)uVar2 < iVar1 * iVar1) goto LAB_00101235;
} while ((int)uVar2 % iVar1 != 0);
}
uVar2 = uVar2 + 1;
} while (param_1 != uVar2);
}
return iVar3;
} |
1,023 | func0 |
#include <assert.h>
| int func0(int n) {
int ctr = 0;
for (int num = 2; num < n; num++) {
bool isPrime = true;
for (int i = 2; i * i <= num; i++) {
if (num % i == 0) {
isPrime = false;
break;
}
}
if (isPrime) {
ctr++;
}
}
return ctr;
}
| int main() {
assert(func0(5) == 2);
assert(func0(10) == 4);
assert(func0(100) == 25);
return 0;
}
| O3 | cpp | func0(int):
endbr64
cmp $0x2,%edi
jle 1284 <_Z5func0i+0x64>
cmp $0x3,%edi
setg %sil
setg %r8b
movzbl %sil,%esi
movzbl %r8b,%r8d
add $0x3,%esi
add $0x1,%r8d
cmp %esi,%edi
jle 1280 <_Z5func0i+0x60>
nopw 0x0(%rax,%rax,1)
test $0x1,%sil
je 1279 <_Z5func0i+0x59>
mov $0x2,%ecx
jmp 1269 <_Z5func0i+0x49>
nopl (%rax)
mov %esi,%eax
cltd
idiv %ecx
test %edx,%edx
je 1279 <_Z5func0i+0x59>
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %eax,%esi
jge 1260 <_Z5func0i+0x40>
add $0x1,%r8d
add $0x1,%esi
cmp %esi,%edi
jne 1250 <_Z5func0i+0x30>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
xor r8d, r8d
cmp edi, 2
jle short loc_1230
cmp edi, 3
setnz sil
setnz r8b
movzx esi, sil
movzx r8d, r8b
add esi, 3
add r8d, 1
cmp edi, esi
jle short loc_1230
loc_11FA:
test sil, 1
jz short loc_1229
mov ecx, 2
jmp short loc_1219
loc_1210:
mov eax, esi
cdq
idiv ecx
test edx, edx
jz short loc_1229
loc_1219:
add ecx, 1
mov eax, ecx
imul eax, ecx
cmp esi, eax
jge short loc_1210
add r8d, 1
loc_1229:
add esi, 1
cmp edi, esi
jnz short loc_11FA
loc_1230:
mov eax, r8d
retn | long long func0(int a1)
{
unsigned int v1; // r8d
_BOOL4 v2; // r8d
int v3; // esi
int v4; // ecx
v1 = 0;
if ( a1 > 2 )
{
v2 = a1 != 3;
v3 = v2 + 3;
v1 = v2 + 1;
if ( a1 > v3 )
{
do
{
if ( (v3 & 1) != 0 )
{
v4 = 2;
while ( 1 )
{
++v4;
if ( v3 < v4 * v4 )
break;
if ( !(v3 % v4) )
goto LABEL_8;
}
++v1;
}
LABEL_8:
++v3;
}
while ( a1 != v3 );
}
}
return v1;
} | func0:
ENDBR64
XOR R8D,R8D
CMP EDI,0x2
JLE 0x00101230
CMP EDI,0x3
SETNZ SIL
SETNZ R8B
MOVZX ESI,SIL
MOVZX R8D,R8B
ADD ESI,0x3
ADD R8D,0x1
CMP EDI,ESI
JLE 0x00101230
LAB_001011fa:
TEST SIL,0x1
JZ 0x00101229
MOV ECX,0x2
JMP 0x00101219
LAB_00101210:
MOV EAX,ESI
CDQ
IDIV ECX
TEST EDX,EDX
JZ 0x00101229
LAB_00101219:
ADD ECX,0x1
MOV EAX,ECX
IMUL EAX,ECX
CMP ESI,EAX
JGE 0x00101210
ADD R8D,0x1
LAB_00101229:
ADD ESI,0x1
CMP EDI,ESI
JNZ 0x001011fa
LAB_00101230:
MOV EAX,R8D
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
uint uVar2;
int iVar3;
iVar3 = 0;
if (2 < param_1) {
uVar2 = (param_1 != 3) + 3;
iVar3 = (param_1 != 3) + 1;
if ((int)uVar2 < param_1) {
do {
if ((uVar2 & 1) != 0) {
iVar1 = 2;
do {
iVar1 = iVar1 + 1;
if ((int)uVar2 < iVar1 * iVar1) {
iVar3 = iVar3 + 1;
break;
}
} while ((int)uVar2 % iVar1 != 0);
}
uVar2 = uVar2 + 1;
} while (param_1 != uVar2);
}
}
return iVar3;
} |
1,024 | func0 |
#include <assert.h>
#include <utility>
| std::pair<int, int> func0(int a, int b) {
int temp = a;
a = b;
b = temp;
return std::make_pair(a, b);
}
| int main() {
assert(func0(10, 20) == std::make_pair(20, 10));
assert(func0(15, 17) == std::make_pair(17, 15));
assert(func0(100, 200) == std::make_pair(200, 100));
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0x18(%rbp)
lea -0x18(%rbp),%rdx
lea -0x14(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1368 <_ZSt9make_pairIRiS0_ESt4pairINSt17__decay_and_stripIT_E6__typeENS2_IT0_E6__typeEEOS3_OS6_>
leaveq
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
mov [rbp+var_18], eax
lea rdx, [rbp+var_18]
lea rax, [rbp+var_14]
mov rsi, rdx
mov rdi, rax
call _ZSt9make_pairIRiS0_ESt4pairINSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeENS2_INS3_IT0_E4typeEE6__typeEEOS4_OS9_; std::make_pair<int &,int &>(int &&&,int &&&)
leave
retn | long long func0(int a1, int a2)
{
int v3; // [rsp+8h] [rbp-18h] BYREF
_DWORD v4[5]; // [rsp+Ch] [rbp-14h] BYREF
v4[4] = a1;
v4[0] = a2;
v3 = a1;
return std::make_pair<int &,int &>(v4, &v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x18],EAX
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x14]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010133d
LEAVE
RET | /* func0(int, int) */
void func0(int param_1,int param_2)
{
int local_20;
int local_1c [4];
int local_c;
local_20 = param_1;
local_1c[0] = param_2;
local_c = param_1;
std::make_pair<int&,int&>(local_1c,&local_20);
return;
} |
1,025 | func0 |
#include <assert.h>
#include <utility>
| std::pair<int, int> func0(int a, int b) {
int temp = a;
a = b;
b = temp;
return std::make_pair(a, b);
}
| int main() {
assert(func0(10, 20) == std::make_pair(20, 10));
assert(func0(15, 17) == std::make_pair(17, 15));
assert(func0(100, 200) == std::make_pair(200, 100));
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
shl $0x20,%rdi
mov %esi,%eax
or %rdi,%rax
retq
| _Z5func0ii:
endbr64
shl rdi, 20h
mov eax, esi
or rax, rdi
retn | long long func0(long long a1, unsigned int a2)
{
return (a1 << 32) | a2;
} | func0:
ENDBR64
SHL RDI,0x20
MOV EAX,ESI
OR RAX,RDI
RET | /* func0(int, int) */
int8 func0(int param_1,int param_2)
{
return CONCAT44(param_1,param_2);
} |
1,026 | func0 |
#include <assert.h>
#include <utility>
| std::pair<int, int> func0(int a, int b) {
int temp = a;
a = b;
b = temp;
return std::make_pair(a, b);
}
| int main() {
assert(func0(10, 20) == std::make_pair(20, 10));
assert(func0(15, 17) == std::make_pair(17, 15));
assert(func0(100, 200) == std::make_pair(200, 100));
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
shl $0x20,%rdi
mov %esi,%eax
or %rdi,%rax
retq
xchg %ax,%ax
| _Z5func0ii:
endbr64
shl rdi, 20h
mov eax, esi
or rax, rdi
retn | long long func0(long long a1, unsigned int a2)
{
return (a1 << 32) | a2;
} | func0:
ENDBR64
SHL RDI,0x20
MOV EAX,ESI
OR RAX,RDI
RET | /* func0(int, int) */
int8 func0(int param_1,int param_2)
{
return CONCAT44(param_1,param_2);
} |
1,027 | func0 |
#include <assert.h>
#include <utility>
| std::pair<int, int> func0(int a, int b) {
int temp = a;
a = b;
b = temp;
return std::make_pair(a, b);
}
| int main() {
assert(func0(10, 20) == std::make_pair(20, 10));
assert(func0(15, 17) == std::make_pair(17, 15));
assert(func0(100, 200) == std::make_pair(200, 100));
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
shl $0x20,%rdi
mov %esi,%eax
or %rdi,%rax
retq
xchg %ax,%ax
| _Z5func0ii:
endbr64
shl rdi, 20h
mov eax, esi
or rax, rdi
retn | long long func0(long long a1, unsigned int a2)
{
return (a1 << 32) | a2;
} | func0:
ENDBR64
SHL RDI,0x20
MOV EAX,ESI
OR RAX,RDI
RET | /* func0(int, int) */
int8 func0(int param_1,int param_2)
{
return CONCAT44(param_1,param_2);
} |
1,028 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 != 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 10}) == 4);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 2);
assert(func0({1, 2, 4, 8, 9}) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 15c8 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x20(%rbp)
mov -0x10(%rbp),%rax
mov %rax,%rdi
callq 1620 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x18(%rbp)
lea -0x18(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1678 <_ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_>
test %al,%al
je 12bb <_Z5func0RKSt6vectorIiSaIiEE+0x92>
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 16dc <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x24(%rbp)
mov -0x24(%rbp),%eax
and $0x1,%eax
test %eax,%eax
je 12ad <_Z5func0RKSt6vectorIiSaIiEE+0x84>
addl $0x1,-0x28(%rbp)
lea -0x20(%rbp),%rax
mov %rax,%rdi
callq 16b8 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv>
jmp 1277 <_Z5func0RKSt6vectorIiSaIiEE+0x4e>
mov -0x28(%rbp),%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 12d2 <_Z5func0RKSt6vectorIiSaIiEE+0xa9>
callq 1110 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_28], 0
mov rax, [rbp+var_38]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_18], rax
jmp short loc_12C4
loc_1299:
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 eax, [rbp+var_24]
and eax, 1
test eax, eax
jz short loc_12B8
add [rbp+var_28], 1
loc_12B8:
lea rax, [rbp+var_20]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(void)
loc_12C4:
lea rdx, [rbp+var_18]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESB_; __gnu_cxx::operator!=<int const*,std::vector<int>>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int const*,std::vector<int>> const&)
test al, al
jnz short loc_1299
mov eax, [rbp+var_28]
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12F2
call ___stack_chk_fail
locret_12F2:
leave
retn | long long func0(long long a1)
{
unsigned int v2; // [rsp+18h] [rbp-28h]
long long v3; // [rsp+20h] [rbp-20h] BYREF
_QWORD v4[3]; // [rsp+28h] [rbp-18h] BYREF
v4[2] = __readfsqword(0x28u);
v2 = 0;
v4[1] = a1;
v3 = std::vector<int>::begin(a1);
v4[0] = std::vector<int>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<int const*,std::vector<int>>(&v3, v4) )
{
if ( (*(_DWORD *)__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator*(&v3) & 1) != 0 )
++v2;
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator++(&v3);
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x0010162e
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,RAX
CALL 0x0010167a
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012c4
LAB_00101299:
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x0010172e
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0x1
TEST EAX,EAX
JZ 0x001012b8
ADD dword ptr [RBP + -0x28],0x1
LAB_001012b8:
LEA RAX,[RBP + -0x20]
MOV RDI,RAX
CALL 0x0010170a
LAB_001012c4:
LEA RDX,[RBP + -0x18]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001016ca
TEST AL,AL
JNZ 0x00101299
MOV EAX,dword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012f2
CALL 0x00101130
LAB_001012f2:
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
bool bVar1;
uint *puVar2;
long in_FS_OFFSET;
int local_30;
int8 local_28;
int8 local_20;
vector<int,std::allocator<int>> *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_30 = 0;
local_18 = (vector<int,std::allocator<int>> *)param_1;
local_28 = std::vector<int,std::allocator<int>>::begin((vector<int,std::allocator<int>> *)param_1)
;
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;
puVar2 = (uint *)__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>
*)&local_28);
if ((*puVar2 & 1) != 0) {
local_30 = local_30 + 1;
}
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int_const*,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;
} |
1,029 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 != 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 10}) == 4);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 2);
assert(func0({1, 2, 4, 8, 9}) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rsi
cmp %rsi,%rax
je 1235 <_Z5func0RKSt6vectorIiSaIiEE+0x2c>
mov $0x0,%ecx
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%ecx
add $0x4,%rax
cmp %rax,%rsi
jne 121e <_Z5func0RKSt6vectorIiSaIiEE+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1232 <_Z5func0RKSt6vectorIiSaIiEE+0x29>
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rsi, [rdi+8]
cmp rsi, rax
jz short loc_1235
mov ecx, 0
loc_121E:
mov edx, [rax]
and edx, 1
cmp edx, 1
sbb ecx, 0FFFFFFFFh
add rax, 4
cmp rax, rsi
jnz short loc_121E
loc_1232:
mov eax, ecx
retn
loc_1235:
mov ecx, 0
jmp short loc_1232 | long long func0(long long a1)
{
_DWORD *v1; // rax
_DWORD *v2; // rsi
unsigned int v3; // ecx
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
if ( v2 == *(_DWORD **)a1 )
{
return 0;
}
else
{
v3 = 0;
do
v3 -= ((*v1++ & 1) == 0) - 1;
while ( v1 != v2 );
}
return v3;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
CMP RSI,RAX
JZ 0x00101235
MOV ECX,0x0
LAB_0010121e:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
SBB ECX,-0x1
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010121e
LAB_00101232:
MOV EAX,ECX
RET
LAB_00101235:
MOV ECX,0x0
JMP 0x00101232 | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
int iVar2;
puVar1 = *(uint **)param_1;
if (*(uint **)(param_1 + 8) == puVar1) {
iVar2 = 0;
}
else {
iVar2 = 0;
do {
iVar2 = (iVar2 + 1) - (uint)((*puVar1 & 1) == 0);
puVar1 = puVar1 + 1;
} while (puVar1 != *(uint **)(param_1 + 8));
}
return iVar2;
} |
1,030 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 != 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 10}) == 4);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 2);
assert(func0({1, 2, 4, 8, 9}) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
cmp %rcx,%rax
je 147d <_Z5func0RKSt6vectorIiSaIiEE+0x2d>
nopl 0x0(%rax,%rax,1)
mov (%rax),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%r8d
add $0x4,%rax
cmp %rax,%rcx
jne 1468 <_Z5func0RKSt6vectorIiSaIiEE+0x18>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rax, [rdi]
mov rsi, [rdi+8]
xor ecx, ecx
cmp rsi, rax
jz short loc_142C
nop word ptr [rax+rax+00h]
loc_1418:
mov edx, [rax]
and edx, 1
cmp edx, 1
sbb ecx, 0FFFFFFFFh
add rax, 4
cmp rsi, rax
jnz short loc_1418
loc_142C:
mov eax, ecx
retn | long long func0(long long a1)
{
_DWORD *v1; // rax
_DWORD *v2; // rsi
unsigned int v3; // ecx
v1 = *(_DWORD **)a1;
v2 = *(_DWORD **)(a1 + 8);
v3 = 0;
if ( v2 != *(_DWORD **)a1 )
{
do
v3 -= ((*v1++ & 1) == 0) - 1;
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
XOR ECX,ECX
CMP RSI,RAX
JZ 0x0010142c
NOP word ptr [RAX + RAX*0x1]
LAB_00101418:
MOV EDX,dword ptr [RAX]
AND EDX,0x1
CMP EDX,0x1
SBB ECX,-0x1
ADD RAX,0x4
CMP RSI,RAX
JNZ 0x00101418
LAB_0010142c:
MOV EAX,ECX
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
int iVar2;
iVar2 = 0;
for (puVar1 = *(uint **)param_1; *(uint **)(param_1 + 8) != puVar1; puVar1 = puVar1 + 1) {
iVar2 = (iVar2 + 1) - (uint)((*puVar1 & 1) == 0);
}
return iVar2;
} |
1,031 | func0 |
#include <vector>
#include <cassert>
| int func0(const std::vector<int>& array_nums) {
int count = 0;
for (int num : array_nums) {
if (num % 2 != 0) {
count++;
}
}
return count;
}
| int main() {
assert(func0({1, 2, 3, 5, 7, 8, 10}) == 4);
assert(func0({10, 15, 14, 13, -18, 12, -20}) == 2);
assert(func0({1, 2, 4, 8, 9}) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%rsi
cmp %rsi,%rdx
je 1790 <_Z5func0RKSt6vectorIiSaIiEE+0x100>
lea -0x4(%rsi),%rcx
mov %rdx,%rax
movabs $0x3ffffffffffffffc,%r8
sub %rdx,%rcx
shr $0x2,%rcx
lea 0x1(%rcx),%rdi
test %r8,%rcx
je 1799 <_Z5func0RKSt6vectorIiSaIiEE+0x109>
mov %rdi,%rcx
pxor %xmm1,%xmm1
movdqa 0xa28(%rip),%xmm4
pcmpeqd %xmm2,%xmm2
shr $0x2,%rcx
movdqa %xmm1,%xmm3
shl $0x4,%rcx
add %rdx,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
add $0x10,%rax
pand %xmm4,%xmm0
pcmpeqd %xmm3,%xmm0
pandn %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rcx,%rax
jne 16f0 <_Z5func0RKSt6vectorIiSaIiEE+0x60>
movdqa %xmm1,%xmm0
mov %rdi,%rcx
psrldq $0x8,%xmm0
and $0xfffffffffffffffc,%rcx
paddd %xmm0,%xmm1
lea (%rdx,%rcx,4),%rdx
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
cmp %rcx,%rdi
je 1798 <_Z5func0RKSt6vectorIiSaIiEE+0x108>
mov (%rdx),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
lea 0x4(%rdx),%rcx
sbb $0xffffffff,%eax
cmp %rcx,%rsi
je 1792 <_Z5func0RKSt6vectorIiSaIiEE+0x102>
mov 0x4(%rdx),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
lea 0x8(%rdx),%rcx
sbb $0xffffffff,%eax
cmp %rcx,%rsi
je 1792 <_Z5func0RKSt6vectorIiSaIiEE+0x102>
mov 0x8(%rdx),%ecx
and $0x1,%ecx
cmp $0x1,%ecx
lea 0xc(%rdx),%rcx
sbb $0xffffffff,%eax
cmp %rcx,%rsi
je 1792 <_Z5func0RKSt6vectorIiSaIiEE+0x102>
mov 0xc(%rdx),%edx
and $0x1,%edx
cmp $0x1,%edx
sbb $0xffffffff,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %eax,%eax
jmp 173b <_Z5func0RKSt6vectorIiSaIiEE+0xab>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
mov rdx, [rdi]
mov rdi, [rdi+8]
cmp rdi, rdx
jz loc_16F0
lea rcx, [rdi-4]
mov rax, rdx
sub rcx, rdx
mov rsi, rcx
shr rsi, 2
add rsi, 1
cmp rcx, 8
jbe loc_16F9
mov rcx, rsi
pxor xmm1, xmm1
movdqa xmm3, cs:xmmword_20F0
shr rcx, 2
movdqa xmm2, xmm1
shl rcx, 4
add rcx, rdx
nop dword ptr [rax+00000000h]
loc_1668:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pand xmm0, xmm3
pcmpeqd xmm0, xmm2
pcmpeqd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rcx
jnz short loc_1668
movdqa xmm0, xmm1
mov rcx, rsi
psrldq xmm0, 8
and rcx, 0FFFFFFFFFFFFFFFCh
and esi, 3
paddd xmm1, xmm0
lea rdx, [rdx+rcx*4]
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
jz short locret_16F8
loc_16B3:
mov ecx, [rdx]
and ecx, 1
cmp ecx, 1
lea rcx, [rdx+4]
sbb eax, 0FFFFFFFFh
cmp rdi, rcx
jz short locret_16F2
mov ecx, [rdx+4]
and ecx, 1
cmp ecx, 1
lea rcx, [rdx+8]
sbb eax, 0FFFFFFFFh
cmp rdi, rcx
jz short locret_16F2
mov edx, [rdx+8]
and edx, 1
cmp edx, 1
sbb eax, 0FFFFFFFFh
retn
loc_16F0:
xor eax, eax
locret_16F2:
retn
locret_16F8:
retn
loc_16F9:
xor eax, eax
jmp short loc_16B3 | long long func0(const __m128i **a1)
{
const __m128i *v1; // rdx
const __m128i *v2; // rdi
const __m128i *v3; // rax
unsigned long long v4; // rsi
__m128i v5; // xmm1
__m128i si128; // xmm3
__m128i v7; // xmm0
__m128i v8; // xmm1
long long result; // rax
v1 = *a1;
v2 = a1[1];
if ( v2 == v1 )
return 0LL;
v3 = v1;
v4 = ((unsigned long long)((char *)&v2[-1].m128i_u64[1] + 4 - (char *)v1) >> 2) + 1;
if ( (unsigned long long)((char *)&v2[-1].m128i_u64[1] + 4 - (char *)v1) <= 8 )
{
LODWORD(result) = 0;
}
else
{
v5 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_20F0);
do
{
v7 = _mm_loadu_si128(v3++);
v5 = _mm_sub_epi32(v5, _mm_cmpeq_epi32(_mm_cmpeq_epi32(_mm_and_si128(v7, si128), (__m128i)0LL), (__m128i)0LL));
}
while ( v3 != &v1[v4 >> 2] );
v8 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
v1 = (const __m128i *)((char *)v1 + 4 * (v4 & 0xFFFFFFFFFFFFFFFCLL));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v8, _mm_srli_si128(v8, 4)));
if ( (v4 & 3) == 0 )
return result;
}
result = (unsigned int)result - (((v1->m128i_i32[0] & 1) == 0) - 1);
if ( v2 != (const __m128i *)((char *)v1->m128i_i64 + 4) )
{
result = (unsigned int)result - (((v1->m128i_i32[1] & 1) == 0) - 1);
if ( v2 != (const __m128i *)&v1->m128i_u64[1] )
return (unsigned int)result - (((v1->m128i_i32[2] & 1) == 0) - 1);
}
return result;
} | func0:
ENDBR64
MOV RDX,qword ptr [RDI]
MOV RDI,qword ptr [RDI + 0x8]
CMP RDI,RDX
JZ 0x001016f0
LEA RCX,[RDI + -0x4]
MOV RAX,RDX
SUB RCX,RDX
MOV RSI,RCX
SHR RSI,0x2
ADD RSI,0x1
CMP RCX,0x8
JBE 0x001016f9
MOV RCX,RSI
PXOR XMM1,XMM1
MOVDQA XMM3,xmmword ptr [0x001020f0]
SHR RCX,0x2
MOVDQA XMM2,XMM1
SHL RCX,0x4
ADD RCX,RDX
NOP dword ptr [RAX]
LAB_00101668:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,XMM3
PCMPEQD XMM0,XMM2
PCMPEQD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RCX
JNZ 0x00101668
MOVDQA XMM0,XMM1
MOV RCX,RSI
PSRLDQ XMM0,0x8
AND RCX,-0x4
AND ESI,0x3
PADDD XMM1,XMM0
LEA RDX,[RDX + RCX*0x4]
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
JZ 0x001016f8
LAB_001016b3:
MOV ECX,dword ptr [RDX]
AND ECX,0x1
CMP ECX,0x1
LEA RCX,[RDX + 0x4]
SBB EAX,-0x1
CMP RDI,RCX
JZ 0x001016f2
MOV ECX,dword ptr [RDX + 0x4]
AND ECX,0x1
CMP ECX,0x1
LEA RCX,[RDX + 0x8]
SBB EAX,-0x1
CMP RDI,RCX
JZ 0x001016f2
MOV EDX,dword ptr [RDX + 0x8]
AND EDX,0x1
CMP EDX,0x1
SBB EAX,-0x1
RET
LAB_001016f0:
XOR EAX,EAX
LAB_001016f2:
RET
LAB_001016f8:
RET
LAB_001016f9:
XOR EAX,EAX
JMP 0x001016b3 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> > const&) */
int func0(vector *param_1)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
ulong uVar7;
uint *puVar8;
ulong uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
puVar8 = *(uint **)param_1;
puVar1 = *(uint **)(param_1 + 8);
if (puVar1 == puVar8) {
iVar10 = 0;
}
else {
uVar7 = (long)puVar1 + (-4 - (long)puVar8);
uVar9 = (uVar7 >> 2) + 1;
if (uVar7 < 9) {
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
puVar6 = puVar8;
do {
uVar2 = *puVar6;
puVar3 = puVar6 + 1;
puVar4 = puVar6 + 2;
puVar5 = puVar6 + 3;
puVar6 = puVar6 + 4;
iVar10 = iVar10 + (uint)((uVar2 & _DAT_001020f0) != 0);
iVar11 = iVar11 + (uint)((*puVar3 & _UNK_001020f4) != 0);
iVar12 = iVar12 + (uint)((*puVar4 & _UNK_001020f8) != 0);
iVar13 = iVar13 + (uint)((*puVar5 & _UNK_001020fc) != 0);
} while (puVar6 != puVar8 + (uVar9 & 0xfffffffffffffffc));
puVar8 = puVar8 + (uVar9 & 0xfffffffffffffffc);
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((uVar9 & 3) == 0) {
return iVar10;
}
}
iVar10 = (iVar10 + 1) - (uint)((*puVar8 & 1) == 0);
if (puVar1 != puVar8 + 1) {
iVar10 = (iVar10 + 1) - (uint)((puVar8[1] & 1) == 0);
if (puVar1 != puVar8 + 2) {
return (iVar10 + 1) - (uint)((puVar8[2] & 1) == 0);
}
}
}
return iVar10;
} |
1,032 | func0 | #include <vector>
#include <array>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<array<int, 2>> func0(const vector<array<int, 2>> &test_tup1, const vector<array<int, 2>> &test_tup2) {
vector<array<int, 2>> res;
for (size_t i = 0; i < test_tup1.size(); i++) {
array<int, 2> temp;
for (size_t j = 0; j < test_tup1[i].size(); j++) {
temp[j] = max(test_tup1[i][j], test_tup2[i][j]);
}
res.push_back(temp);
}
return res;
}
| int main() {
vector<array<int, 2>> a1 = { {1, 3}, {4, 5}, {2, 9}, {1, 10} };
vector<array<int, 2>> b1 = { {6, 7}, {3, 9}, {1, 1}, {7, 3} };
vector<array<int, 2>> ans1 = { {6, 7}, {4, 9}, {2, 9}, {7, 10} };
assert(func0(a1, b1) == ans1);
vector<array<int, 2>> a2 = { {2, 4}, {5, 6}, {3, 10}, {2, 11} };
vector<array<int, 2>> b2 = { {7, 8}, {4, 10}, {2, 2}, {8, 4} };
vector<array<int, 2>> ans2 = { {7, 8}, {5, 10}, {3, 10}, {8, 11} };
assert(func0(a2, b2) == ans2);
vector<array<int, 2>> a3 = { {3, 5}, {6, 7}, {4, 11}, {3, 12} };
vector<array<int, 2>> b3 = { {8, 9}, {5, 11}, {3, 3}, {9, 5} };
vector<array<int, 2>> ans3 = { {8, 9}, {6, 11}, {4, 11}, {9, 12} };
assert(func0(a3, b3) == ans3);
return 0;
}
| O0 | cpp | func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&, std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1d1a <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EEC1Ev>
movq $0x0,-0x30(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1e4e <_ZNKSt6vectorISt5arrayIiLm2EESaIS1_EE4sizeEv>
cmp %rax,-0x30(%rbp)
setb %al
test %al,%al
je 1382 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x139>
movq $0x0,-0x28(%rbp)
mov -0x30(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e76 <_ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm>
mov %rax,%rdi
callq 1e9a <_ZNKSt5arrayIiLm2EE4sizeEv>
cmp %rax,-0x28(%rbp)
setb %al
test %al,%al
je 1347 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xfe>
mov -0x30(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e76 <_ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rax,%rsi
mov %rdx,%rdi
callq 1ed8 <_ZNKSt5arrayIiLm2EEixEm>
mov %rax,%rbx
mov -0x30(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e76 <_ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rax,%rsi
mov %rdx,%rdi
callq 1ed8 <_ZNKSt5arrayIiLm2EEixEm>
mov %rbx,%rsi
mov %rax,%rdi
callq 1f01 <_ZSt3maxIiERKT_S2_S2_>
mov (%rax),%ebx
mov -0x28(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1eae <_ZNSt5arrayIiLm2EEixEm>
mov %ebx,(%rax)
addq $0x1,-0x28(%rbp)
jmpq 12a8 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x5f>
lea -0x20(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1f2e <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EE9push_backERKS1_>
addq $0x1,-0x30(%rbp)
jmpq 1285 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x3c>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1e06 <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1397 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x14e>
callq 1130 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov [rbp+var_58], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EEC2Ev; std::vector<std::array<int,2ul>>::vector(void)
mov [rbp+var_38], 0
jmp loc_136B
loc_12AA:
mov [rbp+var_30], 0
jmp short loc_1328
loc_12B4:
mov rdx, [rbp+var_38]
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm; std::vector<std::array<int,2ul>>::operator[](ulong)
mov rdx, rax
mov rax, [rbp+var_30]
mov rsi, rax
mov rdi, rdx
call _ZNKSt5arrayIiLm2EEixEm; std::array<int,2ul>::operator[](ulong)
mov rbx, rax
mov rdx, [rbp+var_38]
mov rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm; std::vector<std::array<int,2ul>>::operator[](ulong)
mov rdx, rax
mov rax, [rbp+var_30]
mov rsi, rax
mov rdi, rdx
call _ZNKSt5arrayIiLm2EEixEm; std::array<int,2ul>::operator[](ulong)
mov rsi, rbx
mov rdi, rax
call _ZSt3maxIiERKT_S2_S2_; std::max<int>(int const&,int const&)
mov ebx, [rax]
mov rdx, [rbp+var_30]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZNSt5arrayIiLm2EEixEm; std::array<int,2ul>::operator[](ulong)
mov [rax], ebx
add [rbp+var_30], 1
loc_1328:
mov rdx, [rbp+var_38]
mov rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorISt5arrayIiLm2EESaIS1_EEixEm; std::vector<std::array<int,2ul>>::operator[](ulong)
mov [rbp+var_28], rax
mov eax, 2
cmp [rbp+var_30], rax
setb al
test al, al
jnz loc_12B4
lea rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EE9push_backERKS1_; std::vector<std::array<int,2ul>>::push_back(std::array<int,2ul> const&)
add [rbp+var_38], 1
loc_136B:
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorISt5arrayIiLm2EESaIS1_EE4sizeEv; std::vector<std::array<int,2ul>>::size(void)
cmp [rbp+var_38], rax
setb al
test al, al
jnz loc_12AA
jmp short loc_13BA
endbr64
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EED2Ev; std::vector<std::array<int,2ul>>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_13B2
call ___stack_chk_fail
loc_13B2:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13BA:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_13CE
call ___stack_chk_fail
loc_13CE:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // rax
unsigned long long i; // [rsp+28h] [rbp-38h]
unsigned long long j; // [rsp+30h] [rbp-30h]
_BYTE v11[8]; // [rsp+40h] [rbp-20h] BYREF
unsigned long long v12; // [rsp+48h] [rbp-18h]
v12 = __readfsqword(0x28u);
std::vector<std::array<int,2ul>>::vector(a1);
for ( i = 0LL; i < std::vector<std::array<int,2ul>>::size(a2); ++i )
{
for ( j = 0LL; ; ++j )
{
std::vector<std::array<int,2ul>>::operator[](a2, i);
if ( j >= 2 )
break;
v3 = std::vector<std::array<int,2ul>>::operator[](a3, i);
v4 = std::array<int,2ul>::operator[](v3, j);
v5 = std::vector<std::array<int,2ul>>::operator[](a2, i);
v6 = std::array<int,2ul>::operator[](v5, j);
LODWORD(v4) = *(_DWORD *)std::max<int>(v6, v4);
*(_DWORD *)std::array<int,2ul>::operator[](v11, j) = v4;
}
std::vector<std::array<int,2ul>>::push_back(a1, v11);
}
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 qword ptr [RBP + -0x58],RDX
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 0x00101d76
MOV qword ptr [RBP + -0x38],0x0
JMP 0x0010136b
LAB_001012aa:
MOV qword ptr [RBP + -0x30],0x0
JMP 0x00101328
LAB_001012b4:
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e9c
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ee6
MOV RBX,RAX
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e9c
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00101ee6
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101f0b
MOV EBX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x30]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101ec0
MOV dword ptr [RAX],EBX
ADD qword ptr [RBP + -0x30],0x1
LAB_00101328:
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e9c
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,0x2
CMP qword ptr [RBP + -0x30],RAX
SETC AL
TEST AL,AL
JNZ 0x001012b4
LEA RDX,[RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101361:
CALL 0x00101f38
ADD qword ptr [RBP + -0x38],0x1
LAB_0010136b:
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101e74
CMP qword ptr [RBP + -0x38],RAX
SETC AL
TEST AL,AL
JNZ 0x001012aa
JMP 0x001013ba
LAB_001013ba:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001013ce
CALL 0x00101150
LAB_001013ce:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&,
std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
array<int,2ul> *paVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *in_RDX;
long in_FS_OFFSET;
ulong local_40;
ulong local_38;
array<int,2ul> local_28 [8];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::vector
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_1);
local_40 = 0;
while( true ) {
uVar5 = std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::size
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_2);
if (uVar5 <= local_40) break;
local_38 = 0;
while( true ) {
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::operator[]
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_2,local_40
);
if (1 < local_38) break;
paVar2 = (array<int,2ul> *)
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::operator[]
(in_RDX,local_40);
piVar3 = (int *)std::array<int,2ul>::operator[](paVar2,local_38);
paVar2 = (array<int,2ul> *)
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::operator[]
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_2
,local_40);
piVar4 = (int *)std::array<int,2ul>::operator[](paVar2,local_38);
piVar3 = std::max<int>(piVar4,piVar3);
iVar1 = *piVar3;
piVar3 = (int *)std::array<int,2ul>::operator[](local_28,local_38);
*piVar3 = iVar1;
local_38 = local_38 + 1;
}
/* try { // try from 00101361 to 00101365 has its CatchHandler @ 00101388 */
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::push_back
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_1,
(array *)local_28);
local_40 = local_40 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
1,033 | func0 | #include <vector>
#include <array>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<array<int, 2>> func0(const vector<array<int, 2>> &test_tup1, const vector<array<int, 2>> &test_tup2) {
vector<array<int, 2>> res;
for (size_t i = 0; i < test_tup1.size(); i++) {
array<int, 2> temp;
for (size_t j = 0; j < test_tup1[i].size(); j++) {
temp[j] = max(test_tup1[i][j], test_tup2[i][j]);
}
res.push_back(temp);
}
return res;
}
| int main() {
vector<array<int, 2>> a1 = { {1, 3}, {4, 5}, {2, 9}, {1, 10} };
vector<array<int, 2>> b1 = { {6, 7}, {3, 9}, {1, 1}, {7, 3} };
vector<array<int, 2>> ans1 = { {6, 7}, {4, 9}, {2, 9}, {7, 10} };
assert(func0(a1, b1) == ans1);
vector<array<int, 2>> a2 = { {2, 4}, {5, 6}, {3, 10}, {2, 11} };
vector<array<int, 2>> b2 = { {7, 8}, {4, 10}, {2, 2}, {8, 4} };
vector<array<int, 2>> ans2 = { {7, 8}, {5, 10}, {3, 10}, {8, 11} };
assert(func0(a2, b2) == ans2);
vector<array<int, 2>> a3 = { {3, 5}, {6, 7}, {4, 11}, {3, 12} };
vector<array<int, 2>> b3 = { {8, 9}, {5, 11}, {3, 3}, {9, 5} };
vector<array<int, 2>> ans3 = { {8, 9}, {6, 11}, {4, 11}, {9, 12} };
assert(func0(a3, b3) == ans3);
return 0;
}
| O1 | cpp | func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&, std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rax
cmp 0x8(%rsi),%rax
je 131f <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xd6>
mov %rsi,%r12
mov %rdx,%r13
mov $0x0,%ebp
mov %rsp,%r14
jmp 12c4 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x7b>
mov %r14,%rdx
mov %rbx,%rdi
callq 1bc0 <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
add $0x1,%rbp
mov (%r12),%rax
mov 0x8(%r12),%rdx
sub %rax,%rdx
sar $0x3,%rdx
cmp %rdx,%rbp
jae 131f <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xd6>
lea 0x0(,%rbp,8),%rdx
add %rdx,%rax
add 0x0(%r13),%rdx
mov (%rax),%ecx
cmp %ecx,(%rdx)
cmovge (%rdx),%ecx
mov %ecx,(%rsp)
mov 0x4(%rdx),%edx
cmp %edx,0x4(%rax)
cmovge 0x4(%rax),%edx
mov %edx,0x4(%rsp)
mov 0x8(%rbx),%rsi
cmp 0x10(%rbx),%rsi
je 12a0 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x57>
mov (%rsp),%rax
mov %rax,(%rsi)
addq $0x8,0x8(%rbx)
jmp 12ab <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x62>
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
test %rdi,%rdi
je 1317 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xce>
callq 1110 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 133f <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xf6>
mov %rbx,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbx, rdi
mov r12, rsi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rax, [rsi]
mov ebp, 0
mov r14, rsp
cmp rax, [rsi+8]
jnz short loc_12E2
loc_129A:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz loc_1353
mov rax, rbx
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_12BE:
mov rdx, r14
mov rdi, rbx
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(__gnu_cxx::__normal_iterator<std::array<int,2ul>*,std::vector<std::array<int,2ul>>>,std::array<int,2ul> const&)
loc_12C9:
add rbp, 1
mov rax, [r12]
mov rdx, [r12+8]
sub rdx, rax
sar rdx, 3
cmp rbp, rdx
jnb short loc_129A
loc_12E2:
lea rdx, ds:0[rbp*8]
mov rcx, rdx
add rcx, [r13+0]
add rax, rdx
mov edx, [rax]
mov esi, [rcx]
cmp edx, esi
cmovl edx, esi
mov dword ptr [rsp+38h+var_38], edx
mov eax, [rax+4]
mov edx, [rcx+4]
cmp eax, edx
cmovl eax, edx
mov dword ptr [rsp+38h+var_38+4], eax
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz short loc_12BE
mov rax, [rsp+38h+var_38]
mov [rsi], rax
add qword ptr [rbx+8], 8
jmp short loc_12C9
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EED2Ev; std::vector<std::array<int,2ul>>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_134B
call ___stack_chk_fail
loc_134B:
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_1353:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v5; // rax
unsigned long long v6; // rbp
int *v8; // rcx
int *v9; // rax
int v10; // edx
int v11; // eax
_QWORD *v12; // rsi
_QWORD v13[7]; // [rsp+0h] [rbp-38h] BYREF
v13[1] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v5 = *a2;
v6 = 0LL;
if ( *a2 != a2[1] )
{
do
{
v8 = (int *)(*a3 + 8 * v6);
v9 = (int *)(8 * v6 + v5);
v10 = *v9;
if ( *v9 < *v8 )
v10 = *v8;
LODWORD(v13[0]) = v10;
v11 = v9[1];
if ( v11 < v8[1] )
v11 = v8[1];
HIDWORD(v13[0]) = v11;
v12 = (_QWORD *)a1[1];
if ( v12 == (_QWORD *)a1[2] )
{
std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(a1, v12, v13);
}
else
{
*v12 = v13[0];
a1[1] += 8LL;
}
++v6;
v5 = *a2;
}
while ( v6 < (a2[1] - *a2) >> 3 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV R12,RSI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
MOV EBP,0x0
MOV R14,RSP
CMP RAX,qword ptr [RSI + 0x8]
JNZ 0x001012e2
LAB_0010129a:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101353
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001012be:
MOV RDX,R14
MOV RDI,RBX
LAB_001012c4:
CALL 0x00101b60
LAB_001012c9:
ADD RBP,0x1
MOV RAX,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
SUB RDX,RAX
SAR RDX,0x3
CMP RBP,RDX
JNC 0x0010129a
LAB_001012e2:
LEA RDX,[RBP*0x8]
MOV RCX,RDX
ADD RCX,qword ptr [R13]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV ESI,dword ptr [RCX]
CMP EDX,ESI
CMOVL EDX,ESI
MOV dword ptr [RSP],EDX
MOV EAX,dword ptr [RAX + 0x4]
MOV EDX,dword ptr [RCX + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x001012be
MOV RAX,qword ptr [RSP]
MOV qword ptr [RSI],RAX
ADD qword ptr [RBX + 0x8],0x8
JMP 0x001012c9
LAB_00101353:
CALL 0x00101130 | /* func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&,
std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int8 *puVar2;
long lVar3;
int *piVar4;
int *piVar5;
long *in_RDX;
ulong uVar6;
long in_FS_OFFSET;
int local_38;
int iStack_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;
lVar3 = *(long *)param_2;
uVar6 = 0;
if (lVar3 != *(long *)(param_2 + 8)) {
do {
piVar5 = (int *)(uVar6 * 8 + *in_RDX);
piVar4 = (int *)(lVar3 + uVar6 * 8);
local_38 = *piVar4;
iVar1 = *piVar5;
if (local_38 < iVar1) {
local_38 = iVar1;
}
iStack_34 = piVar4[1];
iVar1 = piVar5[1];
if (iStack_34 < iVar1) {
iStack_34 = iVar1;
}
puVar2 = *(int8 **)(param_1 + 8);
if (puVar2 == *(int8 **)(param_1 + 0x10)) {
/* try { // try from 001012c4 to 001012c8 has its CatchHandler @ 00101327 */
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::
_M_realloc_insert<std::array<int,2ul>const&>
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_1,
(__normal_iterator)puVar2,(array *)&local_38);
}
else {
*puVar2 = CONCAT44(iStack_34,local_38);
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 8;
}
uVar6 = uVar6 + 1;
lVar3 = *(long *)param_2;
} while (uVar6 < (ulong)(*(long *)(param_2 + 8) - lVar3 >> 3));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,034 | func0 | #include <vector>
#include <array>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<array<int, 2>> func0(const vector<array<int, 2>> &test_tup1, const vector<array<int, 2>> &test_tup2) {
vector<array<int, 2>> res;
for (size_t i = 0; i < test_tup1.size(); i++) {
array<int, 2> temp;
for (size_t j = 0; j < test_tup1[i].size(); j++) {
temp[j] = max(test_tup1[i][j], test_tup2[i][j]);
}
res.push_back(temp);
}
return res;
}
| int main() {
vector<array<int, 2>> a1 = { {1, 3}, {4, 5}, {2, 9}, {1, 10} };
vector<array<int, 2>> b1 = { {6, 7}, {3, 9}, {1, 1}, {7, 3} };
vector<array<int, 2>> ans1 = { {6, 7}, {4, 9}, {2, 9}, {7, 10} };
assert(func0(a1, b1) == ans1);
vector<array<int, 2>> a2 = { {2, 4}, {5, 6}, {3, 10}, {2, 11} };
vector<array<int, 2>> b2 = { {7, 8}, {4, 10}, {2, 2}, {8, 4} };
vector<array<int, 2>> ans2 = { {7, 8}, {5, 10}, {3, 10}, {8, 11} };
assert(func0(a2, b2) == ans2);
vector<array<int, 2>> a3 = { {3, 5}, {6, 7}, {4, 11}, {3, 12} };
vector<array<int, 2>> b3 = { {8, 9}, {5, 11}, {3, 3}, {9, 5} };
vector<array<int, 2>> ans3 = { {8, 9}, {6, 11}, {4, 11}, {9, 12} };
assert(func0(a3, b3) == ans3);
return 0;
}
| O2 | cpp | func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&, std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&):
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),%rax
cmp 0x8(%rsi),%rax
je 1980 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xd0>
mov %rsi,%rbp
mov %rdx,%r13
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
mov %rsp,%r14
jmp 1940 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x90>
nopl 0x0(%rax,%rax,1)
mov %ecx,(%rsi)
add $0x8,%rsi
mov %edx,-0x4(%rsi)
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rdx
add $0x1,%rbx
sub %rax,%rdx
sar $0x3,%rdx
cmp %rdx,%rbx
jae 1980 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xd0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
lea 0x0(,%rbx,8),%rdx
add %rdx,%rax
add 0x0(%r13),%rdx
mov (%rax),%ecx
cmp %ecx,(%rdx)
cmovge (%rdx),%ecx
mov %ecx,(%rsp)
mov 0x4(%rdx),%edx
cmp %edx,0x4(%rax)
cmovge 0x4(%rax),%edx
mov %edx,0x4(%rsp)
cmp %rdi,%rsi
jne 1910 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x60>
mov %r14,%rdx
mov %r12,%rdi
callq 1b00 <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
jmp 191e <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x6e>
nopl 0x0(%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 19a0 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xf0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rcx, [rsi+8]
jz loc_1848
mov r13, rdx
xor edi, edi
xor esi, esi
xor ebx, ebx
mov r14, rsp
jmp short loc_17FD
loc_17D0:
mov rax, [rsp+38h+var_38]
add rsi, 8
mov [rsi-8], rax
mov [rbp+8], rsi
loc_17E0:
mov rax, [r12+8]
add rbx, 1
sub rax, rcx
sar rax, 3
cmp rbx, rax
jnb short loc_1848
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_17FD:
mov r8, [r13+0]
lea rax, ds:0[rbx*8]
add r8, rax
add rax, rcx
mov r9d, [rax]
mov edx, [r8]
mov eax, [rax+4]
cmp edx, r9d
cmovl edx, r9d
mov dword ptr [rsp+38h+var_38], edx
mov edx, [r8+4]
cmp eax, edx
cmovl eax, edx
mov dword ptr [rsp+38h+var_38+4], eax
cmp rsi, rdi
jnz short loc_17D0
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(__gnu_cxx::__normal_iterator<std::array<int,2ul>*,std::vector<std::array<int,2ul>>>,std::array<int,2ul> const&)
mov rcx, [r12]
jmp short loc_17E0
loc_1848:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1868
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1868:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5__cold; func0(std::vector<std::array<int,2ul>> const&,std::vector<std::array<int,2ul>> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rcx
long long v7; // rdi
long long v8; // rsi
long long v9; // rbx
long long v10; // rsi
int *v11; // r8
int *v12; // rax
int v13; // r9d
int v14; // edx
int v15; // eax
_QWORD v17[7]; // [rsp+0h] [rbp-38h] BYREF
v17[1] = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( v5 != a2[1] )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v11 = (int *)(8 * v9 + *a3);
v12 = (int *)(v5 + 8 * v9);
v13 = *v12;
v14 = *v11;
v15 = v12[1];
if ( *v11 < v13 )
v14 = v13;
LODWORD(v17[0]) = v14;
if ( v15 < v11[1] )
v15 = v11[1];
HIDWORD(v17[0]) = v15;
if ( v8 == v7 )
{
std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(a1, v8, v17);
v5 = *a2;
}
else
{
v10 = v8 + 8;
*(_QWORD *)(v10 - 8) = v17[0];
*(_QWORD *)(a1 + 8) = v10;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v5) >> 3) )
break;
v8 = *(_QWORD *)(a1 + 8);
v7 = *(_QWORD *)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RCX,qword ptr [RSI + 0x8]
JZ 0x00101848
MOV R13,RDX
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
MOV R14,RSP
JMP 0x001017fd
LAB_001017d0:
MOV RAX,qword ptr [RSP]
ADD RSI,0x8
MOV qword ptr [RSI + -0x8],RAX
MOV qword ptr [RBP + 0x8],RSI
LAB_001017e0:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x3
CMP RBX,RAX
JNC 0x00101848
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_001017fd:
MOV R8,qword ptr [R13]
LEA RAX,[RBX*0x8]
ADD R8,RAX
ADD RAX,RCX
MOV R9D,dword ptr [RAX]
MOV EDX,dword ptr [R8]
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,R9D
CMOVL EDX,R9D
MOV dword ptr [RSP],EDX
MOV EDX,dword ptr [R8 + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x001017d0
MOV RDX,R14
MOV RDI,RBP
LAB_0010183a:
CALL 0x00101990
MOV RCX,qword ptr [R12]
JMP 0x001017e0
LAB_00101848:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101868
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101868:
CALL 0x00101110 | /* func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&,
std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
long lVar3;
long *in_RDX;
ulong uVar4;
int8 *puVar5;
int8 *puVar6;
int *piVar7;
long in_FS_OFFSET;
int local_38;
int iStack_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar3 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (lVar3 != *(long *)(param_2 + 8)) {
puVar6 = (int8 *)0x0;
puVar5 = (int8 *)0x0;
uVar4 = 0;
while( true ) {
piVar7 = (int *)(*in_RDX + uVar4 * 8);
piVar2 = (int *)(uVar4 * 8 + lVar3);
iVar1 = *piVar2;
local_38 = *piVar7;
iStack_34 = piVar2[1];
if (local_38 < iVar1) {
local_38 = iVar1;
}
iVar1 = piVar7[1];
if (iStack_34 < iVar1) {
iStack_34 = iVar1;
}
if (puVar5 == puVar6) {
/* try { // try from 0010183a to 0010183e has its CatchHandler @ 0010186d */
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::
_M_realloc_insert<std::array<int,2ul>const&>
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_1,
(__normal_iterator)puVar5,(array *)&local_38);
lVar3 = *(long *)param_2;
}
else {
*puVar5 = CONCAT44(iStack_34,local_38);
*(int8 **)(param_1 + 8) = puVar5 + 1;
}
uVar4 = uVar4 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar3 >> 3) <= uVar4) break;
puVar5 = *(int8 **)(param_1 + 8);
puVar6 = *(int8 **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,035 | func0 | #include <vector>
#include <array>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<array<int, 2>> func0(const vector<array<int, 2>> &test_tup1, const vector<array<int, 2>> &test_tup2) {
vector<array<int, 2>> res;
for (size_t i = 0; i < test_tup1.size(); i++) {
array<int, 2> temp;
for (size_t j = 0; j < test_tup1[i].size(); j++) {
temp[j] = max(test_tup1[i][j], test_tup2[i][j]);
}
res.push_back(temp);
}
return res;
}
| int main() {
vector<array<int, 2>> a1 = { {1, 3}, {4, 5}, {2, 9}, {1, 10} };
vector<array<int, 2>> b1 = { {6, 7}, {3, 9}, {1, 1}, {7, 3} };
vector<array<int, 2>> ans1 = { {6, 7}, {4, 9}, {2, 9}, {7, 10} };
assert(func0(a1, b1) == ans1);
vector<array<int, 2>> a2 = { {2, 4}, {5, 6}, {3, 10}, {2, 11} };
vector<array<int, 2>> b2 = { {7, 8}, {4, 10}, {2, 2}, {8, 4} };
vector<array<int, 2>> ans2 = { {7, 8}, {5, 10}, {3, 10}, {8, 11} };
assert(func0(a2, b2) == ans2);
vector<array<int, 2>> a3 = { {3, 5}, {6, 7}, {4, 11}, {3, 12} };
vector<array<int, 2>> b3 = { {8, 9}, {5, 11}, {3, 3}, {9, 5} };
vector<array<int, 2>> ans3 = { {8, 9}, {6, 11}, {4, 11}, {9, 12} };
assert(func0(a3, b3) == ans3);
return 0;
}
| O3 | cpp | func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&, std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&):
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),%rax
cmp 0x8(%rsi),%rax
je 18e0 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xc0>
mov %rsi,%rbp
mov %rdx,%r13
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
mov %rsp,%r14
jmp 18a0 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x80>
mov %ecx,(%rsi)
add $0x8,%rsi
mov %edx,-0x4(%rsi)
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rax
mov 0x8(%rbp),%rdx
add $0x1,%rbx
sub %rax,%rdx
sar $0x3,%rdx
cmp %rdx,%rbx
jae 18e0 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xc0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
lea 0x0(,%rbx,8),%rdx
add %rdx,%rax
add 0x0(%r13),%rdx
mov (%rdx),%ecx
cmp %ecx,(%rax)
cmovge (%rax),%ecx
mov %ecx,(%rsp)
mov 0x4(%rdx),%edx
cmp %edx,0x4(%rax)
cmovge 0x4(%rax),%edx
mov %edx,0x4(%rsp)
cmp %rdi,%rsi
jne 1870 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 19a0 <_ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_>
jmp 187e <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0x5e>
nopl 0x0(%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1900 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_+0xe0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
mov r12, rsi
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp rcx, [rsi+8]
jz loc_1848
mov r13, rdx
xor edi, edi
xor esi, esi
xor ebx, ebx
mov r14, rsp
jmp short loc_17FD
loc_17D0:
mov rax, [rsp+38h+var_38]
add rsi, 8
mov [rsi-8], rax
mov [rbp+8], rsi
loc_17E0:
mov rax, [r12+8]
add rbx, 1
sub rax, rcx
sar rax, 3
cmp rbx, rax
jnb short loc_1848
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_17FD:
mov r8, [r13+0]
lea rax, ds:0[rbx*8]
add r8, rax
add rax, rcx
mov edx, [rax]
mov r9d, [r8]
mov eax, [rax+4]
cmp edx, r9d
cmovl edx, r9d
mov dword ptr [rsp+38h+var_38], edx
mov edx, [r8+4]
cmp eax, edx
cmovl eax, edx
mov dword ptr [rsp+38h+var_38+4], eax
cmp rsi, rdi
jnz short loc_17D0
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorISt5arrayIiLm2EESaIS1_EE17_M_realloc_insertIJRKS1_EEEvN9__gnu_cxx17__normal_iteratorIPS1_S3_EEDpOT_; std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(__gnu_cxx::__normal_iterator<std::array<int,2ul>*,std::vector<std::array<int,2ul>>>,std::array<int,2ul> const&)
mov rcx, [r12]
jmp short loc_17E0
loc_1848:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1868
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1868:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorISt5arrayIiLm2EESaIS1_EES5__cold; func0(std::vector<std::array<int,2ul>> const&,std::vector<std::array<int,2ul>> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rcx
long long v7; // rdi
long long v8; // rsi
long long v9; // rbx
long long v10; // rsi
int *v11; // r8
int *v12; // rax
int v13; // edx
int v14; // eax
_QWORD v16[7]; // [rsp+0h] [rbp-38h] BYREF
v16[1] = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( v5 != a2[1] )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v11 = (int *)(8 * v9 + *a3);
v12 = (int *)(v5 + 8 * v9);
v13 = *v12;
v14 = v12[1];
if ( v13 < *v11 )
v13 = *v11;
LODWORD(v16[0]) = v13;
if ( v14 < v11[1] )
v14 = v11[1];
HIDWORD(v16[0]) = v14;
if ( v8 == v7 )
{
std::vector<std::array<int,2ul>>::_M_realloc_insert<std::array<int,2ul> const&>(a1, v8, v16);
v5 = *a2;
}
else
{
v10 = v8 + 8;
*(_QWORD *)(v10 - 8) = v16[0];
*(_QWORD *)(a1 + 8) = v10;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v5) >> 3) )
break;
v8 = *(_QWORD *)(a1 + 8);
v7 = *(_QWORD *)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP RCX,qword ptr [RSI + 0x8]
JZ 0x00101848
MOV R13,RDX
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
MOV R14,RSP
JMP 0x001017fd
LAB_001017d0:
MOV RAX,qword ptr [RSP]
ADD RSI,0x8
MOV qword ptr [RSI + -0x8],RAX
MOV qword ptr [RBP + 0x8],RSI
LAB_001017e0:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x3
CMP RBX,RAX
JNC 0x00101848
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_001017fd:
MOV R8,qword ptr [R13]
LEA RAX,[RBX*0x8]
ADD R8,RAX
ADD RAX,RCX
MOV EDX,dword ptr [RAX]
MOV R9D,dword ptr [R8]
MOV EAX,dword ptr [RAX + 0x4]
CMP EDX,R9D
CMOVL EDX,R9D
MOV dword ptr [RSP],EDX
MOV EDX,dword ptr [R8 + 0x4]
CMP EAX,EDX
CMOVL EAX,EDX
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x001017d0
MOV RDX,R14
MOV RDI,RBP
LAB_00101839:
CALL 0x00101990
MOV RCX,qword ptr [R12]
JMP 0x001017e0
LAB_00101848:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101868
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101868:
CALL 0x00101110 | /* func0(std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&,
std::vector<std::array<int, 2ul>, std::allocator<std::array<int, 2ul> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
long lVar3;
long *in_RDX;
ulong uVar4;
int8 *puVar5;
int8 *puVar6;
int *piVar7;
long in_FS_OFFSET;
int local_38;
int iStack_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar3 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (lVar3 != *(long *)(param_2 + 8)) {
puVar6 = (int8 *)0x0;
puVar5 = (int8 *)0x0;
uVar4 = 0;
while( true ) {
piVar7 = (int *)(*in_RDX + uVar4 * 8);
piVar2 = (int *)(uVar4 * 8 + lVar3);
local_38 = *piVar2;
iVar1 = *piVar7;
iStack_34 = piVar2[1];
if (local_38 < iVar1) {
local_38 = iVar1;
}
iVar1 = piVar7[1];
if (iStack_34 < iVar1) {
iStack_34 = iVar1;
}
if (puVar5 == puVar6) {
/* try { // try from 00101839 to 0010183d has its CatchHandler @ 0010186d */
std::vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>>::
_M_realloc_insert<std::array<int,2ul>const&>
((vector<std::array<int,2ul>,std::allocator<std::array<int,2ul>>> *)param_1,
(__normal_iterator)puVar5,(array *)&local_38);
lVar3 = *(long *)param_2;
}
else {
*puVar5 = CONCAT44(iStack_34,local_38);
*(int8 **)(param_1 + 8) = puVar5 + 1;
}
uVar4 = uVar4 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar3 >> 3) <= uVar4) break;
puVar5 = *(int8 **)(param_1 + 8);
puVar6 = *(int8 **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,036 | func0 |
#include <cassert>
| int func0(int n) {
if (n == 0 || n == 1) {
return 1;
}
return 2 * func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(3) == 7);
assert(func0(4) == 17);
assert(func0(5) == 41);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
je 1165 <_Z5func0i+0x1c>
cmpl $0x1,-0x14(%rbp)
jne 116c <_Z5func0i+0x23>
mov $0x1,%eax
jmp 118b <_Z5func0i+0x42>
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1149 <_Z5func0i>
lea (%rax,%rax,1),%ebx
mov -0x14(%rbp),%eax
sub $0x2,%eax
mov %eax,%edi
callq 1149 <_Z5func0i>
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_14], edi
cmp [rbp+var_14], 0
jz short loc_1165
cmp [rbp+var_14], 1
jnz short loc_116C
loc_1165:
mov eax, 1
jmp short loc_118B
loc_116C:
mov eax, [rbp+var_14]
sub eax, 1
mov edi, eax; int
call _Z5func0i; func0(int)
lea ebx, [rax+rax]
mov eax, [rbp+var_14]
sub eax, 2
mov edi, eax; int
call _Z5func0i; func0(int)
add eax, ebx
loc_118B:
mov rbx, [rbp+var_8]
leave
retn | long long func0(unsigned int a1)
{
int v2; // ebx
if ( a1 <= 1 )
return 1LL;
v2 = 2 * func0(a1 - 1);
return v2 + (unsigned int)func0(a1 - 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00101165
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x0010116c
LAB_00101165:
MOV EAX,0x1
JMP 0x0010118b
LAB_0010116c:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101149
LEA EBX,[RAX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
MOV EDI,EAX
CALL 0x00101149
ADD EAX,EBX
LAB_0010118b:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if ((param_1 == 0) || (param_1 == 1)) {
iVar2 = 1;
}
else {
iVar1 = func0(param_1 + -1);
iVar2 = func0(param_1 + -2);
iVar2 = iVar2 + iVar1 * 2;
}
return iVar2;
} |
1,037 | func0 |
#include <cassert>
| int func0(int n) {
if (n == 0 || n == 1) {
return 1;
}
return 2 * func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(3) == 7);
assert(func0(4) == 17);
assert(func0(5) == 41);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov $0x1,%eax
cmp $0x1,%edi
jbe 117b <_Z5func0i+0x32>
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
lea -0x1(%rdi),%edi
callq 1149 <_Z5func0i>
mov %eax,%ebp
lea -0x2(%rbx),%edi
callq 1149 <_Z5func0i>
lea (%rax,%rbp,2),%eax
add $0x8,%rsp
pop %rbx
pop %rbp
retq
retq
| _Z5func0i:
endbr64
mov eax, 1
cmp edi, 1
jbe short locret_117B
push rbp
push rbx
sub rsp, 8
mov ebx, edi
lea edi, [rdi-1]; int
call _Z5func0i; func0(int)
mov ebp, eax
lea edi, [rbx-2]; int
call _Z5func0i; func0(int)
lea eax, [rax+rbp*2]
add rsp, 8
pop rbx
pop rbp
retn
locret_117B:
retn | long long func0(unsigned int a1)
{
long long result; // rax
int v2; // ebp
result = 1LL;
if ( a1 > 1 )
{
v2 = func0(a1 - 1);
return (unsigned int)func0(a1 - 2) + 2 * v2;
}
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,0x1
JBE 0x0010117b
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
LEA EDI,[RDI + -0x1]
CALL 0x00101149
MOV EBP,EAX
LEA EDI,[RBX + -0x2]
CALL 0x00101149
LEA EAX,[RAX + RBP*0x2]
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_0010117b:
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (1 < (uint)param_1) {
iVar1 = func0(param_1 + -1);
iVar2 = func0(param_1 + -2);
return iVar2 + iVar1 * 2;
}
return 1;
} |
1,038 | func0 |
#include <cassert>
| int func0(int n) {
if (n == 0 || n == 1) {
return 1;
}
return 2 * func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(3) == 7);
assert(func0(4) == 17);
assert(func0(5) == 41);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jbe 1248 <_Z5func0i+0x38>
push %rbp
xor %ebp,%ebp
push %rbx
mov %edi,%ebx
sub $0x8,%rsp
lea -0x1(%rbx),%edi
sub $0x2,%ebx
callq 1210 <_Z5func0i>
lea 0x0(%rbp,%rax,2),%ebp
cmp $0x1,%ebx
ja 1223 <_Z5func0i+0x13>
add $0x8,%rsp
lea 0x1(%rbp),%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| _Z5func0i:
endbr64
push r15
push r14
mov r14d, 1
push r13
push r12
push rbp
push rbx
sub rsp, 58h
cmp edi, 1
jbe loc_1576
lea r15d, [rdi-1]
xor ebp, ebp
loc_1217:
cmp r15d, 1
jz loc_156F
loc_1221:
lea r12d, [r15-1]
xor r14d, r14d
mov [rsp+88h+var_6C], ebp
mov r13d, r12d
mov ebp, r14d
mov ebx, r12d
loc_1235:
cmp ebx, 1
jz loc_1544
loc_123E:
mov [rsp+88h+var_64], r15d
lea ecx, [rbx-1]
xor r14d, r14d
mov r12d, ebx
mov [rsp+88h+var_68], ebp
mov ebx, ecx
mov ebp, r14d
loc_1255:
cmp ebx, 1
jz loc_1517
mov [rsp+88h+var_60], r13d
lea edi, [rbx-1]
mov eax, r12d
xor r15d, r15d
mov [rsp+88h+var_5C], ebx
mov r12d, edi
loc_1273:
cmp r12d, 1
jz loc_14DE
mov [rsp+88h+var_58], ebp
lea r11d, [r12-1]
mov r10d, ecx
xor r13d, r13d
mov ecx, r15d
mov ebx, r11d
mov r9d, eax
mov r8d, edi
mov r15d, r12d
loc_129B:
cmp ebx, 1
jz loc_149F
loc_12A4:
lea ebp, [rbx-1]
xor r12d, r12d
mov edi, ecx
mov [rsp+88h+var_84], ebp
mov eax, ebp
mov ebp, r9d
loc_12B5:
mov r14d, eax
cmp eax, 1
jz loc_1478
lea esi, [rax-1]
lea edx, [rax-2]
mov ecx, r14d
mov r9d, edi
mov eax, esi
mov [rsp+88h+var_88], edx
mov edi, edx
and eax, 0FFFFFFFEh
sub ecx, eax
mov eax, r14d
mov [rsp+88h+var_70], ecx
xor ecx, ecx
loc_12E2:
mov edx, [rsp+88h+var_70]
cmp eax, edx
jz loc_14C0
mov r14d, edi
mov [rsp+88h+var_80], r9d
xor edx, edx
mov r9d, ebx
mov [rsp+88h+var_78], ecx
mov ebx, r14d
mov ecx, r15d
mov r15d, ebp
mov [rsp+88h+var_7C], eax
mov [rsp+88h+var_74], edi
cmp r14d, 1
jbe short loc_138A
loc_1316:
xor ebp, ebp
loc_1318:
lea edi, [rbx-1]; int
sub ebx, 2
mov [rsp+88h+var_3C], esi
mov [rsp+88h+var_40], r9d
mov [rsp+88h+var_44], ecx
mov [rsp+88h+var_48], r11d
mov [rsp+88h+var_4C], r8d
mov [rsp+88h+var_50], r10d
mov [rsp+88h+var_54], edx
call _Z5func0i; func0(int)
cmp ebx, 1
mov edx, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_44]
mov r10d, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_4C]
lea ebp, [rbp+rax*2+0]
mov r11d, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_40]
mov esi, [rsp+88h+var_3C]
ja short loc_1318
lea edx, [rdx+rbp*2+2]
lea edi, [r14-2]
cmp r14d, 2
jz loc_14F8
mov r14d, edi
mov ebx, r14d
cmp r14d, 1
ja short loc_1316
loc_138A:
mov ebp, r15d
mov ebx, r9d
mov r15d, ecx
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_78]
mov r9d, [rsp+88h+var_80]
add edx, 2
mov edi, [rsp+88h+var_74]
loc_13A7:
sub eax, 2
lea ecx, [rcx+rdx*2+2]
sub edi, 2
cmp eax, 1
jnz loc_12E2
mov edx, [rsp+88h+var_88]
mov edi, r9d
lea r12d, [r12+rcx*2+2]
cmp esi, 1
jnz loc_14D7
loc_13CE:
mov r9d, ebp
mov ebp, [rsp+88h+var_84]
mov ecx, edi
lea r13d, [r13+r12*2+2]
sub ebx, 2
cmp ebp, 1
jnz loc_129B
loc_13E8:
mov ebp, [rsp+88h+var_58]
mov r12d, r15d
mov eax, r9d
mov r15d, ecx
mov edi, r8d
mov ecx, r10d
loc_13FB:
lea r15d, [r15+r13*2+2]
sub r12d, 2
cmp r11d, 1
jnz loc_1273
mov r13d, [rsp+88h+var_60]
mov ebx, [rsp+88h+var_5C]
mov r12d, eax
loc_141A:
lea ebp, [rbp+r15*2+2]
sub ebx, 2
cmp edi, 1
jnz loc_1255
mov r14d, ebp
mov ebp, [rsp+88h+var_68]
mov ebx, r12d
mov r15d, [rsp+88h+var_64]
sub ebx, 2
lea ebp, [rbp+r14*2+2]
cmp ecx, 1
jnz loc_1235
loc_144B:
mov r14d, ebp
mov ebp, [rsp+88h+var_6C]
mov r12d, r13d
sub r15d, 2
lea ebp, [rbp+r14*2+2]
cmp r12d, 1
jnz loc_1217
loc_1468:
mov r14d, ebp
add r14d, 1
jmp loc_1576
loc_1478:
mov r9d, ebp
mov ebp, [rsp+88h+var_84]
add r12d, 2
mov ecx, edi
lea r13d, [r13+r12*2+2]
sub ebx, 2
cmp ebp, 1
jz loc_13E8
cmp ebx, 1
jnz loc_12A4
loc_149F:
mov r12d, r15d
mov ebp, [rsp+88h+var_58]
mov r15d, ecx
mov eax, r9d
mov edi, r8d
mov ecx, r10d
add r13d, 2
jmp loc_13FB
loc_14C0:
add ecx, 2
mov edx, [rsp+88h+var_88]
mov edi, r9d
lea r12d, [r12+rcx*2+2]
cmp esi, 1
jz loc_13CE
loc_14D7:
mov eax, edx
jmp loc_12B5
loc_14DE:
mov r13d, [rsp+88h+var_60]
mov ebx, [rsp+88h+var_5C]
mov r12d, eax
add r15d, 2
jmp loc_141A
loc_14F8:
mov ebp, r15d
mov ebx, r9d
mov r15d, ecx
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_78]
mov r9d, [rsp+88h+var_80]
mov edi, [rsp+88h+var_74]
jmp loc_13A7
loc_1517:
mov r14d, ebp
mov ebp, [rsp+88h+var_68]
mov ebx, r12d
mov r15d, [rsp+88h+var_64]
add r14d, 2
sub ebx, 2
lea ebp, [rbp+r14*2+2]
cmp ecx, 1
jz loc_144B
cmp ebx, 1
jnz loc_123E
loc_1544:
mov r14d, ebp
mov ebp, [rsp+88h+var_6C]
mov r12d, r13d
sub r15d, 2
add r14d, 2
lea ebp, [rbp+r14*2+2]
cmp r12d, 1
jz loc_1468
cmp r15d, 1
jnz loc_1221
loc_156F:
mov r14d, ebp
add r14d, 3
loc_1576:
add rsp, 58h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(unsigned int a1)
{
unsigned int v1; // r14d
unsigned int v2; // r15d
int v3; // ebp
unsigned int v4; // r13d
int v5; // ebp
unsigned int v6; // ebx
unsigned int v7; // ecx
unsigned int v8; // r12d
unsigned int v9; // ebx
int v10; // ebp
unsigned int v11; // edi
unsigned int v12; // eax
int v13; // r15d
unsigned int v14; // r12d
unsigned int v15; // r11d
unsigned int v16; // r10d
int v17; // r13d
int v18; // ecx
unsigned int v19; // ebx
unsigned int v20; // r9d
unsigned int v21; // r8d
unsigned int v22; // r15d
int v23; // r12d
int v24; // edi
unsigned int v25; // eax
unsigned int v26; // ebp
unsigned int v27; // esi
int v28; // r9d
unsigned int v29; // edi
int v30; // ecx
unsigned int v31; // r14d
int v32; // edx
unsigned int v33; // r9d
unsigned int v34; // ebx
unsigned int v35; // ecx
unsigned int v36; // r15d
int v37; // ebp
int v38; // edi
int v39; // eax
unsigned int v40; // edi
unsigned int v41; // eax
int v42; // ecx
unsigned int v43; // edi
unsigned int v44; // edx
unsigned int v45; // r12d
int v46; // r15d
unsigned int v47; // ebx
unsigned int v49; // [rsp+0h] [rbp-88h]
unsigned int v50; // [rsp+4h] [rbp-84h]
int v51; // [rsp+8h] [rbp-80h]
unsigned int v52; // [rsp+Ch] [rbp-7Ch]
int v53; // [rsp+10h] [rbp-78h]
unsigned int v54; // [rsp+14h] [rbp-74h]
unsigned int v55; // [rsp+18h] [rbp-70h]
int v56; // [rsp+1Ch] [rbp-6Ch]
int v57; // [rsp+20h] [rbp-68h]
unsigned int v58; // [rsp+24h] [rbp-64h]
unsigned int v59; // [rsp+28h] [rbp-60h]
unsigned int v60; // [rsp+2Ch] [rbp-5Ch]
int v61; // [rsp+30h] [rbp-58h]
int v62; // [rsp+34h] [rbp-54h]
unsigned int v63; // [rsp+38h] [rbp-50h]
unsigned int v64; // [rsp+3Ch] [rbp-4Ch]
unsigned int v65; // [rsp+40h] [rbp-48h]
unsigned int v66; // [rsp+44h] [rbp-44h]
unsigned int v67; // [rsp+48h] [rbp-40h]
v1 = 1;
if ( a1 > 1 )
{
v2 = a1 - 1;
v3 = 0;
LABEL_3:
if ( v2 == 1 )
{
return (unsigned int)(v3 + 3);
}
else
{
while ( 1 )
{
v56 = v3;
v4 = v2 - 1;
v5 = 0;
v6 = v2 - 1;
LABEL_5:
if ( v6 != 1 )
{
while ( 2 )
{
v58 = v2;
v7 = v6 - 1;
v8 = v6;
v57 = v5;
v9 = v6 - 1;
v10 = 0;
while ( v9 != 1 )
{
v59 = v4;
v11 = v9 - 1;
v12 = v8;
v13 = 0;
v60 = v9;
v14 = v9 - 1;
while ( v14 != 1 )
{
v61 = v10;
v15 = v14 - 1;
v16 = v7;
v17 = 0;
v18 = v13;
v19 = v14 - 1;
v20 = v12;
v21 = v11;
v22 = v14;
while ( 2 )
{
if ( v19 == 1 )
{
LABEL_34:
v45 = v22;
v10 = v61;
v46 = v18;
v12 = v20;
v11 = v21;
v7 = v16;
v17 += 2;
goto LABEL_26;
}
while ( 1 )
{
v23 = 0;
v24 = v18;
v50 = v19 - 1;
v25 = v19 - 1;
v26 = v20;
LABEL_13:
if ( v25 != 1 )
break;
v20 = v26;
v18 = v24;
v17 += 2 * (v23 + 2) + 2;
v19 -= 2;
if ( v50 == 1 )
goto LABEL_25;
if ( v19 == 1 )
goto LABEL_34;
}
v27 = v25 - 1;
v28 = v24;
v49 = v25 - 2;
v29 = v25 - 2;
v55 = v25 - ((v25 - 1) & 0xFFFFFFFE);
v30 = 0;
do
{
if ( v25 == v55 )
{
v44 = v49;
v24 = v28;
v23 += 2 * (v30 + 2) + 2;
if ( v27 == 1 )
goto LABEL_24;
LABEL_36:
v25 = v44;
goto LABEL_13;
}
v31 = v29;
v51 = v28;
v32 = 0;
v33 = v19;
v53 = v30;
v34 = v29;
v35 = v22;
v36 = v26;
v52 = v25;
v54 = v29;
if ( v29 <= 1 )
{
LABEL_21:
v26 = v36;
v19 = v33;
v22 = v35;
v41 = v52;
v42 = v53;
v28 = v51;
v32 += 2;
v43 = v54;
}
else
{
while ( 1 )
{
v37 = 0;
do
{
v38 = v34 - 1;
v34 -= 2;
v67 = v33;
v66 = v35;
v65 = v15;
v64 = v21;
v63 = v16;
v62 = v32;
v39 = func0(v38);
v32 = v62;
v35 = v66;
v16 = v63;
v21 = v64;
v37 += 2 * v39;
v15 = v65;
v33 = v67;
}
while ( v34 > 1 );
v32 = v62 + 2 * v37 + 2;
v40 = v31 - 2;
if ( v31 == 2 )
break;
v31 -= 2;
v34 = v40;
if ( v40 <= 1 )
goto LABEL_21;
}
v26 = v36;
v19 = v67;
v22 = v66;
v41 = v52;
v42 = v53;
v28 = v51;
v43 = v54;
}
v25 = v41 - 2;
v30 = v42 + 2 * v32 + 2;
v29 = v43 - 2;
}
while ( v25 != 1 );
v44 = v49;
v24 = v28;
v23 += 2 * v30 + 2;
if ( v27 != 1 )
goto LABEL_36;
LABEL_24:
v20 = v26;
v18 = v24;
v17 += 2 * v23 + 2;
v19 -= 2;
if ( v50 != 1 )
continue;
break;
}
LABEL_25:
v10 = v61;
v45 = v22;
v12 = v20;
v46 = v18;
v11 = v21;
v7 = v16;
LABEL_26:
v13 = v46 + 2 * v17 + 2;
v14 = v45 - 2;
if ( v15 == 1 )
{
v4 = v59;
v47 = v60;
v8 = v12;
goto LABEL_28;
}
}
v4 = v59;
v47 = v60;
v8 = v12;
v13 += 2;
LABEL_28:
v10 += 2 * v13 + 2;
v9 = v47 - 2;
if ( v11 == 1 )
{
v2 = v58;
v6 = v8 - 2;
v5 = v57 + 2 * v10 + 2;
if ( v7 != 1 )
goto LABEL_5;
LABEL_30:
v2 -= 2;
v3 = v56 + 2 * v5 + 2;
if ( v4 != 1 )
goto LABEL_3;
return (unsigned int)(v3 + 1);
}
}
v2 = v58;
v6 = v8 - 2;
v5 = v57 + 2 * (v10 + 2) + 2;
if ( v7 == 1 )
goto LABEL_30;
if ( v8 != 3 )
continue;
break;
}
}
v2 -= 2;
v3 = v56 + 2 * (v5 + 2) + 2;
if ( v4 == 1 )
return (unsigned int)(v3 + 1);
if ( v2 == 1 )
return (unsigned int)(v3 + 3);
}
}
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,0x1
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
CMP EDI,0x1
JBE 0x00101576
LEA R15D,[RDI + -0x1]
XOR EBP,EBP
LAB_00101217:
CMP R15D,0x1
JZ 0x0010156f
LAB_00101221:
LEA R12D,[R15 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x1c],EBP
MOV R13D,R12D
MOV EBP,R14D
MOV EBX,R12D
LAB_00101235:
CMP EBX,0x1
JZ 0x00101544
LAB_0010123e:
MOV dword ptr [RSP + 0x24],R15D
LEA ECX,[RBX + -0x1]
XOR R14D,R14D
MOV R12D,EBX
MOV dword ptr [RSP + 0x20],EBP
MOV EBX,ECX
MOV EBP,R14D
LAB_00101255:
CMP EBX,0x1
JZ 0x00101517
MOV dword ptr [RSP + 0x28],R13D
LEA EDI,[RBX + -0x1]
MOV EAX,R12D
XOR R15D,R15D
MOV dword ptr [RSP + 0x2c],EBX
MOV R12D,EDI
LAB_00101273:
CMP R12D,0x1
JZ 0x001014de
MOV dword ptr [RSP + 0x30],EBP
LEA R11D,[R12 + -0x1]
MOV R10D,ECX
XOR R13D,R13D
MOV ECX,R15D
MOV EBX,R11D
MOV R9D,EAX
MOV R8D,EDI
MOV R15D,R12D
LAB_0010129b:
CMP EBX,0x1
JZ 0x0010149f
LAB_001012a4:
LEA EBP,[RBX + -0x1]
XOR R12D,R12D
MOV EDI,ECX
MOV dword ptr [RSP + 0x4],EBP
MOV EAX,EBP
MOV EBP,R9D
LAB_001012b5:
MOV R14D,EAX
CMP EAX,0x1
JZ 0x00101478
LEA ESI,[RAX + -0x1]
LEA EDX,[RAX + -0x2]
MOV ECX,R14D
MOV R9D,EDI
MOV EAX,ESI
MOV dword ptr [RSP],EDX
MOV EDI,EDX
AND EAX,0xfffffffe
SUB ECX,EAX
MOV EAX,R14D
MOV dword ptr [RSP + 0x18],ECX
XOR ECX,ECX
LAB_001012e2:
MOV EDX,dword ptr [RSP + 0x18]
CMP EAX,EDX
JZ 0x001014c0
MOV R14D,EDI
MOV dword ptr [RSP + 0x8],R9D
XOR EDX,EDX
MOV R9D,EBX
MOV dword ptr [RSP + 0x10],ECX
MOV EBX,R14D
MOV ECX,R15D
MOV R15D,EBP
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x14],EDI
CMP R14D,0x1
JBE 0x0010138a
LAB_00101316:
XOR EBP,EBP
LAB_00101318:
LEA EDI,[RBX + -0x1]
SUB EBX,0x2
MOV dword ptr [RSP + 0x4c],ESI
MOV dword ptr [RSP + 0x48],R9D
MOV dword ptr [RSP + 0x44],ECX
MOV dword ptr [RSP + 0x40],R11D
MOV dword ptr [RSP + 0x3c],R8D
MOV dword ptr [RSP + 0x38],R10D
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
CMP EBX,0x1
MOV EDX,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x44]
MOV R10D,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x3c]
LEA EBP,[RBP + RAX*0x2]
MOV R11D,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x48]
MOV ESI,dword ptr [RSP + 0x4c]
JA 0x00101318
LEA EDX,[RDX + RBP*0x2 + 0x2]
LEA EDI,[R14 + -0x2]
CMP R14D,0x2
JZ 0x001014f8
MOV R14D,EDI
MOV EBX,R14D
CMP R14D,0x1
JA 0x00101316
LAB_0010138a:
MOV EBP,R15D
MOV EBX,R9D
MOV R15D,ECX
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0x8]
ADD EDX,0x2
MOV EDI,dword ptr [RSP + 0x14]
LAB_001013a7:
SUB EAX,0x2
LEA ECX,[RCX + RDX*0x2 + 0x2]
SUB EDI,0x2
CMP EAX,0x1
JNZ 0x001012e2
MOV EDX,dword ptr [RSP]
MOV EDI,R9D
LEA R12D,[R12 + RCX*0x2 + 0x2]
CMP ESI,0x1
JNZ 0x001014d7
LAB_001013ce:
MOV R9D,EBP
MOV EBP,dword ptr [RSP + 0x4]
MOV ECX,EDI
LEA R13D,[R13 + R12*0x2 + 0x2]
SUB EBX,0x2
CMP EBP,0x1
JNZ 0x0010129b
LAB_001013e8:
MOV EBP,dword ptr [RSP + 0x30]
MOV R12D,R15D
MOV EAX,R9D
MOV R15D,ECX
MOV EDI,R8D
MOV ECX,R10D
LAB_001013fb:
LEA R15D,[R15 + R13*0x2 + 0x2]
SUB R12D,0x2
CMP R11D,0x1
JNZ 0x00101273
MOV R13D,dword ptr [RSP + 0x28]
MOV EBX,dword ptr [RSP + 0x2c]
MOV R12D,EAX
LAB_0010141a:
LEA EBP,[RBP + R15*0x2 + 0x2]
SUB EBX,0x2
CMP EDI,0x1
JNZ 0x00101255
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x20]
MOV EBX,R12D
MOV R15D,dword ptr [RSP + 0x24]
SUB EBX,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP ECX,0x1
JNZ 0x00101235
LAB_0010144b:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x1c]
MOV R12D,R13D
SUB R15D,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP R12D,0x1
JNZ 0x00101217
LAB_00101468:
MOV R14D,EBP
ADD R14D,0x1
JMP 0x00101576
LAB_00101478:
MOV R9D,EBP
MOV EBP,dword ptr [RSP + 0x4]
ADD R12D,0x2
MOV ECX,EDI
LEA R13D,[R13 + R12*0x2 + 0x2]
SUB EBX,0x2
CMP EBP,0x1
JZ 0x001013e8
CMP EBX,0x1
JNZ 0x001012a4
LAB_0010149f:
MOV R12D,R15D
MOV EBP,dword ptr [RSP + 0x30]
MOV R15D,ECX
MOV EAX,R9D
MOV EDI,R8D
MOV ECX,R10D
ADD R13D,0x2
JMP 0x001013fb
LAB_001014c0:
ADD ECX,0x2
MOV EDX,dword ptr [RSP]
MOV EDI,R9D
LEA R12D,[R12 + RCX*0x2 + 0x2]
CMP ESI,0x1
JZ 0x001013ce
LAB_001014d7:
MOV EAX,EDX
JMP 0x001012b5
LAB_001014de:
MOV R13D,dword ptr [RSP + 0x28]
MOV EBX,dword ptr [RSP + 0x2c]
MOV R12D,EAX
ADD R15D,0x2
JMP 0x0010141a
LAB_001014f8:
MOV EBP,R15D
MOV EBX,R9D
MOV R15D,ECX
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0x8]
MOV EDI,dword ptr [RSP + 0x14]
JMP 0x001013a7
LAB_00101517:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x20]
MOV EBX,R12D
MOV R15D,dword ptr [RSP + 0x24]
ADD R14D,0x2
SUB EBX,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP ECX,0x1
JZ 0x0010144b
CMP EBX,0x1
JNZ 0x0010123e
LAB_00101544:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x1c]
MOV R12D,R13D
SUB R15D,0x2
ADD R14D,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP R12D,0x1
JZ 0x00101468
CMP R15D,0x1
JNZ 0x00101221
LAB_0010156f:
MOV R14D,EBP
ADD R14D,0x3
LAB_00101576:
ADD RSP,0x58
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
uint uVar3;
uint uVar4;
int iVar5;
int iVar6;
uint uVar7;
int iVar8;
uint uVar9;
int iVar10;
uint uVar11;
int iVar12;
uint uVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
uint uVar18;
int iVar19;
uint uVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int iVar25;
int iVar26;
int iVar27;
bool bVar28;
iVar17 = 1;
if (1 < (uint)param_1) {
iVar26 = param_1 + -1;
iVar17 = 0;
do {
if (iVar26 == 1) {
return iVar17 + 3;
}
iVar1 = iVar26 + -1;
iVar15 = 0;
iVar6 = iVar1;
do {
if (iVar6 == 1) {
iVar17 = iVar17 + 2 + (iVar15 + 2) * 2;
goto joined_r0x0010155f;
}
iVar8 = iVar6 + -1;
iVar25 = 0;
iVar14 = iVar8;
do {
if (iVar14 == 1) {
iVar15 = iVar15 + 2 + (iVar25 + 2) * 2;
goto joined_r0x00101445;
}
iVar2 = iVar14 + -1;
iVar27 = 0;
iVar23 = iVar2;
do {
if (iVar23 == 1) {
iVar27 = iVar27 + 2;
break;
}
iVar21 = iVar23 + -1;
iVar24 = 0;
iVar5 = iVar21;
do {
if (iVar5 == 1) {
iVar24 = iVar24 + 2;
break;
}
uVar3 = iVar5 - 1;
iVar22 = 0;
uVar7 = uVar3;
do {
if (uVar7 == 1) {
iVar24 = iVar24 + 2 + (iVar22 + 2) * 2;
goto joined_r0x00101490;
}
uVar18 = uVar7 - 1;
uVar11 = uVar7 - 2;
uVar9 = uVar7 - (uVar18 & 0xfffffffe);
iVar10 = 0;
uVar20 = uVar11;
do {
if (uVar7 == uVar9) {
iVar22 = iVar22 + 2 + (iVar10 + 2) * 2;
goto joined_r0x001014d1;
}
iVar12 = 0;
uVar4 = uVar20;
do {
if (uVar4 < 2) {
iVar12 = iVar12 + 2;
break;
}
iVar16 = 0;
uVar13 = uVar4;
do {
iVar19 = uVar13 - 1;
uVar13 = uVar13 - 2;
iVar19 = func0(iVar19);
iVar16 = iVar16 + iVar19 * 2;
} while (1 < uVar13);
iVar12 = iVar12 + 2 + iVar16 * 2;
bVar28 = uVar4 != 2;
uVar4 = uVar4 - 2;
} while (bVar28);
uVar7 = uVar7 - 2;
iVar10 = iVar10 + 2 + iVar12 * 2;
uVar20 = uVar20 - 2;
} while (uVar7 != 1);
iVar22 = iVar22 + 2 + iVar10 * 2;
joined_r0x001014d1:
uVar7 = uVar11;
} while (uVar18 != 1);
iVar24 = iVar24 + 2 + iVar22 * 2;
joined_r0x00101490:
iVar5 = iVar5 + -2;
} while (uVar3 != 1);
iVar27 = iVar27 + 2 + iVar24 * 2;
iVar23 = iVar23 + -2;
} while (iVar21 != 1);
iVar25 = iVar25 + 2 + iVar27 * 2;
iVar14 = iVar14 + -2;
} while (iVar2 != 1);
iVar15 = iVar15 + 2 + iVar25 * 2;
joined_r0x00101445:
iVar6 = iVar6 + -2;
} while (iVar8 != 1);
iVar17 = iVar17 + 2 + iVar15 * 2;
joined_r0x0010155f:
iVar26 = iVar26 + -2;
} while (iVar1 != 1);
iVar17 = iVar17 + 1;
}
return iVar17;
} |
1,039 | func0 |
#include <cassert>
| int func0(int n) {
if (n == 0 || n == 1) {
return 1;
}
return 2 * func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(3) == 7);
assert(func0(4) == 17);
assert(func0(5) == 41);
return 0;
}
| O3 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jbe 1248 <_Z5func0i+0x38>
push %rbp
xor %ebp,%ebp
push %rbx
mov %edi,%ebx
sub $0x8,%rsp
lea -0x1(%rbx),%edi
sub $0x2,%ebx
callq 1210 <_Z5func0i>
lea 0x0(%rbp,%rax,2),%ebp
cmp $0x1,%ebx
ja 1223 <_Z5func0i+0x13>
add $0x8,%rsp
lea 0x1(%rbp),%eax
pop %rbx
pop %rbp
retq
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
| _Z5func0i:
endbr64
push r15
push r14
mov r14d, 1
push r13
push r12
push rbp
push rbx
sub rsp, 58h
cmp edi, 1
jbe loc_1576
lea r15d, [rdi-1]
xor ebp, ebp
loc_1217:
cmp r15d, 1
jz loc_156F
loc_1221:
lea r12d, [r15-1]
xor r14d, r14d
mov [rsp+88h+var_6C], ebp
mov r13d, r12d
mov ebp, r14d
mov ebx, r12d
loc_1235:
cmp ebx, 1
jz loc_1544
loc_123E:
mov [rsp+88h+var_64], r15d
lea ecx, [rbx-1]
xor r14d, r14d
mov r12d, ebx
mov [rsp+88h+var_68], ebp
mov ebx, ecx
mov ebp, r14d
loc_1255:
cmp ebx, 1
jz loc_1517
mov [rsp+88h+var_60], r13d
lea edi, [rbx-1]
mov eax, r12d
xor r15d, r15d
mov [rsp+88h+var_5C], ebx
mov r12d, edi
loc_1273:
cmp r12d, 1
jz loc_14DE
mov [rsp+88h+var_58], ebp
lea r11d, [r12-1]
mov r10d, ecx
xor r13d, r13d
mov ecx, r15d
mov ebx, r11d
mov r9d, eax
mov r8d, edi
mov r15d, r12d
loc_129B:
cmp ebx, 1
jz loc_149F
loc_12A4:
lea ebp, [rbx-1]
xor r12d, r12d
mov edi, ecx
mov [rsp+88h+var_84], ebp
mov eax, ebp
mov ebp, r9d
loc_12B5:
mov r14d, eax
cmp eax, 1
jz loc_1478
lea esi, [rax-1]
lea edx, [rax-2]
mov ecx, r14d
mov r9d, edi
mov eax, esi
mov [rsp+88h+var_88], edx
mov edi, edx
and eax, 0FFFFFFFEh
sub ecx, eax
mov eax, r14d
mov [rsp+88h+var_70], ecx
xor ecx, ecx
loc_12E2:
mov edx, [rsp+88h+var_70]
cmp eax, edx
jz loc_14C0
mov r14d, edi
mov [rsp+88h+var_80], r9d
xor edx, edx
mov r9d, ebx
mov [rsp+88h+var_78], ecx
mov ebx, r14d
mov ecx, r15d
mov r15d, ebp
mov [rsp+88h+var_7C], eax
mov [rsp+88h+var_74], edi
cmp r14d, 1
jbe short loc_138A
loc_1316:
xor ebp, ebp
loc_1318:
lea edi, [rbx-1]; int
sub ebx, 2
mov [rsp+88h+var_3C], esi
mov [rsp+88h+var_40], r9d
mov [rsp+88h+var_44], ecx
mov [rsp+88h+var_48], r11d
mov [rsp+88h+var_4C], r8d
mov [rsp+88h+var_50], r10d
mov [rsp+88h+var_54], edx
call _Z5func0i; func0(int)
cmp ebx, 1
mov edx, [rsp+88h+var_54]
mov ecx, [rsp+88h+var_44]
mov r10d, [rsp+88h+var_50]
mov r8d, [rsp+88h+var_4C]
lea ebp, [rbp+rax*2+0]
mov r11d, [rsp+88h+var_48]
mov r9d, [rsp+88h+var_40]
mov esi, [rsp+88h+var_3C]
ja short loc_1318
lea edx, [rdx+rbp*2+2]
lea edi, [r14-2]
cmp r14d, 2
jz loc_14F8
mov r14d, edi
mov ebx, r14d
cmp r14d, 1
ja short loc_1316
loc_138A:
mov ebp, r15d
mov ebx, r9d
mov r15d, ecx
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_78]
mov r9d, [rsp+88h+var_80]
add edx, 2
mov edi, [rsp+88h+var_74]
loc_13A7:
sub eax, 2
lea ecx, [rcx+rdx*2+2]
sub edi, 2
cmp eax, 1
jnz loc_12E2
mov edx, [rsp+88h+var_88]
mov edi, r9d
lea r12d, [r12+rcx*2+2]
cmp esi, 1
jnz loc_14D7
loc_13CE:
mov r9d, ebp
mov ebp, [rsp+88h+var_84]
mov ecx, edi
lea r13d, [r13+r12*2+2]
sub ebx, 2
cmp ebp, 1
jnz loc_129B
loc_13E8:
mov ebp, [rsp+88h+var_58]
mov r12d, r15d
mov eax, r9d
mov r15d, ecx
mov edi, r8d
mov ecx, r10d
loc_13FB:
lea r15d, [r15+r13*2+2]
sub r12d, 2
cmp r11d, 1
jnz loc_1273
mov r13d, [rsp+88h+var_60]
mov ebx, [rsp+88h+var_5C]
mov r12d, eax
loc_141A:
lea ebp, [rbp+r15*2+2]
sub ebx, 2
cmp edi, 1
jnz loc_1255
mov r14d, ebp
mov ebp, [rsp+88h+var_68]
mov ebx, r12d
mov r15d, [rsp+88h+var_64]
sub ebx, 2
lea ebp, [rbp+r14*2+2]
cmp ecx, 1
jnz loc_1235
loc_144B:
mov r14d, ebp
mov ebp, [rsp+88h+var_6C]
mov r12d, r13d
sub r15d, 2
lea ebp, [rbp+r14*2+2]
cmp r12d, 1
jnz loc_1217
loc_1468:
mov r14d, ebp
add r14d, 1
jmp loc_1576
loc_1478:
mov r9d, ebp
mov ebp, [rsp+88h+var_84]
add r12d, 2
mov ecx, edi
lea r13d, [r13+r12*2+2]
sub ebx, 2
cmp ebp, 1
jz loc_13E8
cmp ebx, 1
jnz loc_12A4
loc_149F:
mov r12d, r15d
mov ebp, [rsp+88h+var_58]
mov r15d, ecx
mov eax, r9d
mov edi, r8d
mov ecx, r10d
add r13d, 2
jmp loc_13FB
loc_14C0:
add ecx, 2
mov edx, [rsp+88h+var_88]
mov edi, r9d
lea r12d, [r12+rcx*2+2]
cmp esi, 1
jz loc_13CE
loc_14D7:
mov eax, edx
jmp loc_12B5
loc_14DE:
mov r13d, [rsp+88h+var_60]
mov ebx, [rsp+88h+var_5C]
mov r12d, eax
add r15d, 2
jmp loc_141A
loc_14F8:
mov ebp, r15d
mov ebx, r9d
mov r15d, ecx
mov eax, [rsp+88h+var_7C]
mov ecx, [rsp+88h+var_78]
mov r9d, [rsp+88h+var_80]
mov edi, [rsp+88h+var_74]
jmp loc_13A7
loc_1517:
mov r14d, ebp
mov ebp, [rsp+88h+var_68]
mov ebx, r12d
mov r15d, [rsp+88h+var_64]
add r14d, 2
sub ebx, 2
lea ebp, [rbp+r14*2+2]
cmp ecx, 1
jz loc_144B
cmp ebx, 1
jnz loc_123E
loc_1544:
mov r14d, ebp
mov ebp, [rsp+88h+var_6C]
mov r12d, r13d
sub r15d, 2
add r14d, 2
lea ebp, [rbp+r14*2+2]
cmp r12d, 1
jz loc_1468
cmp r15d, 1
jnz loc_1221
loc_156F:
mov r14d, ebp
add r14d, 3
loc_1576:
add rsp, 58h
mov eax, r14d
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(unsigned int a1)
{
unsigned int v1; // r14d
unsigned int v2; // r15d
int v3; // ebp
unsigned int v4; // r13d
int v5; // ebp
unsigned int v6; // ebx
unsigned int v7; // ecx
unsigned int v8; // r12d
unsigned int v9; // ebx
int v10; // ebp
unsigned int v11; // edi
unsigned int v12; // eax
int v13; // r15d
unsigned int v14; // r12d
unsigned int v15; // r11d
unsigned int v16; // r10d
int v17; // r13d
int v18; // ecx
unsigned int v19; // ebx
unsigned int v20; // r9d
unsigned int v21; // r8d
unsigned int v22; // r15d
int v23; // r12d
int v24; // edi
unsigned int v25; // eax
unsigned int v26; // ebp
unsigned int v27; // esi
int v28; // r9d
unsigned int v29; // edi
int v30; // ecx
unsigned int v31; // r14d
int v32; // edx
unsigned int v33; // r9d
unsigned int v34; // ebx
unsigned int v35; // ecx
unsigned int v36; // r15d
int v37; // ebp
int v38; // edi
int v39; // eax
unsigned int v40; // edi
unsigned int v41; // eax
int v42; // ecx
unsigned int v43; // edi
unsigned int v44; // edx
unsigned int v45; // r12d
int v46; // r15d
unsigned int v47; // ebx
unsigned int v49; // [rsp+0h] [rbp-88h]
unsigned int v50; // [rsp+4h] [rbp-84h]
int v51; // [rsp+8h] [rbp-80h]
unsigned int v52; // [rsp+Ch] [rbp-7Ch]
int v53; // [rsp+10h] [rbp-78h]
unsigned int v54; // [rsp+14h] [rbp-74h]
unsigned int v55; // [rsp+18h] [rbp-70h]
int v56; // [rsp+1Ch] [rbp-6Ch]
int v57; // [rsp+20h] [rbp-68h]
unsigned int v58; // [rsp+24h] [rbp-64h]
unsigned int v59; // [rsp+28h] [rbp-60h]
unsigned int v60; // [rsp+2Ch] [rbp-5Ch]
int v61; // [rsp+30h] [rbp-58h]
int v62; // [rsp+34h] [rbp-54h]
unsigned int v63; // [rsp+38h] [rbp-50h]
unsigned int v64; // [rsp+3Ch] [rbp-4Ch]
unsigned int v65; // [rsp+40h] [rbp-48h]
unsigned int v66; // [rsp+44h] [rbp-44h]
unsigned int v67; // [rsp+48h] [rbp-40h]
v1 = 1;
if ( a1 > 1 )
{
v2 = a1 - 1;
v3 = 0;
LABEL_3:
if ( v2 == 1 )
{
return (unsigned int)(v3 + 3);
}
else
{
while ( 1 )
{
v56 = v3;
v4 = v2 - 1;
v5 = 0;
v6 = v2 - 1;
LABEL_5:
if ( v6 != 1 )
{
while ( 2 )
{
v58 = v2;
v7 = v6 - 1;
v8 = v6;
v57 = v5;
v9 = v6 - 1;
v10 = 0;
while ( v9 != 1 )
{
v59 = v4;
v11 = v9 - 1;
v12 = v8;
v13 = 0;
v60 = v9;
v14 = v9 - 1;
while ( v14 != 1 )
{
v61 = v10;
v15 = v14 - 1;
v16 = v7;
v17 = 0;
v18 = v13;
v19 = v14 - 1;
v20 = v12;
v21 = v11;
v22 = v14;
while ( 2 )
{
if ( v19 == 1 )
{
LABEL_34:
v45 = v22;
v10 = v61;
v46 = v18;
v12 = v20;
v11 = v21;
v7 = v16;
v17 += 2;
goto LABEL_26;
}
while ( 1 )
{
v23 = 0;
v24 = v18;
v50 = v19 - 1;
v25 = v19 - 1;
v26 = v20;
LABEL_13:
if ( v25 != 1 )
break;
v20 = v26;
v18 = v24;
v17 += 2 * (v23 + 2) + 2;
v19 -= 2;
if ( v50 == 1 )
goto LABEL_25;
if ( v19 == 1 )
goto LABEL_34;
}
v27 = v25 - 1;
v28 = v24;
v49 = v25 - 2;
v29 = v25 - 2;
v55 = v25 - ((v25 - 1) & 0xFFFFFFFE);
v30 = 0;
do
{
if ( v25 == v55 )
{
v44 = v49;
v24 = v28;
v23 += 2 * (v30 + 2) + 2;
if ( v27 == 1 )
goto LABEL_24;
LABEL_36:
v25 = v44;
goto LABEL_13;
}
v31 = v29;
v51 = v28;
v32 = 0;
v33 = v19;
v53 = v30;
v34 = v29;
v35 = v22;
v36 = v26;
v52 = v25;
v54 = v29;
if ( v29 <= 1 )
{
LABEL_21:
v26 = v36;
v19 = v33;
v22 = v35;
v41 = v52;
v42 = v53;
v28 = v51;
v32 += 2;
v43 = v54;
}
else
{
while ( 1 )
{
v37 = 0;
do
{
v38 = v34 - 1;
v34 -= 2;
v67 = v33;
v66 = v35;
v65 = v15;
v64 = v21;
v63 = v16;
v62 = v32;
v39 = func0(v38);
v32 = v62;
v35 = v66;
v16 = v63;
v21 = v64;
v37 += 2 * v39;
v15 = v65;
v33 = v67;
}
while ( v34 > 1 );
v32 = v62 + 2 * v37 + 2;
v40 = v31 - 2;
if ( v31 == 2 )
break;
v31 -= 2;
v34 = v40;
if ( v40 <= 1 )
goto LABEL_21;
}
v26 = v36;
v19 = v67;
v22 = v66;
v41 = v52;
v42 = v53;
v28 = v51;
v43 = v54;
}
v25 = v41 - 2;
v30 = v42 + 2 * v32 + 2;
v29 = v43 - 2;
}
while ( v25 != 1 );
v44 = v49;
v24 = v28;
v23 += 2 * v30 + 2;
if ( v27 != 1 )
goto LABEL_36;
LABEL_24:
v20 = v26;
v18 = v24;
v17 += 2 * v23 + 2;
v19 -= 2;
if ( v50 != 1 )
continue;
break;
}
LABEL_25:
v10 = v61;
v45 = v22;
v12 = v20;
v46 = v18;
v11 = v21;
v7 = v16;
LABEL_26:
v13 = v46 + 2 * v17 + 2;
v14 = v45 - 2;
if ( v15 == 1 )
{
v4 = v59;
v47 = v60;
v8 = v12;
goto LABEL_28;
}
}
v4 = v59;
v47 = v60;
v8 = v12;
v13 += 2;
LABEL_28:
v10 += 2 * v13 + 2;
v9 = v47 - 2;
if ( v11 == 1 )
{
v2 = v58;
v6 = v8 - 2;
v5 = v57 + 2 * v10 + 2;
if ( v7 != 1 )
goto LABEL_5;
LABEL_30:
v2 -= 2;
v3 = v56 + 2 * v5 + 2;
if ( v4 != 1 )
goto LABEL_3;
return (unsigned int)(v3 + 1);
}
}
v2 = v58;
v6 = v8 - 2;
v5 = v57 + 2 * (v10 + 2) + 2;
if ( v7 == 1 )
goto LABEL_30;
if ( v8 != 3 )
continue;
break;
}
}
v2 -= 2;
v3 = v56 + 2 * (v5 + 2) + 2;
if ( v4 == 1 )
return (unsigned int)(v3 + 1);
if ( v2 == 1 )
return (unsigned int)(v3 + 3);
}
}
}
return v1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,0x1
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
CMP EDI,0x1
JBE 0x00101576
LEA R15D,[RDI + -0x1]
XOR EBP,EBP
LAB_00101217:
CMP R15D,0x1
JZ 0x0010156f
LAB_00101221:
LEA R12D,[R15 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x1c],EBP
MOV R13D,R12D
MOV EBP,R14D
MOV EBX,R12D
LAB_00101235:
CMP EBX,0x1
JZ 0x00101544
LAB_0010123e:
MOV dword ptr [RSP + 0x24],R15D
LEA ECX,[RBX + -0x1]
XOR R14D,R14D
MOV R12D,EBX
MOV dword ptr [RSP + 0x20],EBP
MOV EBX,ECX
MOV EBP,R14D
LAB_00101255:
CMP EBX,0x1
JZ 0x00101517
MOV dword ptr [RSP + 0x28],R13D
LEA EDI,[RBX + -0x1]
MOV EAX,R12D
XOR R15D,R15D
MOV dword ptr [RSP + 0x2c],EBX
MOV R12D,EDI
LAB_00101273:
CMP R12D,0x1
JZ 0x001014de
MOV dword ptr [RSP + 0x30],EBP
LEA R11D,[R12 + -0x1]
MOV R10D,ECX
XOR R13D,R13D
MOV ECX,R15D
MOV EBX,R11D
MOV R9D,EAX
MOV R8D,EDI
MOV R15D,R12D
LAB_0010129b:
CMP EBX,0x1
JZ 0x0010149f
LAB_001012a4:
LEA EBP,[RBX + -0x1]
XOR R12D,R12D
MOV EDI,ECX
MOV dword ptr [RSP + 0x4],EBP
MOV EAX,EBP
MOV EBP,R9D
LAB_001012b5:
MOV R14D,EAX
CMP EAX,0x1
JZ 0x00101478
LEA ESI,[RAX + -0x1]
LEA EDX,[RAX + -0x2]
MOV ECX,R14D
MOV R9D,EDI
MOV EAX,ESI
MOV dword ptr [RSP],EDX
MOV EDI,EDX
AND EAX,0xfffffffe
SUB ECX,EAX
MOV EAX,R14D
MOV dword ptr [RSP + 0x18],ECX
XOR ECX,ECX
LAB_001012e2:
MOV EDX,dword ptr [RSP + 0x18]
CMP EAX,EDX
JZ 0x001014c0
MOV R14D,EDI
MOV dword ptr [RSP + 0x8],R9D
XOR EDX,EDX
MOV R9D,EBX
MOV dword ptr [RSP + 0x10],ECX
MOV EBX,R14D
MOV ECX,R15D
MOV R15D,EBP
MOV dword ptr [RSP + 0xc],EAX
MOV dword ptr [RSP + 0x14],EDI
CMP R14D,0x1
JBE 0x0010138a
LAB_00101316:
XOR EBP,EBP
LAB_00101318:
LEA EDI,[RBX + -0x1]
SUB EBX,0x2
MOV dword ptr [RSP + 0x4c],ESI
MOV dword ptr [RSP + 0x48],R9D
MOV dword ptr [RSP + 0x44],ECX
MOV dword ptr [RSP + 0x40],R11D
MOV dword ptr [RSP + 0x3c],R8D
MOV dword ptr [RSP + 0x38],R10D
MOV dword ptr [RSP + 0x34],EDX
CALL 0x001011f0
CMP EBX,0x1
MOV EDX,dword ptr [RSP + 0x34]
MOV ECX,dword ptr [RSP + 0x44]
MOV R10D,dword ptr [RSP + 0x38]
MOV R8D,dword ptr [RSP + 0x3c]
LEA EBP,[RBP + RAX*0x2]
MOV R11D,dword ptr [RSP + 0x40]
MOV R9D,dword ptr [RSP + 0x48]
MOV ESI,dword ptr [RSP + 0x4c]
JA 0x00101318
LEA EDX,[RDX + RBP*0x2 + 0x2]
LEA EDI,[R14 + -0x2]
CMP R14D,0x2
JZ 0x001014f8
MOV R14D,EDI
MOV EBX,R14D
CMP R14D,0x1
JA 0x00101316
LAB_0010138a:
MOV EBP,R15D
MOV EBX,R9D
MOV R15D,ECX
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0x8]
ADD EDX,0x2
MOV EDI,dword ptr [RSP + 0x14]
LAB_001013a7:
SUB EAX,0x2
LEA ECX,[RCX + RDX*0x2 + 0x2]
SUB EDI,0x2
CMP EAX,0x1
JNZ 0x001012e2
MOV EDX,dword ptr [RSP]
MOV EDI,R9D
LEA R12D,[R12 + RCX*0x2 + 0x2]
CMP ESI,0x1
JNZ 0x001014d7
LAB_001013ce:
MOV R9D,EBP
MOV EBP,dword ptr [RSP + 0x4]
MOV ECX,EDI
LEA R13D,[R13 + R12*0x2 + 0x2]
SUB EBX,0x2
CMP EBP,0x1
JNZ 0x0010129b
LAB_001013e8:
MOV EBP,dword ptr [RSP + 0x30]
MOV R12D,R15D
MOV EAX,R9D
MOV R15D,ECX
MOV EDI,R8D
MOV ECX,R10D
LAB_001013fb:
LEA R15D,[R15 + R13*0x2 + 0x2]
SUB R12D,0x2
CMP R11D,0x1
JNZ 0x00101273
MOV R13D,dword ptr [RSP + 0x28]
MOV EBX,dword ptr [RSP + 0x2c]
MOV R12D,EAX
LAB_0010141a:
LEA EBP,[RBP + R15*0x2 + 0x2]
SUB EBX,0x2
CMP EDI,0x1
JNZ 0x00101255
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x20]
MOV EBX,R12D
MOV R15D,dword ptr [RSP + 0x24]
SUB EBX,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP ECX,0x1
JNZ 0x00101235
LAB_0010144b:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x1c]
MOV R12D,R13D
SUB R15D,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP R12D,0x1
JNZ 0x00101217
LAB_00101468:
MOV R14D,EBP
ADD R14D,0x1
JMP 0x00101576
LAB_00101478:
MOV R9D,EBP
MOV EBP,dword ptr [RSP + 0x4]
ADD R12D,0x2
MOV ECX,EDI
LEA R13D,[R13 + R12*0x2 + 0x2]
SUB EBX,0x2
CMP EBP,0x1
JZ 0x001013e8
CMP EBX,0x1
JNZ 0x001012a4
LAB_0010149f:
MOV R12D,R15D
MOV EBP,dword ptr [RSP + 0x30]
MOV R15D,ECX
MOV EAX,R9D
MOV EDI,R8D
MOV ECX,R10D
ADD R13D,0x2
JMP 0x001013fb
LAB_001014c0:
ADD ECX,0x2
MOV EDX,dword ptr [RSP]
MOV EDI,R9D
LEA R12D,[R12 + RCX*0x2 + 0x2]
CMP ESI,0x1
JZ 0x001013ce
LAB_001014d7:
MOV EAX,EDX
JMP 0x001012b5
LAB_001014de:
MOV R13D,dword ptr [RSP + 0x28]
MOV EBX,dword ptr [RSP + 0x2c]
MOV R12D,EAX
ADD R15D,0x2
JMP 0x0010141a
LAB_001014f8:
MOV EBP,R15D
MOV EBX,R9D
MOV R15D,ECX
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0x10]
MOV R9D,dword ptr [RSP + 0x8]
MOV EDI,dword ptr [RSP + 0x14]
JMP 0x001013a7
LAB_00101517:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x20]
MOV EBX,R12D
MOV R15D,dword ptr [RSP + 0x24]
ADD R14D,0x2
SUB EBX,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP ECX,0x1
JZ 0x0010144b
CMP EBX,0x1
JNZ 0x0010123e
LAB_00101544:
MOV R14D,EBP
MOV EBP,dword ptr [RSP + 0x1c]
MOV R12D,R13D
SUB R15D,0x2
ADD R14D,0x2
LEA EBP,[RBP + R14*0x2 + 0x2]
CMP R12D,0x1
JZ 0x00101468
CMP R15D,0x1
JNZ 0x00101221
LAB_0010156f:
MOV R14D,EBP
ADD R14D,0x3
LAB_00101576:
ADD RSP,0x58
MOV EAX,R14D
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
uint uVar3;
uint uVar4;
int iVar5;
int iVar6;
uint uVar7;
int iVar8;
uint uVar9;
int iVar10;
uint uVar11;
int iVar12;
uint uVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
uint uVar18;
int iVar19;
uint uVar20;
int iVar21;
int iVar22;
int iVar23;
int iVar24;
int iVar25;
int iVar26;
int iVar27;
bool bVar28;
iVar17 = 1;
if (1 < (uint)param_1) {
iVar26 = param_1 + -1;
iVar17 = 0;
do {
if (iVar26 == 1) {
return iVar17 + 3;
}
iVar1 = iVar26 + -1;
iVar15 = 0;
iVar6 = iVar1;
do {
if (iVar6 == 1) {
iVar17 = iVar17 + 2 + (iVar15 + 2) * 2;
goto joined_r0x0010155f;
}
iVar8 = iVar6 + -1;
iVar25 = 0;
iVar14 = iVar8;
do {
if (iVar14 == 1) {
iVar15 = iVar15 + 2 + (iVar25 + 2) * 2;
goto joined_r0x00101445;
}
iVar2 = iVar14 + -1;
iVar27 = 0;
iVar23 = iVar2;
do {
if (iVar23 == 1) {
iVar27 = iVar27 + 2;
break;
}
iVar21 = iVar23 + -1;
iVar24 = 0;
iVar5 = iVar21;
do {
if (iVar5 == 1) {
iVar24 = iVar24 + 2;
break;
}
uVar3 = iVar5 - 1;
iVar22 = 0;
uVar7 = uVar3;
do {
if (uVar7 == 1) {
iVar24 = iVar24 + 2 + (iVar22 + 2) * 2;
goto joined_r0x00101490;
}
uVar18 = uVar7 - 1;
uVar11 = uVar7 - 2;
uVar9 = uVar7 - (uVar18 & 0xfffffffe);
iVar10 = 0;
uVar20 = uVar11;
do {
if (uVar7 == uVar9) {
iVar22 = iVar22 + 2 + (iVar10 + 2) * 2;
goto joined_r0x001014d1;
}
iVar12 = 0;
uVar4 = uVar20;
do {
if (uVar4 < 2) {
iVar12 = iVar12 + 2;
break;
}
iVar16 = 0;
uVar13 = uVar4;
do {
iVar19 = uVar13 - 1;
uVar13 = uVar13 - 2;
iVar19 = func0(iVar19);
iVar16 = iVar16 + iVar19 * 2;
} while (1 < uVar13);
iVar12 = iVar12 + 2 + iVar16 * 2;
bVar28 = uVar4 != 2;
uVar4 = uVar4 - 2;
} while (bVar28);
uVar7 = uVar7 - 2;
iVar10 = iVar10 + 2 + iVar12 * 2;
uVar20 = uVar20 - 2;
} while (uVar7 != 1);
iVar22 = iVar22 + 2 + iVar10 * 2;
joined_r0x001014d1:
uVar7 = uVar11;
} while (uVar18 != 1);
iVar24 = iVar24 + 2 + iVar22 * 2;
joined_r0x00101490:
iVar5 = iVar5 + -2;
} while (uVar3 != 1);
iVar27 = iVar27 + 2 + iVar24 * 2;
iVar23 = iVar23 + -2;
} while (iVar21 != 1);
iVar25 = iVar25 + 2 + iVar27 * 2;
iVar14 = iVar14 + -2;
} while (iVar2 != 1);
iVar15 = iVar15 + 2 + iVar25 * 2;
joined_r0x00101445:
iVar6 = iVar6 + -2;
} while (iVar8 != 1);
iVar17 = iVar17 + 2 + iVar15 * 2;
joined_r0x0010155f:
iVar26 = iVar26 + -2;
} while (iVar1 != 1);
iVar17 = iVar17 + 1;
}
return iVar17;
} |
1,040 | func0 | #include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
std::tuple<int, int, int, int> res(
std::get<0>(test_tup1) / std::get<0>(test_tup2),
std::get<1>(test_tup1) / std::get<1>(test_tup2),
std::get<2>(test_tup1) / std::get<2>(test_tup2),
std::get<3>(test_tup1) / std::get<3>(test_tup2)
);
return res;
}
| int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(2, 2, 2, 3));
assert(func0(std::make_tuple(12, 6, 8, 16), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(2, 2, 2, 4));
assert(func0(std::make_tuple(20, 14, 36, 18), std::make_tuple(5, 7, 6, 9)) == std::make_tuple(4, 2, 6, 2));
return 0;
}
| O0 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 174a <_ZSt3getILm3EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ebx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 174a <_ZSt3getILm3EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ecx
mov %ebx,%eax
cltd
idiv %ecx
mov %eax,-0x1c(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 16da <_ZSt3getILm2EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ebx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 16da <_ZSt3getILm2EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%esi
mov %ebx,%eax
cltd
idiv %esi
mov %eax,-0x20(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 166a <_ZSt3getILm1EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ebx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 166a <_ZSt3getILm1EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ecx
mov %ebx,%eax
cltd
idiv %ecx
mov %eax,-0x24(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 15fa <_ZSt3getILm0EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%ebx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 15fa <_ZSt3getILm0EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_>
mov (%rax),%esi
mov %ebx,%eax
cltd
idiv %esi
mov %eax,-0x28(%rbp)
lea -0x1c(%rbp),%rdi
lea -0x20(%rbp),%rcx
lea -0x24(%rbp),%rdx
lea -0x28(%rbp),%rsi
mov -0x38(%rbp),%rax
mov %rdi,%r8
mov %rax,%rdi
callq 17b6 <_ZNSt5tupleIJiiiiEEC1IJiiiiELb1EEEDpOT_>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1275 <_Z5func0RKSt5tupleIJiiiiEES2_+0xec>
callq 1080 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm3EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<3ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ebx, [rax]
mov rax, [rbp+var_48]
mov rdi, rax
call _ZSt3getILm3EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<3ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ecx, [rax]
mov eax, ebx
cdq
idiv ecx
mov [rbp+var_1C], eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm2EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<2ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ebx, [rax]
mov rax, [rbp+var_48]
mov rdi, rax
call _ZSt3getILm2EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<2ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov esi, [rax]
mov eax, ebx
cdq
idiv esi
mov [rbp+var_20], eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm1EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<1ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ebx, [rax]
mov rax, [rbp+var_48]
mov rdi, rax
call _ZSt3getILm1EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<1ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ecx, [rax]
mov eax, ebx
cdq
idiv ecx
mov [rbp+var_24], eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm0EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<0ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov ebx, [rax]
mov rax, [rbp+var_48]
mov rdi, rax
call _ZSt3getILm0EJiiiiEERKNSt13tuple_elementIXT_ESt5tupleIJDpT0_EEE4typeERKS4_; std::get<0ul,int,int,int,int>(std::tuple<int,int,int,int> const&)
mov esi, [rax]
mov eax, ebx
cdq
idiv esi
mov [rbp+var_28], eax
lea rdi, [rbp+var_1C]
lea rcx, [rbp+var_20]
lea rdx, [rbp+var_24]
lea rsi, [rbp+var_28]
mov rax, [rbp+var_38]
mov r8, rdi
mov rdi, rax
call _ZNSt5tupleIJiiiiEEC2IJiiiiELb1ELb1EEEDpOT_; std::tuple<int,int,int,int>::tuple<int,int,int,int,true,true>(int,int,int,int &&)
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_1255
call ___stack_chk_fail
loc_1255:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
_DWORD *v4; // rax
long long v5; // rdx
int v6; // ebx
long long v7; // rdx
long long v8; // rsi
long long v9; // rdx
int v10; // ebx
long long v11; // rdx
_DWORD *v12; // rax
long long v13; // rdx
int v14; // ebx
long long v15; // rdx
int v19; // [rsp+28h] [rbp-28h] BYREF
int v20; // [rsp+2Ch] [rbp-24h] BYREF
int v21; // [rsp+30h] [rbp-20h] BYREF
int v22; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v23; // [rsp+38h] [rbp-18h]
v23 = __readfsqword(0x28u);
v3 = *(_DWORD *)std::get<3ul,int,int,int,int>(a2);
v4 = (_DWORD *)std::get<3ul,int,int,int,int>(a3);
v5 = (unsigned int)(v3 >> 31);
LODWORD(v5) = v3 % *v4;
v22 = v3 / *v4;
v6 = *(_DWORD *)std::get<2ul,int,int,int,int>(a2, a2, v5);
v8 = *(unsigned int *)std::get<2ul,int,int,int,int>(a3, a2, v7);
v9 = (unsigned int)(v6 >> 31);
LODWORD(v9) = v6 % (int)v8;
v21 = v6 / (int)v8;
v10 = *(_DWORD *)std::get<1ul,int,int,int,int>(a2, v8, v9);
v12 = (_DWORD *)std::get<1ul,int,int,int,int>(a3, v8, v11);
v13 = (unsigned int)(v10 >> 31);
LODWORD(v13) = v10 % *v12;
v20 = v10 / *v12;
v14 = *(_DWORD *)std::get<0ul,int,int,int,int>(a2, v8, v13);
v19 = v14 / *(_DWORD *)std::get<0ul,int,int,int,int>(a3, v8, v15);
std::tuple<int,int,int,int>::tuple<int,int,int,int,true,true>(a1, &v19, &v20, &v21, &v22);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101604
MOV EBX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101604
MOV ECX,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001015e6
MOV EBX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001015e6
MOV ESI,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ESI
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001015c8
MOV EBX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001015c8
MOV ECX,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001015aa
MOV EBX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001015aa
MOV ESI,dword ptr [RAX]
MOV EAX,EBX
CDQ
IDIV ESI
MOV dword ptr [RBP + -0x28],EAX
LEA RDI,[RBP + -0x1c]
LEA RCX,[RBP + -0x20]
LEA RDX,[RBP + -0x24]
LEA RSI,[RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x38]
MOV R8,RDI
MOV RDI,RAX
CALL 0x00101622
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101255
CALL 0x00101070
LAB_00101255:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
tuple * func0(tuple *param_1,tuple *param_2)
{
int iVar1;
type *ptVar2;
type *ptVar3;
type *ptVar4;
type *ptVar5;
tuple *in_RDX;
long in_FS_OFFSET;
int local_30;
int local_2c;
int local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
ptVar2 = std::get<3ul,int,int,int,int>(param_2);
iVar1 = *(int *)ptVar2;
ptVar2 = std::get<3ul,int,int,int,int>(in_RDX);
local_24 = iVar1 / *(int *)ptVar2;
ptVar3 = std::get<2ul,int,int,int,int>(param_2);
iVar1 = *(int *)ptVar3;
ptVar3 = std::get<2ul,int,int,int,int>(in_RDX);
local_28 = iVar1 / *(int *)ptVar3;
ptVar4 = std::get<1ul,int,int,int,int>(param_2);
iVar1 = *(int *)ptVar4;
ptVar4 = std::get<1ul,int,int,int,int>(in_RDX);
local_2c = iVar1 / *(int *)ptVar4;
ptVar5 = std::get<0ul,int,int,int,int>(param_2);
iVar1 = *(int *)ptVar5;
ptVar5 = std::get<0ul,int,int,int,int>(in_RDX);
local_30 = iVar1 / *(int *)ptVar5;
std::tuple<int,int,int,int>::tuple<int,int,int,int,true,true>
((tuple<int,int,int,int> *)param_1,&local_30,&local_2c,&local_28,&local_24);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
1,041 | func0 | #include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
std::tuple<int, int, int, int> res(
std::get<0>(test_tup1) / std::get<0>(test_tup2),
std::get<1>(test_tup1) / std::get<1>(test_tup2),
std::get<2>(test_tup1) / std::get<2>(test_tup2),
std::get<3>(test_tup1) / std::get<3>(test_tup2)
);
return res;
}
| int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(2, 2, 2, 3));
assert(func0(std::make_tuple(12, 6, 8, 16), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(2, 2, 2, 4));
assert(func0(std::make_tuple(20, 14, 36, 18), std::make_tuple(5, 7, 6, 9)) == std::make_tuple(4, 2, 6, 2));
return 0;
}
| O1 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
mov %rdx,%rcx
mov 0x4(%rsi),%eax
cltd
idivl 0x4(%rcx)
mov %eax,%r10d
mov 0x8(%rsi),%eax
cltd
idivl 0x8(%rcx)
mov %eax,%r9d
mov 0xc(%rsi),%eax
cltd
idivl 0xc(%rcx)
mov %eax,%r8d
mov (%rsi),%eax
cltd
idivl (%rcx)
mov %eax,(%rdi)
mov %r10d,0x4(%rdi)
mov %r9d,0x8(%rdi)
mov %r8d,0xc(%rdi)
mov %rdi,%rax
retq
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
mov rcx, rdx
mov eax, [rsi+4]
cdq
idiv dword ptr [rcx+4]
mov r10d, eax
mov eax, [rsi+8]
cdq
idiv dword ptr [rcx+8]
mov r9d, eax
mov eax, [rsi+0Ch]
cdq
idiv dword ptr [rcx+0Ch]
mov r8d, eax
mov eax, [rsi]
cdq
idiv dword ptr [rcx]
mov [rdi], eax
mov [rdi+4], r10d
mov [rdi+8], r9d
mov [rdi+0Ch], r8d
mov rax, rdi
retn | int * func0(int *a1, _DWORD *a2, _DWORD *a3)
{
int v3; // r10d
int v4; // r9d
int v5; // r8d
v3 = a2[1] / a3[1];
v4 = a2[2] / a3[2];
v5 = a2[3] / a3[3];
*a1 = *a2 / *a3;
a1[1] = v3;
a1[2] = v4;
a1[3] = v5;
return a1;
} | func0:
ENDBR64
MOV RCX,RDX
MOV EAX,dword ptr [RSI + 0x4]
CDQ
IDIV dword ptr [RCX + 0x4]
MOV R10D,EAX
MOV EAX,dword ptr [RSI + 0x8]
CDQ
IDIV dword ptr [RCX + 0x8]
MOV R9D,EAX
MOV EAX,dword ptr [RSI + 0xc]
CDQ
IDIV dword ptr [RCX + 0xc]
MOV R8D,EAX
MOV EAX,dword ptr [RSI]
CDQ
IDIV dword ptr [RCX]
MOV dword ptr [RDI],EAX
MOV dword ptr [RDI + 0x4],R10D
MOV dword ptr [RDI + 0x8],R9D
MOV dword ptr [RDI + 0xc],R8D
MOV RAX,RDI
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
int [16] func0(tuple *param_1,tuple *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int *in_RDX;
int auVar7 [16];
iVar1 = *(int *)(param_2 + 4);
iVar2 = in_RDX[1];
iVar3 = *(int *)(param_2 + 8);
iVar4 = in_RDX[2];
iVar5 = *(int *)(param_2 + 0xc);
iVar6 = in_RDX[3];
auVar7._8_8_ = (long)*(int *)param_2 % (long)*in_RDX & 0xffffffff;
*(int *)param_1 = *(int *)param_2 / *in_RDX;
*(int *)(param_1 + 4) = iVar1 / iVar2;
*(int *)(param_1 + 8) = iVar3 / iVar4;
*(int *)(param_1 + 0xc) = iVar5 / iVar6;
auVar7._0_8_ = param_1;
return auVar7;
} |
1,042 | func0 | #include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
std::tuple<int, int, int, int> res(
std::get<0>(test_tup1) / std::get<0>(test_tup2),
std::get<1>(test_tup1) / std::get<1>(test_tup2),
std::get<2>(test_tup1) / std::get<2>(test_tup2),
std::get<3>(test_tup1) / std::get<3>(test_tup2)
);
return res;
}
| int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(2, 2, 2, 3));
assert(func0(std::make_tuple(12, 6, 8, 16), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(2, 2, 2, 4));
assert(func0(std::make_tuple(20, 14, 36, 18), std::make_tuple(5, 7, 6, 9)) == std::make_tuple(4, 2, 6, 2));
return 0;
}
| O2 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
mov 0x4(%rsi),%eax
mov %rdx,%rcx
mov %rdi,%r8
cltd
idivl 0x4(%rcx)
mov %eax,%r10d
mov 0x8(%rsi),%eax
cltd
idivl 0x8(%rcx)
mov %eax,%r9d
mov 0xc(%rsi),%eax
cltd
idivl 0xc(%rcx)
mov %eax,%edi
mov (%rsi),%eax
cltd
idivl (%rcx)
mov %r10d,0x4(%r8)
mov %r9d,0x8(%r8)
mov %edi,0xc(%r8)
mov %eax,(%r8)
mov %r8,%rax
retq
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
mov eax, [rsi]
mov rcx, rdx
mov r9, rdi
cdq
idiv dword ptr [rcx]
mov edi, eax
mov eax, [rsi+4]
movd xmm0, edi
cdq
idiv dword ptr [rcx+4]
mov r10d, eax
mov eax, [rsi+8]
movd xmm3, r10d
cdq
punpckldq xmm0, xmm3
idiv dword ptr [rcx+8]
mov r8d, eax
mov eax, [rsi+0Ch]
movd xmm1, r8d
cdq
idiv dword ptr [rcx+0Ch]
movd xmm2, eax
mov rax, r9
punpckldq xmm1, xmm2
punpcklqdq xmm0, xmm1
movups xmmword ptr [r9], xmm0
retn | __m128i * func0(__m128i *a1, _DWORD *a2, _DWORD *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_unpacklo_epi64(
_mm_unpacklo_epi32(_mm_cvtsi32_si128(*a2 / *a3), _mm_cvtsi32_si128(a2[1] / a3[1])),
_mm_unpacklo_epi32(_mm_cvtsi32_si128(a2[2] / a3[2]), _mm_cvtsi32_si128(a2[3] / a3[3])));
return result;
} | func0:
ENDBR64
MOV EAX,dword ptr [RSI]
MOV RCX,RDX
MOV R9,RDI
CDQ
IDIV dword ptr [RCX]
MOV EDI,EAX
MOV EAX,dword ptr [RSI + 0x4]
MOVD XMM0,EDI
CDQ
IDIV dword ptr [RCX + 0x4]
MOV R10D,EAX
MOV EAX,dword ptr [RSI + 0x8]
MOVD XMM3,R10D
CDQ
PUNPCKLDQ XMM0,XMM3
IDIV dword ptr [RCX + 0x8]
MOV R8D,EAX
MOV EAX,dword ptr [RSI + 0xc]
MOVD XMM1,R8D
CDQ
IDIV dword ptr [RCX + 0xc]
MOVD XMM2,EAX
MOV RAX,R9
PUNPCKLDQ XMM1,XMM2
PUNPCKLQDQ XMM0,XMM1
MOVUPS xmmword ptr [R9],XMM0
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
int [16] func0(tuple *param_1,tuple *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int *in_RDX;
int auVar5 [16];
iVar1 = *(int *)(param_2 + 8);
iVar2 = in_RDX[2];
iVar3 = *(int *)(param_2 + 0xc);
iVar4 = in_RDX[3];
auVar5._8_8_ = (long)iVar3 % (long)iVar4 & 0xffffffff;
*(ulong *)param_1 = CONCAT44(*(int *)(param_2 + 4) / in_RDX[1],*(int *)param_2 / *in_RDX);
*(ulong *)(param_1 + 8) = CONCAT44(iVar3 / iVar4,iVar1 / iVar2);
auVar5._0_8_ = param_1;
return auVar5;
} |
1,043 | func0 | #include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
std::tuple<int, int, int, int> res(
std::get<0>(test_tup1) / std::get<0>(test_tup2),
std::get<1>(test_tup1) / std::get<1>(test_tup2),
std::get<2>(test_tup1) / std::get<2>(test_tup2),
std::get<3>(test_tup1) / std::get<3>(test_tup2)
);
return res;
}
| int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(2, 2, 2, 3));
assert(func0(std::make_tuple(12, 6, 8, 16), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(2, 2, 2, 4));
assert(func0(std::make_tuple(20, 14, 36, 18), std::make_tuple(5, 7, 6, 9)) == std::make_tuple(4, 2, 6, 2));
return 0;
}
| O3 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
mov 0x4(%rsi),%eax
mov %rdx,%rcx
mov %rdi,%r8
cltd
idivl 0x4(%rcx)
mov %eax,%r10d
mov 0x8(%rsi),%eax
cltd
idivl 0x8(%rcx)
mov %eax,%r9d
mov 0xc(%rsi),%eax
cltd
idivl 0xc(%rcx)
mov %eax,%edi
mov (%rsi),%eax
cltd
idivl (%rcx)
mov %r10d,0x4(%r8)
mov %r9d,0x8(%r8)
mov %edi,0xc(%r8)
mov %eax,(%r8)
mov %r8,%rax
retq
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
mov eax, [rsi]
mov rcx, rdx
mov r9, rdi
cdq
idiv dword ptr [rcx]
mov edi, eax
mov eax, [rsi+4]
movd xmm0, edi
cdq
idiv dword ptr [rcx+4]
mov r10d, eax
mov eax, [rsi+8]
movd xmm3, r10d
cdq
punpckldq xmm0, xmm3
idiv dword ptr [rcx+8]
mov r8d, eax
mov eax, [rsi+0Ch]
movd xmm1, r8d
cdq
idiv dword ptr [rcx+0Ch]
movd xmm2, eax
mov rax, r9
punpckldq xmm1, xmm2
punpcklqdq xmm0, xmm1
movups xmmword ptr [r9], xmm0
retn | __m128i * func0(__m128i *a1, _DWORD *a2, _DWORD *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_unpacklo_epi64(
_mm_unpacklo_epi32(_mm_cvtsi32_si128(*a2 / *a3), _mm_cvtsi32_si128(a2[1] / a3[1])),
_mm_unpacklo_epi32(_mm_cvtsi32_si128(a2[2] / a3[2]), _mm_cvtsi32_si128(a2[3] / a3[3])));
return result;
} | func0:
ENDBR64
MOV EAX,dword ptr [RSI]
MOV RCX,RDX
MOV R9,RDI
CDQ
IDIV dword ptr [RCX]
MOV EDI,EAX
MOV EAX,dword ptr [RSI + 0x4]
MOVD XMM0,EDI
CDQ
IDIV dword ptr [RCX + 0x4]
MOV R10D,EAX
MOV EAX,dword ptr [RSI + 0x8]
MOVD XMM3,R10D
CDQ
PUNPCKLDQ XMM0,XMM3
IDIV dword ptr [RCX + 0x8]
MOV R8D,EAX
MOV EAX,dword ptr [RSI + 0xc]
MOVD XMM1,R8D
CDQ
IDIV dword ptr [RCX + 0xc]
MOVD XMM2,EAX
MOV RAX,R9
PUNPCKLDQ XMM1,XMM2
PUNPCKLQDQ XMM0,XMM1
MOVUPS xmmword ptr [R9],XMM0
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
int [16] func0(tuple *param_1,tuple *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int *in_RDX;
int auVar5 [16];
iVar1 = *(int *)(param_2 + 8);
iVar2 = in_RDX[2];
iVar3 = *(int *)(param_2 + 0xc);
iVar4 = in_RDX[3];
auVar5._8_8_ = (long)iVar3 % (long)iVar4 & 0xffffffff;
*(ulong *)param_1 = CONCAT44(*(int *)(param_2 + 4) / in_RDX[1],*(int *)param_2 / *in_RDX);
*(ulong *)(param_1 + 8) = CONCAT44(iVar3 / iVar4,iVar1 / iVar2);
auVar5._0_8_ = param_1;
return auVar5;
} |
1,044 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
template <typename T>
| std::pair<std::vector<T>, std::vector<T>> func0(const std::vector<T>& list1, int L) {
std::vector<T> first_part(list1.begin(), list1.begin() + L);
std::vector<T> second_part(list1.begin() + L, list1.end());
return {first_part, second_part};
}
| int main() {
assert(func0(std::vector<int>{1, 1, 2, 3, 4, 4, 5, 1}, 3) == std::make_pair(std::vector<int>{1, 1, 2}, std::vector<int>{3, 4, 4, 5, 1}));
assert(func0(std::vector<char>{'a', 'b', 'c', 'd'}, 2) == std::make_pair(std::vector<char>{'a', 'b'}, std::vector<char>{'c', 'd'}));
assert(func0(std::vector<char>{'p', 'y', 't', 'h', 'o', 'n'}, 4) == std::make_pair(std::vector<char>{'p', 'y', 't', 'h'}, std::vector<char>{'o', 'n'}));
return 0;
}
| O0 | cpp | std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x70,%rsp
mov %rdi,-0x68(%rbp)
mov %rsi,-0x70(%rbp)
mov %edx,-0x74(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 1c70 <_ZNSaIiEC1Ev>
mov -0x74(%rbp),%eax
movslq %eax,%rbx
mov -0x70(%rbp),%rax
mov %rax,%rdi
callq 257e <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 25d6 <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEplEl>
mov %rax,%rbx
mov -0x70(%rbp),%rax
mov %rax,%rdi
callq 257e <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,%rsi
lea -0x58(%rbp),%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rcx
mov %rbx,%rdx
mov %rax,%rdi
callq 263c <_ZNSt6vectorIiSaIiEEC1IN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEET_S8_RKS0_>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 1c90 <_ZNSaIiED1Ev>
lea -0x59(%rbp),%rax
mov %rax,%rdi
callq 1c70 <_ZNSaIiEC1Ev>
mov -0x70(%rbp),%rax
mov %rax,%rdi
callq 26da <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%r12
mov -0x74(%rbp),%eax
movslq %eax,%rbx
mov -0x70(%rbp),%rax
mov %rax,%rdi
callq 257e <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x58(%rbp)
lea -0x58(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 25d6 <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEplEl>
mov %rax,%rsi
lea -0x59(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rcx
mov %r12,%rdx
mov %rax,%rdi
callq 263c <_ZNSt6vectorIiSaIiEEC1IN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEET_S8_RKS0_>
lea -0x59(%rbp),%rax
mov %rax,%rdi
callq 1c90 <_ZNSaIiED1Ev>
lea -0x30(%rbp),%rdx
lea -0x50(%rbp),%rcx
mov -0x68(%rbp),%rax
mov %rcx,%rsi
mov %rax,%rdi
callq 2732 <_ZNSt4pairISt6vectorIiSaIiEES2_EC1IRS2_S5_Lb1EEEOT_OT0_>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1d64 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1d64 <_ZNSt6vectorIiSaIiEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1f43 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x197>
jmp 1f3e <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x192>
endbr64
mov %rax,%rbx
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 1c90 <_ZNSaIiED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11e0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
lea -0x59(%rbp),%rax
mov %rax,%rdi
callq 1c90 <_ZNSaIiED1Ev>
jmp 1f27 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x17b>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1d64 <_ZNSt6vectorIiSaIiEED1Ev>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 1d64 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11e0 <_Unwind_Resume@plt>
callq 11b0 <__stack_chk_fail@plt>
mov -0x68(%rbp),%rax
add $0x70,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov [rbp+var_84], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_68]
mov [rbp+var_60], rax
nop
nop
mov eax, [rbp+var_84]
movsxd rbx, eax
mov rax, [rbp+var_80]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_30], rax
lea rax, [rbp+var_30]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator+(long)
mov rbx, rax
mov rax, [rbp+var_80]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rsi, rax
lea rdx, [rbp+var_68]
lea rax, [rbp+var_50]
mov rcx, rdx
mov rdx, rbx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2IN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEET_S8_RKS0_; std::vector<int>::vector<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::allocator<int> const&)
lea rax, [rbp+var_68]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rax, [rbp+var_69]
mov [rbp+var_58], rax
nop
nop
mov rax, [rbp+var_80]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov r12, rax
mov eax, [rbp+var_84]
movsxd rbx, eax
mov rax, [rbp+var_80]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_68], rax
lea rax, [rbp+var_68]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEplEl; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator+(long)
mov rsi, rax
lea rdx, [rbp+var_69]
lea rax, [rbp+var_30]
mov rcx, rdx
mov rdx, r12
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2IN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEET_S8_RKS0_; std::vector<int>::vector<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::allocator<int> const&)
lea rax, [rbp+var_69]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_50]
mov rax, [rbp+var_78]
mov rsi, rcx
mov rdi, rax
call _ZNSt4pairISt6vectorIiSaIiEES2_EC2IRS2_S5_Lb1EEEOT_OT0_; std::pair<std::vector<int>,std::vector<int>>::pair<std::vector<int>&,std::vector<int>&,true>(std::vector<int>&,std::vector<int>&)
nop
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz loc_1F41
jmp loc_1F3C
endbr64
mov rbx, rax
lea rax, [rbp+var_68]
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_1EE0
call ___stack_chk_fail
loc_1EE0:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
lea rax, [rbp+var_69]
mov rdi, rax
call _ZNSt15__new_allocatorIiED2Ev; std::__new_allocator<int>::~__new_allocator()
nop
jmp short loc_1F11
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_1F11:
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1F34
call ___stack_chk_fail
loc_1F34:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1F3C:
call ___stack_chk_fail
loc_1F41:
mov rax, [rbp+var_78]
sub rsp, 0FFFFFFFFFFFFFF80h
pop rbx
pop r12
pop rbp
retn | long long func0<int>(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rbx
long long v5; // rax
long long v6; // r12
long long v7; // rax
char v10; // [rsp+27h] [rbp-69h] BYREF
_QWORD v11[3]; // [rsp+28h] [rbp-68h] BYREF
_BYTE v12[32]; // [rsp+40h] [rbp-50h] BYREF
_QWORD v13[6]; // [rsp+60h] [rbp-30h] BYREF
v13[3] = __readfsqword(0x28u);
v11[1] = v11;
v3 = a3;
v13[0] = std::vector<int>::begin(a2);
v4 = __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator+(v13, v3);
v5 = std::vector<int>::begin(a2);
std::vector<int>::vector<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(v12, v5, v4, v11);
std::__new_allocator<int>::~__new_allocator(v11);
v11[2] = &v10;
v6 = std::vector<int>::end(a2);
v11[0] = std::vector<int>::begin(a2);
v7 = __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator+(v11, a3);
std::vector<int>::vector<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(v13, v7, v6, &v10);
std::__new_allocator<int>::~__new_allocator(&v10);
std::pair<std::vector<int>,std::vector<int>>::pair<std::vector<int>&,std::vector<int>&,true>(a1, v12, v13);
std::vector<int>::~vector(v13);
std::vector<int>::~vector(v12);
return a1;
} | func0<int>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV dword ptr [RBP + -0x84],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x68]
MOV qword ptr [RBP + -0x60],RAX
NOP
NOP
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,RAX
CALL 0x001025aa
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[RBP + -0x30]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x001025f6
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,RAX
CALL 0x001025aa
MOV RSI,RAX
LEA RDX,[RBP + -0x68]
LEA RAX,[RBP + -0x50]
MOV RCX,RDX
MOV RDX,RBX
MOV RDI,RAX
LAB_00101df3:
CALL 0x0010265c
LEA RAX,[RBP + -0x68]
MOV RDI,RAX
CALL 0x001023a2
NOP
LEA RAX,[RBP + -0x69]
MOV qword ptr [RBP + -0x58],RAX
NOP
NOP
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,RAX
CALL 0x00102702
MOV R12,RAX
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RDI,RAX
CALL 0x001025aa
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[RBP + -0x68]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x001025f6
MOV RSI,RAX
LEA RDX,[RBP + -0x69]
LEA RAX,[RBP + -0x30]
MOV RCX,RDX
MOV RDX,R12
MOV RDI,RAX
LAB_00101e5a:
CALL 0x0010265c
LEA RAX,[RBP + -0x69]
MOV RDI,RAX
CALL 0x001023a2
NOP
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RCX
MOV RDI,RAX
LAB_00101e7e:
CALL 0x00102752
NOP
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00101d18
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101d18
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101f41
JMP 0x00101f3c
LAB_00101f3c:
CALL 0x00101150
LAB_00101f41:
MOV RAX,qword ptr [RBP + -0x78]
SUB RSP,-0x80
POP RBX
POP R12
POP RBP
RET | /* std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > >
func0<int>(std::vector<int, std::allocator<int> > const&, int) */
pair func0<int>(vector *param_1,int param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int in_EDX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
allocator local_71;
int8 local_70;
int8 *local_68;
allocator *local_60;
vector<int,std::allocator<int>> local_58 [32];
int8 local_38 [3];
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_00000034,param_2);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_68 = &local_70;
local_38[0] = std::vector<int,std::allocator<int>>::begin(this);
_Var1 = __normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)local_38,
(long)in_EDX);
_Var2 = std::vector<int,std::allocator<int>>::begin(this);
/* try { // try from 00101df3 to 00101df7 has its CatchHandler @ 00101eb5 */
std::vector<int,std::allocator<int>>::
vector<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,void>
(local_58,_Var2,_Var1,(allocator *)&local_70);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_70);
local_60 = &local_71;
_Var1 = std::vector<int,std::allocator<int>>::end(this);
local_70 = std::vector<int,std::allocator<int>>::begin(this);
_Var2 = __normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator+
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_70
,(long)in_EDX);
/* try { // try from 00101e5a to 00101e5e has its CatchHandler @ 00101ee8 */
std::vector<int,std::allocator<int>>::
vector<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,void>
((vector<int,std::allocator<int>> *)local_38,_Var2,_Var1,&local_71);
std::__new_allocator<int>::~__new_allocator((__new_allocator<int> *)&local_71);
/* try { // try from 00101e7e to 00101e82 has its CatchHandler @ 00101efe */
std::pair<std::vector<int,std::allocator<int>>,std::vector<int,std::allocator<int>>>::
pair<std::vector<int,std::allocator<int>>&,std::vector<int,std::allocator<int>>&,true>
((pair<std::vector<int,std::allocator<int>>,std::vector<int,std::allocator<int>>> *)
param_1,(vector *)local_58,(vector *)local_38);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_38);
std::vector<int,std::allocator<int>>::~vector(local_58);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (pair)param_1;
} |
1,045 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
template <typename T>
| std::pair<std::vector<T>, std::vector<T>> func0(const std::vector<T>& list1, int L) {
std::vector<T> first_part(list1.begin(), list1.begin() + L);
std::vector<T> second_part(list1.begin() + L, list1.end());
return {first_part, second_part};
}
| int main() {
assert(func0(std::vector<int>{1, 1, 2, 3, 4, 4, 5, 1}, 3) == std::make_pair(std::vector<int>{1, 1, 2}, std::vector<int>{3, 4, 4, 5, 1}));
assert(func0(std::vector<char>{'a', 'b', 'c', 'd'}, 2) == std::make_pair(std::vector<char>{'a', 'b'}, std::vector<char>{'c', 'd'}));
assert(func0(std::vector<char>{'p', 'y', 't', 'h', 'o', 'n'}, 4) == std::make_pair(std::vector<char>{'p', 'y', 't', 'h'}, std::vector<char>{'o', 'n'}));
return 0;
}
| O1 | cpp | std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%r14
movslq %edx,%rbp
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rbp
ja 1b24 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x96>
mov %rdi,%rbx
mov %rsi,%r13
lea 0x0(,%rbp,4),%r12
movq $0x0,0x8(%rsp)
test %rbp,%rbp
je 1ade <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x50>
mov %r12,%rdi
callq 1120 <_Znwm@plt>
mov %rax,0x8(%rsp)
test %r12,%r12
je 1af3 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x65>
mov %r12,%rdx
mov %r14,%rsi
mov 0x8(%rsp),%rdi
callq 1140 <memmove@plt>
mov 0x8(%r13),%rax
mov %rax,0x18(%rsp)
mov %r12,%r14
add 0x0(%r13),%r14
sub %r14,%rax
mov %rax,%r13
mov %rax,%r15
sar $0x2,%r15
test %rax,%rax
js 1b30 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xa2>
test %r15,%r15
je 1b8a <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xfc>
mov %rax,%rdi
callq 1120 <_Znwm@plt>
jmp 1b48 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xba>
lea 0x14dd(%rip),%rdi
callq 10e0 <_ZSt20__throw_length_errorPKc@plt>
lea 0x14d1(%rip),%rdi
callq 10e0 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbx
jmpq 1c7c <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1ee>
mov %rax,0x10(%rsp)
cmp 0x18(%rsp),%r14
je 1b64 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xd6>
mov %r13,%rdx
mov %r14,%rsi
mov 0x10(%rsp),%rdi
callq 1140 <memmove@plt>
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
test %rbp,%rbp
je 1be0 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x152>
mov %r12,%rdi
callq 1120 <_Znwm@plt>
jmp 1b95 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x107>
movq $0x0,0x10(%rsp)
jmp 1b4d <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xbf>
mov %rax,%rdi
mov %rdi,(%rbx)
lea (%rdi,%r12,1),%rbp
mov %rbp,0x10(%rbx)
test %r12,%r12
je 1bb5 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x127>
mov %r12,%rdx
mov 0x8(%rsp),%rsi
callq 1100 <memcpy@plt>
mov %rbp,0x8(%rbx)
movq $0x0,0x18(%rbx)
movq $0x0,0x20(%rbx)
movq $0x0,0x28(%rbx)
test %r15,%r15
je 1c3e <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1b0>
mov %r13,%rdi
callq 1120 <_Znwm@plt>
jmp 1be7 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x159>
mov $0x0,%edi
jmp 1b98 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x10a>
mov %rax,%rdi
mov %rdi,0x18(%rbx)
mov %rdi,0x20(%rbx)
lea (%rdi,%r13,1),%rbp
mov %rbp,0x28(%rbx)
test %r13,%r13
je 1c45 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1b7>
mov %r13,%rdx
mov 0x10(%rsp),%rsi
callq 1100 <memcpy@plt>
mov %rbp,0x20(%rbx)
mov 0x10(%rsp),%rdi
callq 1110 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
test %rax,%rax
je 1c2c <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x19e>
mov %rax,%rdi
callq 1110 <_ZdlPv@plt>
mov %rbx,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%edi
jmp 1bea <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x15c>
mov %rdi,0x20(%rbx)
cmpq $0x0,0x10(%rsp)
je 1c1a <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x18c>
jmp 1c10 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x182>
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
test %rdi,%rdi
je 1c67 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1d9>
callq 1110 <_ZdlPv@plt>
mov %rbp,%rbx
cmpq $0x0,0x10(%rsp)
je 1c7c <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1ee>
mov 0x10(%rsp),%rdi
callq 1110 <_ZdlPv@plt>
cmpq $0x0,0x8(%rsp)
je 1c8e <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x200>
mov 0x8(%rsp),%rdi
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
jmp 1c6a <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1dc>
| _Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
mov r15, [rsi]
movsxd rdx, edx
lea r12, ds:0[rdx*4]
mov [rsp+98h+var_78], 0
mov [rsp+98h+var_70], 0
mov [rsp+98h+var_68], 0
mov [rsp+98h+var_90], rdx
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, r12
jb short loc_1C20
mov rbx, rdi
mov r14, rsi
cmp [rsp+98h+var_90], 0
jz loc_1F27
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1C6B
loc_1C20:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1C66
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+98h+var_78]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jz loc_1CF4
call ___stack_chk_fail
loc_1C66:
call ___stack_chk_fail
loc_1C6B:
mov r13, rax
mov [rsp+98h+var_78], rax
lea rbp, [rax+r12]
mov [rsp+98h+var_68], rbp
cmp r12, 4
jle short loc_1CEB
mov rdx, r12; n
mov rsi, r15; src
mov rdi, rax; dest
call _memmove
loc_1C90:
mov [rsp+98h+var_70], rbp
mov rbp, [r14+8]
mov rax, r12
add rax, [r14]
mov [rsp+98h+src], rax
mov [rsp+98h+var_58], 0
mov [rsp+98h+var_50], 0
mov [rsp+98h+var_48], 0
sub rbp, rax
mov r15, rbp
sar r15, 2
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb short loc_1CFC
test r15, r15
jz loc_1F01
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1D51
loc_1CEB:
mov eax, [r15]
mov [r13+0], eax
jmp short loc_1C90
loc_1CF4:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1CFC:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1D4C
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+98h+var_58]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
loc_1D29:
lea rdi, [rsp+98h+var_78]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jz loc_1EB6
call ___stack_chk_fail
loc_1D4C:
call ___stack_chk_fail
loc_1D51:
mov r14, rax
mov [rsp+98h+var_58], rax
lea rax, [rax+rbp]
mov [rsp+98h+var_80], rax
mov [rsp+98h+var_48], rax
cmp rbp, 4
jle short loc_1DB4
mov rdx, rbp; n
mov rsi, [rsp+98h+src]; src
mov rdi, r14; dest
call _memmove
loc_1D7D:
mov rax, [rsp+98h+var_80]
mov [rsp+98h+var_50], rax
mov qword ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx+10h], 0
cmp [rsp+98h+var_90], 0
jz loc_1EE4
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1DC0
loc_1DB4:
mov rax, [rsp+98h+src]
mov eax, [rax]
mov [r14], eax
jmp short loc_1D7D
loc_1DC0:
mov rdi, rax; dest
mov [rbx], rax
lea rax, [rax+r12]
mov [rsp+98h+var_90], rax
mov [rbx+10h], rax
cmp r12, 4
jle short loc_1E18
mov rdx, r12; n
mov rsi, r13; src
call _memcpy
loc_1DE4:
mov rax, [rsp+98h+var_90]
mov [rbx+8], rax
mov qword ptr [rbx+18h], 0
mov qword ptr [rbx+20h], 0
mov qword ptr [rbx+28h], 0
test r15, r15
jz loc_1EBE
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1E20
loc_1E18:
mov eax, [r13+0]
mov [rdi], eax
jmp short loc_1DE4
loc_1E20:
mov rdi, rax; dest
mov [rbx+18h], rax
lea r15, [rax+rbp]
mov [rbx+28h], r15
cmp rbp, 4
jle short loc_1E85
mov rdx, rbp; n
mov rsi, r14; src
call _memcpy
loc_1E40:
mov [rbx+20h], r15
loc_1E44:
mov rsi, rbp; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1E4F:
test r13, r13
jz short loc_1E5F
mov rsi, r12; unsigned __int64
mov rdi, r13; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1E5F:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz loc_1F49
mov rax, rbx
add rsp, 68h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1E85:
mov eax, [r14]
mov [rdi], eax
jmp short loc_1E40
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rbx, rbp
loc_1E9E:
lea rdi, [rsp+98h+var_58]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
jmp loc_1D29
endbr64
mov rbx, rax
jmp short loc_1E9E
loc_1EB6:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1EBE:
mov qword ptr [rbx+18h], 0
mov qword ptr [rbx+28h], 0
mov qword ptr [rbx+20h], 0
test r14, r14
jz loc_1E4F
jmp loc_1E44
loc_1EE4:
mov qword ptr [rbx], 0
mov qword ptr [rbx+10h], 0
mov [rsp+98h+var_90], 0
jmp loc_1DE4
loc_1F01:
mov [rsp+98h+var_58], 0
mov [rsp+98h+var_48], 0
mov [rsp+98h+var_80], 0
mov r14d, 0
jmp loc_1D7D
loc_1F27:
mov [rsp+98h+var_78], 0
mov [rsp+98h+var_68], 0
mov ebp, 0
mov r13d, 0
jmp loc_1C90
loc_1F49:
call ___stack_chk_fail | _QWORD * func0<int>(_QWORD *a1, long long a2, int a3)
{
_DWORD *v3; // r15
signed long long v4; // r12
_DWORD *v5; // rax
_DWORD *v6; // r13
signed long long v7; // rbp
long long v8; // r15
_DWORD *v9; // rax
_DWORD *v10; // r14
_DWORD *v11; // rax
_DWORD *v12; // rax
char *v13; // r15
long long v15; // [rsp+8h] [rbp-90h]
_DWORD *v16; // [rsp+8h] [rbp-90h]
_DWORD *src; // [rsp+10h] [rbp-88h]
v3 = *(_DWORD **)a2;
v4 = a3;
v15 = a3;
if ( (unsigned long long)v4 > 0x1FFFFFFFFFFFFFFFLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a3 )
{
v5 = (_DWORD *)operator new(4LL * a3);
v6 = v5;
if ( v4 <= 1 )
*v5 = *v3;
else
memmove(v5, v3, v4 * 4);
}
else
{
v6 = 0LL;
}
src = (_DWORD *)(*(_QWORD *)a2 + v4 * 4);
v7 = *(_QWORD *)(a2 + 8) - (_QWORD)src;
v8 = v7 >> 2;
if ( (unsigned long long)v7 > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v8 )
{
v9 = (_DWORD *)operator new(v7);
v10 = v9;
if ( v7 <= 4 )
*v9 = *src;
else
memmove(v9, src, v7);
}
else
{
v10 = 0LL;
}
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( v15 )
{
v11 = (_DWORD *)operator new(v4 * 4);
*a1 = v11;
v16 = &v11[v4];
a1[2] = &v11[v4];
if ( v4 <= 1 )
*v11 = *v6;
else
memcpy(v11, v6, v4 * 4);
}
else
{
*a1 = 0LL;
a1[2] = 0LL;
v16 = 0LL;
}
a1[1] = v16;
a1[3] = 0LL;
a1[4] = 0LL;
a1[5] = 0LL;
if ( v8 )
{
v12 = (_DWORD *)operator new(v7);
a1[3] = v12;
v13 = (char *)v12 + v7;
a1[5] = (char *)v12 + v7;
if ( v7 <= 4 )
*v12 = *v10;
else
memcpy(v12, v10, v7);
a1[4] = v13;
goto LABEL_25;
}
a1[3] = 0LL;
a1[5] = 0LL;
a1[4] = 0LL;
if ( v10 )
LABEL_25:
operator delete(v10, v7);
if ( v6 )
operator delete(v6, v4 * 4);
return a1;
} | func0<int>:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV R15,qword ptr [RSI]
MOVSXD RDX,EDX
LEA R12,[RDX*0x4]
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,0x7ffffffffffffffc
CMP RAX,R12
JC 0x00101c20
MOV RBX,RDI
MOV R14,RSI
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00101f27
MOV RDI,R12
LAB_00101c19:
CALL 0x00101110
JMP 0x00101c6b
LAB_00101c20:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c66
LEA RDI,[0x103008]
CALL 0x001010e0
LAB_00101c3c:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x20]
CALL 0x00101abe
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101cf4
CALL 0x00101130
LAB_00101c66:
CALL 0x00101130
LAB_00101c6b:
MOV R13,RAX
MOV qword ptr [RSP + 0x20],RAX
LEA RBP,[RAX + R12*0x1]
MOV qword ptr [RSP + 0x30],RBP
CMP R12,0x4
JLE 0x00101ceb
MOV RDX,R12
MOV RSI,R15
MOV RDI,RAX
CALL 0x00101140
LAB_00101c90:
MOV qword ptr [RSP + 0x28],RBP
MOV RBP,qword ptr [R14 + 0x8]
MOV RAX,R12
ADD RAX,qword ptr [R14]
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
SUB RBP,RAX
MOV R15,RBP
SAR R15,0x2
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00101cfc
TEST R15,R15
JZ 0x00101f01
MOV RDI,RBP
LAB_00101ce4:
CALL 0x00101110
JMP 0x00101d51
LAB_00101ceb:
MOV EAX,dword ptr [R15]
MOV dword ptr [R13],EAX
JMP 0x00101c90
LAB_00101cf4:
MOV RDI,RBX
LAB_00101cf7:
CALL 0x00101150
LAB_00101cfc:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101d4c
LEA RDI,[0x103008]
LAB_00101d13:
CALL 0x001010e0
LAB_00101d18:
ENDBR64
MOV RBX,RAX
LEA RDI,[RSP + 0x40]
CALL 0x00101abe
LAB_00101d29:
LEA RDI,[RSP + 0x20]
CALL 0x001019f0
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101eb6
CALL 0x00101130
LAB_00101d4c:
CALL 0x00101130
LAB_00101d51:
MOV R14,RAX
MOV qword ptr [RSP + 0x40],RAX
LEA RAX,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x50],RAX
CMP RBP,0x4
JLE 0x00101db4
MOV RDX,RBP
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x00101140
LAB_00101d7d:
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX + 0x10],0x0
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00101ee4
MOV RDI,R12
LAB_00101dad:
CALL 0x00101110
JMP 0x00101dc0
LAB_00101db4:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [R14],EAX
JMP 0x00101d7d
LAB_00101dc0:
MOV RDI,RAX
MOV qword ptr [RBX],RAX
LEA RAX,[RAX + R12*0x1]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RBX + 0x10],RAX
CMP R12,0x4
JLE 0x00101e18
MOV RDX,R12
MOV RSI,R13
CALL 0x00101100
LAB_00101de4:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x8],RAX
MOV qword ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x20],0x0
MOV qword ptr [RBX + 0x28],0x0
TEST R15,R15
JZ 0x00101ebe
MOV RDI,RBP
LAB_00101e11:
CALL 0x00101110
JMP 0x00101e20
LAB_00101e18:
MOV EAX,dword ptr [R13]
MOV dword ptr [RDI],EAX
JMP 0x00101de4
LAB_00101e20:
MOV RDI,RAX
MOV qword ptr [RBX + 0x18],RAX
LEA R15,[RAX + RBP*0x1]
MOV qword ptr [RBX + 0x28],R15
CMP RBP,0x4
JLE 0x00101e85
MOV RDX,RBP
MOV RSI,R14
CALL 0x00101100
LAB_00101e40:
MOV qword ptr [RBX + 0x20],R15
LAB_00101e44:
MOV RSI,RBP
MOV RDI,R14
CALL 0x00101120
LAB_00101e4f:
TEST R13,R13
JZ 0x00101e5f
MOV RSI,R12
MOV RDI,R13
CALL 0x00101120
LAB_00101e5f:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101f49
MOV RAX,RBX
ADD RSP,0x68
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101e85:
MOV EAX,dword ptr [R14]
MOV dword ptr [RDI],EAX
JMP 0x00101e40
LAB_00101eb6:
MOV RDI,RBX
LAB_00101eb9:
CALL 0x00101150
LAB_00101ebe:
MOV qword ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x28],0x0
MOV qword ptr [RBX + 0x20],0x0
TEST R14,R14
JZ 0x00101e4f
JMP 0x00101e44
LAB_00101ee4:
MOV qword ptr [RBX],0x0
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RSP + 0x8],0x0
JMP 0x00101de4
LAB_00101f01:
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV R14D,0x0
JMP 0x00101d7d
LAB_00101f27:
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV EBP,0x0
MOV R13D,0x0
JMP 0x00101c90
LAB_00101f49:
CALL 0x00101130 | /* std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > >
func0<int>(std::vector<int, std::allocator<int> > const&, int) */
int8 * func0<int>(int8 *param_1,long *param_2,int param_3)
{
ulong __n;
int4 *__dest;
int4 *puVar1;
int4 *puVar2;
int8 uVar3;
long lVar4;
ulong __n_00;
long in_FS_OFFSET;
int4 *local_90;
long local_80;
int4 *local_78;
int4 *local_70;
int4 *local_68;
int4 *local_58;
long local_50;
long local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
puVar1 = (int4 *)*param_2;
lVar4 = (long)param_3;
__n = lVar4 * 4;
local_78 = (int4 *)0x0;
local_70 = (int4 *)0x0;
local_68 = (int4 *)0x0;
if (0x7ffffffffffffffc < __n) {
if (local_40 != *(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 @ 00101c19 with catch @ 00101c3c */
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_78);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (lVar4 == 0) {
local_78 = (int4 *)0x0;
local_68 = (int4 *)0x0;
puVar2 = (int4 *)0x0;
__dest = (int4 *)0x0;
}
else {
/* try { // try from 00101c19 to 00101c3b has its CatchHandler @ 00101c3c */
__dest = (int4 *)operator_new(__n);
puVar2 = __dest + lVar4;
local_78 = __dest;
local_68 = puVar2;
if ((long)__n < 5) {
*__dest = *puVar1;
}
else {
memmove(__dest,puVar1,__n);
}
}
puVar1 = (int4 *)(__n + *param_2);
local_58 = (int4 *)0x0;
local_50 = 0;
local_48 = 0;
__n_00 = param_2[1] - (long)puVar1;
local_70 = puVar2;
if (0x7ffffffffffffffc < __n_00) {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* try { // try from 00101d13 to 00101d17 has its CatchHandler @ 00101d18 */
uVar3 = std::__throw_length_error("cannot create std::vector larger than max_size()");
/* catch() { ... } // from try @ 00101ce4 with catch @ 00101d18
catch() { ... } // from try @ 00101d13 with catch @ 00101d18 */
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_58);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)&local_78);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if ((long)__n_00 >> 2 == 0) {
local_58 = (int4 *)0x0;
local_48 = 0;
local_80 = 0;
puVar2 = (int4 *)0x0;
}
else {
/* try { // try from 00101ce4 to 00101ce8 has its CatchHandler @ 00101d18 */
puVar2 = (int4 *)operator_new(__n_00);
local_80 = (long)puVar2 + __n_00;
local_58 = puVar2;
local_48 = local_80;
if ((long)__n_00 < 5) {
*puVar2 = *puVar1;
}
else {
memmove(puVar2,puVar1,__n_00);
}
}
local_50 = local_80;
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
if (lVar4 == 0) {
*param_1 = 0;
param_1[2] = 0;
local_90 = (int4 *)0x0;
}
else {
/* try { // try from 00101dad to 00101db1 has its CatchHandler @ 00101ead */
puVar1 = (int4 *)operator_new(__n);
*param_1 = puVar1;
local_90 = puVar1 + lVar4;
param_1[2] = local_90;
if ((long)__n < 5) {
*puVar1 = *__dest;
}
else {
memcpy(puVar1,__dest,__n);
}
}
param_1[1] = local_90;
param_1[3] = 0;
param_1[4] = 0;
param_1[5] = 0;
if ((long)__n_00 >> 2 == 0) {
param_1[3] = 0;
param_1[5] = 0;
param_1[4] = 0;
if (puVar2 == (int4 *)0x0) goto LAB_00101e4f;
}
else {
/* try { // try from 00101e11 to 00101e15 has its CatchHandler @ 00101e8c */
puVar1 = (int4 *)operator_new(__n_00);
param_1[3] = puVar1;
param_1[5] = (long)puVar1 + __n_00;
if ((long)__n_00 < 5) {
*puVar1 = *puVar2;
}
else {
memcpy(puVar1,puVar2,__n_00);
}
param_1[4] = (long)puVar1 + __n_00;
}
operator_delete(puVar2,__n_00);
LAB_00101e4f:
if (__dest != (int4 *)0x0) {
operator_delete(__dest,__n);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
1,046 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
template <typename T>
| std::pair<std::vector<T>, std::vector<T>> func0(const std::vector<T>& list1, int L) {
std::vector<T> first_part(list1.begin(), list1.begin() + L);
std::vector<T> second_part(list1.begin() + L, list1.end());
return {first_part, second_part};
}
| int main() {
assert(func0(std::vector<int>{1, 1, 2, 3, 4, 4, 5, 1}, 3) == std::make_pair(std::vector<int>{1, 1, 2}, std::vector<int>{3, 4, 4, 5, 1}));
assert(func0(std::vector<char>{'a', 'b', 'c', 'd'}, 2) == std::make_pair(std::vector<char>{'a', 'b'}, std::vector<char>{'c', 'd'}));
assert(func0(std::vector<char>{'p', 'y', 't', 'h', 'o', 'n'}, 4) == std::make_pair(std::vector<char>{'p', 'y', 't', 'h'}, std::vector<char>{'o', 'n'}));
return 0;
}
| O2 | cpp | std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
movslq %edx,%rbx
sub $0x28,%rsp
mov (%rsi),%r15
cmp %rax,%rbx
ja 1c57 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1d7>
mov %rdi,%r12
mov %rsi,%r14
lea 0x0(,%rbx,4),%r13
test %rbx,%rbx
je 1c20 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1a0>
mov %r13,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rbp
mov (%r14),%rax
add %r13,%rax
mov %rax,0x8(%rsp)
test %r13,%r13
je 1aeb <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x6b>
mov %r13,%rdx
mov %r15,%rsi
mov %rbp,%rdi
callq 10f0 <memcpy@plt>
mov 0x8(%r14),%rax
mov %rax,%r14
sub 0x8(%rsp),%r14
mov %rax,0x18(%rsp)
mov %r14,%rax
sar $0x2,%rax
mov %rax,0x10(%rsp)
test %r14,%r14
js 1c63 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1e3>
cmpq $0x0,0x10(%rsp)
je 1c30 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1b0>
mov %r14,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%r15
mov 0x8(%rsp),%rax
cmp %rax,0x18(%rsp)
je 1b42 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xc2>
mov %r14,%rdx
mov %rax,%rsi
mov %r15,%rdi
callq 10f0 <memcpy@plt>
movq $0x0,(%r12)
movq $0x0,0x8(%r12)
movq $0x0,0x10(%r12)
test %rbx,%rbx
je 1c40 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1c0>
mov %r13,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r13,1),%rbx
mov %rdi,(%r12)
mov %rbx,0x10(%r12)
test %r13,%r13
je 1b8d <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x10d>
mov %r13,%rdx
mov %rbp,%rsi
callq 10f0 <memcpy@plt>
cmpq $0x0,0x10(%rsp)
mov %rbx,0x8(%r12)
movq $0x0,0x18(%r12)
movq $0x0,0x20(%r12)
movq $0x0,0x28(%r12)
je 1c50 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1d0>
mov %r14,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r14,1),%rbx
mov %rdi,0x18(%r12)
mov %rbx,0x28(%r12)
test %r14,%r14
je 1c10 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x190>
mov %r14,%rdx
mov %r15,%rsi
callq 10f0 <memcpy@plt>
mov %rbx,0x20(%r12)
mov %r15,%rdi
callq 1100 <_ZdlPv@plt>
test %rbp,%rbp
je 1bfc <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x17c>
mov %rbp,%rdi
callq 1100 <_ZdlPv@plt>
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
xchg %ax,%ax
mov %rdi,0x20(%r12)
test %r15,%r15
je 1bef <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x16f>
jmp 1be7 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x167>
nopl 0x0(%rax)
lea (%r15,%r13,1),%rax
xor %ebp,%ebp
mov %rax,0x8(%rsp)
jmpq 1ad8 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x58>
xor %r15d,%r15d
jmpq 1b28 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xa8>
nopl 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1b70 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xf0>
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1bc4 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x144>
lea 0x13aa(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
lea 0x139e(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%r12
jmp 1ca6 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x226>
endbr64
mov %rax,%r12
jmp 1c99 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x219>
endbr64
mov %rax,%rbx
mov (%r12),%rdi
test %rdi,%rdi
je 1c96 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x216>
callq 1100 <_ZdlPv@plt>
mov %rbx,%r12
test %r15,%r15
je 1ca6 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x226>
mov %r15,%rdi
callq 1100 <_ZdlPv@plt>
test %rbp,%rbp
je 1cb3 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x233>
mov %rbp,%rdi
callq 1100 <_ZdlPv@plt>
mov %r12,%rdi
callq 1130 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
movsxd r12, edx
push rbp
lea r13, ds:0[r12*4]
push rbx
sub rsp, 68h
mov r15, [rsi]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
movaps [rsp+98h+var_78], xmm0
mov rax, 7FFFFFFFFFFFFFFCh
mov [rsp+98h+var_68], 0
cmp rax, r13
jb loc_1DBA
mov rbx, rdi
mov rbp, rsi
test r12, r12
jz loc_1D00
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+r13]
mov qword ptr [rsp+98h+var_78], rax
mov r14, rax
mov [rsp+98h+var_68], rcx
cmp r13, 4
jz loc_1D70
mov rsi, r15; src
mov rdx, r13; n
mov rdi, rax; dest
mov [rsp+98h+var_90], rcx
call _memmove
mov r15, [rbp+0]
mov rcx, [rsp+98h+var_90]
loc_1B63:
mov rbp, [rbp+8]
lea rax, [r15+r13]
pxor xmm0, xmm0
mov qword ptr [rsp+98h+var_78+8], rcx
mov [rsp+98h+src], rax
sub rbp, rax
movaps [rsp+98h+var_58], xmm0
mov [rsp+98h+var_48], 0
mov rax, rbp
sar rax, 2
mov [rsp+98h+var_90], rax
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbp
jb loc_1D9E
cmp [rsp+98h+var_90], 0
jz loc_1D20
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+rbp]
mov qword ptr [rsp+98h+var_58], rax
mov r15, rax
mov [rsp+98h+var_48], rcx
cmp rbp, 4
jz loc_1D60
mov rsi, [rsp+98h+src]; src
mov rdx, rbp; n
mov rdi, rax; dest
mov [rsp+98h+var_80], rcx
call _memmove
mov rcx, [rsp+98h+var_80]
loc_1BF2:
pxor xmm0, xmm0
mov qword ptr [rsp+98h+var_58+8], rcx
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm0
test r12, r12
jz loc_1CE0
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
movq xmm0, rax
lea r12, [rax+r13]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+10h], r12
movups xmmword ptr [rbx], xmm0
cmp r13, 4
jz loc_1D80
mov rdx, r13; n
mov rsi, r14; src
call _memcpy
loc_1C43:
pxor xmm0, xmm0
cmp [rsp+98h+var_90], 0
mov [rbx+8], r12
mov qword ptr [rbx+28h], 0
movups xmmword ptr [rbx+18h], xmm0
jz loc_1D40
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
movq xmm0, rax
lea r12, [rax+rbp]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+28h], r12
movups xmmword ptr [rbx+18h], xmm0
cmp rbp, 4
jz loc_1D90
mov rdx, rbp; n
mov rsi, r15; src
call _memcpy
mov [rbx+20h], r12
loc_1C9C:
mov rsi, rbp; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1CA7:
test r14, r14
jz short loc_1CB7
mov rsi, r13; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1CB7:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz loc_1E05
add rsp, 68h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1CE0:
mov qword ptr [rbx], 0
xor r12d, r12d
mov qword ptr [rbx+10h], 0
jmp loc_1C43
loc_1D00:
mov qword ptr [rsp+98h+var_78], 0
xor ecx, ecx
xor r14d, r14d
mov [rsp+98h+var_68], 0
jmp loc_1B63
loc_1D20:
mov qword ptr [rsp+98h+var_58], 0
xor ecx, ecx
xor r15d, r15d
mov [rsp+98h+var_48], 0
jmp loc_1BF2
loc_1D40:
mov qword ptr [rbx+28h], 0
test r15, r15
jz loc_1CA7
jmp loc_1C9C
loc_1D60:
mov rax, [rsp+98h+src]
mov eax, [rax]
mov [r15], eax
jmp loc_1BF2
loc_1D70:
mov eax, [r15]
mov r15, [rbp+0]
mov [r14], eax
jmp loc_1B63
loc_1D80:
mov eax, [r14]
mov [rdi], eax
jmp loc_1C43
loc_1D90:
mov eax, [r15]
mov [rdi], eax
mov [rbx+20h], r12
jmp loc_1C9C
loc_1D9E:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1E05
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1DBA:
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1E05
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1DD6:
mov rdi, rbx
mov rbx, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_1DE1:
lea rdi, [rsp+98h+var_58]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
loc_1DEB:
lea rdi, [rsp+98h+var_78]
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jz short loc_1E36
loc_1E05:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_1E1C
endbr64
mov rbx, rax
jmp short loc_1DE1
loc_1E1C:
lea rdi, [rsp+98h+var_78]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rax, [rsp+98h+var_40]
sub rax, fs:28h
jnz short loc_1E05
loc_1E36:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
jmp short loc_1E50
endbr64
mov rbp, rax
jmp short loc_1DD6
loc_1E50:
lea rdi, [rsp+98h+var_58]
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
jmp short loc_1DEB | long long func0<int>(long long a1, long long a2, int a3)
{
long long v3; // r12
size_t v4; // r13
int *v5; // r15
_DWORD *v6; // rax
_DWORD *v7; // r14
signed long long v8; // rbp
int *v9; // rax
int *v10; // r15
_DWORD *v11; // rax
_DWORD *v12; // r12
int *v13; // rax
char *v14; // r12
int v16; // eax
long long v17; // [rsp+0h] [rbp-90h]
int *src; // [rsp+8h] [rbp-88h]
v3 = a3;
v4 = a3;
v5 = *(int **)a2;
if ( v4 > 0x1FFFFFFFFFFFFFFFLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a3 )
{
v6 = (_DWORD *)operator new(4LL * a3);
v7 = v6;
if ( v4 == 1 )
{
v16 = *v5;
v5 = *(int **)a2;
*v7 = v16;
}
else
{
memmove(v6, v5, v4 * 4);
v5 = *(int **)a2;
}
}
else
{
v7 = 0LL;
}
src = &v5[v4];
v8 = *(_QWORD *)(a2 + 8) - (_QWORD)&v5[v4];
v17 = v8 >> 2;
if ( (unsigned long long)v8 > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v17 )
{
v9 = (int *)operator new(v8);
v10 = v9;
if ( v8 == 4 )
*v9 = *src;
else
memmove(v9, src, v8);
}
else
{
v10 = 0LL;
}
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v3 )
{
v11 = (_DWORD *)operator new(v4 * 4);
v12 = &v11[v4];
*(_QWORD *)(a1 + 16) = &v11[v4];
*(__m128i *)a1 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v11, (__m128i)(unsigned long long)v11);
if ( v4 == 1 )
*v11 = *v7;
else
memcpy(v11, v7, v4 * 4);
}
else
{
*(_QWORD *)a1 = 0LL;
v12 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
}
*(_QWORD *)(a1 + 8) = v12;
*(_QWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
if ( v17 )
{
v13 = (int *)operator new(v8);
v14 = (char *)v13 + v8;
*(_QWORD *)(a1 + 40) = (char *)v13 + v8;
*(__m128i *)(a1 + 24) = _mm_unpacklo_epi64((__m128i)(unsigned long long)v13, (__m128i)(unsigned long long)v13);
if ( v8 == 4 )
*v13 = *v10;
else
memcpy(v13, v10, v8);
*(_QWORD *)(a1 + 32) = v14;
goto LABEL_16;
}
*(_QWORD *)(a1 + 40) = 0LL;
if ( v10 )
LABEL_16:
operator delete(v10, v8);
if ( v7 )
operator delete(v7, v4 * 4);
return a1;
} | func0<int>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,EDX
PUSH RBP
LEA R13,[R12*0x4]
PUSH RBX
SUB RSP,0x68
MOV R15,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RAX,0x7ffffffffffffffc
MOV qword ptr [RSP + 0x30],0x0
CMP RAX,R13
JC 0x00101dba
MOV RBX,RDI
MOV RBP,RSI
TEST R12,R12
JZ 0x00101d00
MOV RDI,R13
LAB_00101b27:
CALL 0x00101110
LEA RCX,[RAX + R13*0x1]
MOV qword ptr [RSP + 0x20],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x30],RCX
CMP R13,0x4
JZ 0x00101d70
MOV RSI,R15
MOV RDX,R13
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x00101140
MOV R15,qword ptr [RBP]
MOV RCX,qword ptr [RSP + 0x8]
LAB_00101b63:
MOV RBP,qword ptr [RBP + 0x8]
LEA RAX,[R15 + R13*0x1]
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x10],RAX
SUB RBP,RAX
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
MOV RAX,RBP
SAR RAX,0x2
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBP
JC 0x00101d9e
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00101d20
MOV RDI,RBP
LAB_00101bb8:
CALL 0x00101110
LEA RCX,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x40],RAX
MOV R15,RAX
MOV qword ptr [RSP + 0x50],RCX
CMP RBP,0x4
JZ 0x00101d60
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RBP
MOV RDI,RAX
MOV qword ptr [RSP + 0x18],RCX
CALL 0x00101140
MOV RCX,qword ptr [RSP + 0x18]
LAB_00101bf2:
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x48],RCX
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM0
TEST R12,R12
JZ 0x00101ce0
MOV RDI,R13
LAB_00101c12:
CALL 0x00101110
MOVQ XMM0,RAX
LEA R12,[RAX + R13*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x10],R12
MOVUPS xmmword ptr [RBX],XMM0
CMP R13,0x4
JZ 0x00101d80
MOV RDX,R13
MOV RSI,R14
CALL 0x00101100
LAB_00101c43:
PXOR XMM0,XMM0
CMP qword ptr [RSP + 0x8],0x0
MOV qword ptr [RBX + 0x8],R12
MOV qword ptr [RBX + 0x28],0x0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
JZ 0x00101d40
MOV RDI,RBP
LAB_00101c66:
CALL 0x00101110
MOVQ XMM0,RAX
LEA R12,[RAX + RBP*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x28],R12
MOVUPS xmmword ptr [RBX + 0x18],XMM0
CMP RBP,0x4
JZ 0x00101d90
MOV RDX,RBP
MOV RSI,R15
CALL 0x00101100
MOV qword ptr [RBX + 0x20],R12
LAB_00101c9c:
MOV RSI,RBP
MOV RDI,R15
CALL 0x00101120
LAB_00101ca7:
TEST R14,R14
JZ 0x00101cb7
MOV RSI,R13
MOV RDI,R14
CALL 0x00101120
LAB_00101cb7:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101e05
ADD RSP,0x68
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101ce0:
MOV qword ptr [RBX],0x0
XOR R12D,R12D
MOV qword ptr [RBX + 0x10],0x0
JMP 0x00101c43
LAB_00101d00:
MOV qword ptr [RSP + 0x20],0x0
XOR ECX,ECX
XOR R14D,R14D
MOV qword ptr [RSP + 0x30],0x0
JMP 0x00101b63
LAB_00101d20:
MOV qword ptr [RSP + 0x40],0x0
XOR ECX,ECX
XOR R15D,R15D
MOV qword ptr [RSP + 0x50],0x0
JMP 0x00101bf2
LAB_00101d40:
MOV qword ptr [RBX + 0x28],0x0
TEST R15,R15
JZ 0x00101ca7
JMP 0x00101c9c
LAB_00101d60:
MOV RAX,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [R15],EAX
JMP 0x00101bf2
LAB_00101d70:
MOV EAX,dword ptr [R15]
MOV R15,qword ptr [RBP]
MOV dword ptr [R14],EAX
JMP 0x00101b63
LAB_00101d80:
MOV EAX,dword ptr [R14]
MOV dword ptr [RDI],EAX
JMP 0x00101c43
LAB_00101d90:
MOV EAX,dword ptr [R15]
MOV dword ptr [RDI],EAX
MOV qword ptr [RBX + 0x20],R12
JMP 0x00101c9c
LAB_00101d9e:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101e05
LEA RDI,[0x103008]
LAB_00101db5:
CALL 0x001010e0
LAB_00101dba:
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101e05
LEA RDI,[0x103008]
LAB_00101dd1:
CALL 0x001010e0
LAB_00101dd6:
MOV RDI,RBX
MOV RBX,RBP
CALL 0x001018e0
LAB_00101de1:
LEA RDI,[RSP + 0x40]
CALL 0x001018e0
LAB_00101deb:
LEA RDI,[RSP + 0x20]
CALL 0x001018e0
MOV RAX,qword ptr [RSP + 0x58]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101e36
LAB_00101e05:
CALL 0x00101130
LAB_00101e36:
MOV RDI,RBX
LAB_00101e39:
CALL 0x00101150 | /* std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > >
func0<int>(std::vector<int, std::allocator<int> > const&, int) */
vector<int,std::allocator<int>> *
func0<int>(vector<int,std::allocator<int>> *param_1,int8 *param_2,int param_3)
{
ulong __n;
int4 uVar1;
int4 *__dest;
int4 *puVar2;
int4 *__dest_00;
int4 *puVar3;
long lVar4;
vector<int,std::allocator<int>> *unaff_RBX;
ulong unaff_RBP;
long lVar5;
long in_FS_OFFSET;
int local_78 [16];
int4 *local_68;
int local_58 [16];
long local_48;
long local_40;
lVar5 = (long)param_3;
__n = lVar5 * 4;
puVar3 = (int4 *)*param_2;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = (int [16])0x0;
local_68 = (int4 *)0x0;
if (__n < 0x7ffffffffffffffd) {
if (lVar5 == 0) {
local_78._0_8_ = (int4 *)0x0;
puVar2 = (int4 *)0x0;
__dest = (int4 *)0x0;
local_68 = (int4 *)0x0;
}
else {
/* try { // try from 00101b27 to 00101b2b has its CatchHandler @ 00101e0a */
__dest = (int4 *)operator_new(__n);
puVar2 = __dest + lVar5;
local_78._0_8_ = __dest;
local_68 = puVar2;
if (__n == 4) {
uVar1 = *puVar3;
puVar3 = (int4 *)*param_2;
*__dest = uVar1;
}
else {
memmove(__dest,puVar3,__n);
puVar3 = (int4 *)*param_2;
}
}
puVar3 = puVar3 + lVar5;
local_78._8_8_ = puVar2;
unaff_RBP = param_2[1] - (long)puVar3;
local_58 = (int [16])0x0;
local_48 = 0;
if (unaff_RBP < 0x7ffffffffffffffd) {
if ((long)unaff_RBP >> 2 == 0) {
local_58._0_8_ = (int4 *)0x0;
lVar4 = 0;
puVar2 = (int4 *)0x0;
local_48 = 0;
}
else {
/* try { // try from 00101bb8 to 00101bbc has its CatchHandler @ 00101e3e */
puVar2 = (int4 *)operator_new(unaff_RBP);
lVar4 = (long)puVar2 + unaff_RBP;
local_58._0_8_ = puVar2;
local_48 = lVar4;
if (unaff_RBP == 4) {
*puVar2 = *puVar3;
}
else {
memmove(puVar2,puVar3,unaff_RBP);
}
}
local_58._8_8_ = lVar4;
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (lVar5 == 0) {
*(int8 *)param_1 = 0;
puVar3 = (int4 *)0x0;
*(int8 *)(param_1 + 0x10) = 0;
}
else {
/* try { // try from 00101c12 to 00101c16 has its CatchHandler @ 00101e13 */
__dest_00 = (int4 *)operator_new(__n);
puVar3 = __dest_00 + lVar5;
*(int4 **)(param_1 + 0x10) = puVar3;
*(int4 **)param_1 = __dest_00;
*(int4 **)(param_1 + 8) = __dest_00;
if (__n == 4) {
*__dest_00 = *__dest;
}
else {
memcpy(__dest_00,__dest,__n);
}
}
*(int4 **)(param_1 + 8) = puVar3;
*(int8 *)(param_1 + 0x28) = 0;
*(int (*) [16])(param_1 + 0x18) = (int [16])0x0;
if ((long)unaff_RBP >> 2 == 0) {
*(int8 *)(param_1 + 0x28) = 0;
if (puVar2 != (int4 *)0x0) goto LAB_00101c9c;
}
else {
/* try { // try from 00101c66 to 00101c6a has its CatchHandler @ 00101e47 */
puVar3 = (int4 *)operator_new(unaff_RBP);
lVar5 = (long)puVar3 + unaff_RBP;
*(long *)(param_1 + 0x28) = lVar5;
*(int4 **)(param_1 + 0x18) = puVar3;
*(int4 **)(param_1 + 0x20) = puVar3;
if (unaff_RBP == 4) {
*puVar3 = *puVar2;
*(long *)(param_1 + 0x20) = lVar5;
}
else {
memcpy(puVar3,puVar2,unaff_RBP);
*(long *)(param_1 + 0x20) = lVar5;
}
LAB_00101c9c:
operator_delete(puVar2,unaff_RBP);
}
if (__dest != (int4 *)0x0) {
operator_delete(__dest,__n);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
goto LAB_00101e05;
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_00101e05;
/* try { // try from 00101db5 to 00101db9 has its CatchHandler @ 00101e3e */
std::__throw_length_error("cannot create std::vector larger than max_size()");
unaff_RBX = param_1;
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 00101dd1 to 00101dd5 has its CatchHandler @ 00101e0a */
std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<int,std::allocator<int>>::~vector(unaff_RBX);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_58);
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)local_78);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(unaff_RBP);
}
}
LAB_00101e05:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,047 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
template <typename T>
| std::pair<std::vector<T>, std::vector<T>> func0(const std::vector<T>& list1, int L) {
std::vector<T> first_part(list1.begin(), list1.begin() + L);
std::vector<T> second_part(list1.begin() + L, list1.end());
return {first_part, second_part};
}
| int main() {
assert(func0(std::vector<int>{1, 1, 2, 3, 4, 4, 5, 1}, 3) == std::make_pair(std::vector<int>{1, 1, 2}, std::vector<int>{3, 4, 4, 5, 1}));
assert(func0(std::vector<char>{'a', 'b', 'c', 'd'}, 2) == std::make_pair(std::vector<char>{'a', 'b'}, std::vector<char>{'c', 'd'}));
assert(func0(std::vector<char>{'p', 'y', 't', 'h', 'o', 'n'}, 4) == std::make_pair(std::vector<char>{'p', 'y', 't', 'h'}, std::vector<char>{'o', 'n'}));
return 0;
}
| O3 | cpp | std::pair<std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
movslq %edx,%rbx
sub $0x28,%rsp
mov (%rsi),%r15
cmp %rax,%rbx
ja 1b77 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1d7>
mov %rdi,%r12
mov %rsi,%r14
lea 0x0(,%rbx,4),%r13
test %rbx,%rbx
je 1b40 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1a0>
mov %r13,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rbp
mov (%r14),%rax
add %r13,%rax
mov %rax,0x8(%rsp)
test %r13,%r13
je 1a0b <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x6b>
mov %r13,%rdx
mov %r15,%rsi
mov %rbp,%rdi
callq 10f0 <memcpy@plt>
mov 0x8(%r14),%rax
mov %rax,%r14
sub 0x8(%rsp),%r14
mov %rax,0x18(%rsp)
mov %r14,%rax
sar $0x2,%rax
mov %rax,0x10(%rsp)
test %r14,%r14
js 1b83 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1e3>
cmpq $0x0,0x10(%rsp)
je 1b50 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1b0>
mov %r14,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%r15
mov 0x8(%rsp),%rax
cmp %rax,0x18(%rsp)
je 1a62 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xc2>
mov %r14,%rdx
mov %rax,%rsi
mov %r15,%rdi
callq 10f0 <memcpy@plt>
movq $0x0,0x10(%r12)
pxor %xmm0,%xmm0
movups %xmm0,(%r12)
test %rbx,%rbx
je 1b60 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1c0>
mov %r13,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r13,1),%rbx
mov %rdi,(%r12)
mov %rbx,0x10(%r12)
test %r13,%r13
je 1aa5 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x105>
mov %r13,%rdx
mov %rbp,%rsi
callq 10f0 <memcpy@plt>
pxor %xmm0,%xmm0
cmpq $0x0,0x10(%rsp)
mov %rbx,0x8(%r12)
movq $0x0,0x28(%r12)
movups %xmm0,0x18(%r12)
je 1b70 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x1d0>
mov %r14,%rdi
callq 1110 <_Znwm@plt>
mov %rax,%rdi
movq %rdi,%xmm0
lea (%rdi,%r14,1),%rbx
punpcklqdq %xmm0,%xmm0
mov %rbx,0x28(%r12)
movups %xmm0,0x18(%r12)
test %r14,%r14
je 1b30 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x190>
mov %r14,%rdx
mov %r15,%rsi
callq 10f0 <memcpy@plt>
mov %rbx,0x20(%r12)
mov %r15,%rdi
callq 1100 <_ZdlPv@plt>
test %rbp,%rbp
je 1b16 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x176>
mov %rbp,%rdi
callq 1100 <_ZdlPv@plt>
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
mov %rdi,0x20(%r12)
test %r15,%r15
je 1b09 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x169>
jmp 1b01 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x161>
nopl 0x0(%rax)
lea (%r15,%r13,1),%rax
xor %ebp,%ebp
mov %rax,0x8(%rsp)
jmpq 19f8 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x58>
xor %r15d,%r15d
jmpq 1a48 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xa8>
nopl 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1a88 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0xe8>
nopw 0x0(%rax,%rax,1)
xor %edi,%edi
jmpq 1ad4 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x134>
lea 0x48a(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
lea 0x47e(%rip),%rdi
callq 10d0 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%r12
jmp 1bc6 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x226>
endbr64
mov %rax,%r12
jmp 1bb9 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x219>
endbr64
mov %rax,%rbx
mov (%r12),%rdi
test %rdi,%rdi
je 1bb6 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x216>
callq 1100 <_ZdlPv@plt>
mov %rbx,%r12
test %r15,%r15
je 1bc6 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x226>
mov %r15,%rdi
callq 1100 <_ZdlPv@plt>
test %rbp,%rbp
je 1bd3 <_Z5func0IiESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i+0x233>
mov %rbp,%rdi
callq 1100 <_ZdlPv@plt>
mov %r12,%rdi
callq 1130 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0IcESt4pairISt6vectorIT_SaIS2_EES4_ERKS4_i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
movsxd rbp, edx
push rbx
sub rsp, 58h
mov r13, [rsi]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
movaps [rsp+88h+var_78], xmm0
mov [rsp+88h+var_68], 0
test rbp, rbp
js loc_2007
mov rbx, rdi
mov r12, rsi
jz loc_1F60
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
lea r15, [rax+rbp]
mov qword ptr [rsp+88h+var_78], rax
mov r14, rax
mov [rsp+88h+var_68], r15
cmp rbp, 1
jz loc_1FD0
mov rsi, r13; src
mov rdx, rbp; n
mov rdi, rax; dest
call _memmove
mov r13, [r12]
loc_1DF4:
mov r12, [r12+8]
pxor xmm0, xmm0
add r13, rbp
mov qword ptr [rsp+88h+var_78+8], r15
mov [rsp+88h+var_48], 0
movaps [rsp+88h+var_58], xmm0
sub r12, r13
js loc_2023
jz loc_1F80
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+r12]
mov qword ptr [rsp+88h+var_58], rax
mov r15, rax
mov [rsp+88h+var_48], rcx
cmp r12, 1
jz loc_1FC0
mov rdx, r12; n
mov rsi, r13; src
mov rdi, rax; dest
mov [rsp+88h+var_80], rcx
call _memmove
mov rcx, [rsp+88h+var_80]
loc_1E5D:
pxor xmm0, xmm0
mov qword ptr [rsp+88h+var_58+8], rcx
mov qword ptr [rbx+10h], 0
movups xmmword ptr [rbx], xmm0
test rbp, rbp
jz loc_1F48
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
movq xmm0, rax
lea r13, [rax+rbp]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+10h], r13
movups xmmword ptr [rbx], xmm0
cmp rbp, 1
jz loc_1FE8
mov rdx, rbp; n
mov rsi, r14; src
call _memcpy
loc_1EAE:
pxor xmm0, xmm0
mov [rbx+8], r13
mov qword ptr [rbx+28h], 0
movups xmmword ptr [rbx+18h], xmm0
test r12, r12
jz loc_1FA0
mov rdi, r12; unsigned __int64
call __Znwm; operator new(ulong)
movq xmm0, rax
lea r13, [rax+r12]
mov rdi, rax; dest
punpcklqdq xmm0, xmm0
mov [rbx+28h], r13
movups xmmword ptr [rbx+18h], xmm0
cmp r12, 1
jz loc_1FF8
mov rdx, r12; n
mov rsi, r15; src
call _memcpy
mov [rbx+20h], r13
loc_1F04:
mov rsi, r12; unsigned __int64
mov rdi, r15; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1F0F:
test r14, r14
jz short loc_1F1F
mov rsi, rbp; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1F1F:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_206E
add rsp, 58h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1F48:
mov qword ptr [rbx], 0
xor r13d, r13d
mov qword ptr [rbx+10h], 0
jmp loc_1EAE
loc_1F60:
mov qword ptr [rsp+88h+var_78], 0
xor r15d, r15d
xor r14d, r14d
mov [rsp+88h+var_68], 0
jmp loc_1DF4
loc_1F80:
mov qword ptr [rsp+88h+var_58], 0
xor ecx, ecx
xor r15d, r15d
mov [rsp+88h+var_48], 0
jmp loc_1E5D
loc_1FA0:
mov qword ptr [rbx+28h], 0
test r15, r15
jz loc_1F0F
jmp loc_1F04
loc_1FC0:
movzx eax, byte ptr [r13+0]
mov [r15], al
jmp loc_1E5D
loc_1FD0:
movzx eax, byte ptr [r13+0]
mov r13, [r12]
mov [r14], al
jmp loc_1DF4
loc_1FE8:
movzx eax, byte ptr [r14]
mov [rdi], al
jmp loc_1EAE
loc_1FF8:
movzx eax, byte ptr [r15]
mov [rdi], al
mov [rbx+20h], r13
jmp loc_1F04
loc_2007:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_206E
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_2023:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_206E
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_203F:
mov rdi, rbx
mov rbx, rbp
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
loc_204A:
lea rdi, [rsp+88h+var_58]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
loc_2054:
lea rdi, [rsp+88h+var_78]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jz short loc_208E
loc_206E:
call ___stack_chk_fail
endbr64
mov rbp, rax
jmp short loc_203F
endbr64
mov rbx, rax
jmp short loc_204A
endbr64
mov rbx, rax
jmp short loc_2054
loc_208E:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<char>(long long a1, long long a2, int a3)
{
size_t v3; // rbp
char *v4; // r13
_BYTE *v5; // rax
_BYTE *v6; // r14
char *v7; // r13
signed long long v8; // r12
char *v9; // rax
char *v10; // r15
_BYTE *v11; // rax
_BYTE *v12; // r13
char *v13; // rax
char *v14; // r13
char v16; // al
v3 = a3;
v4 = *(char **)a2;
if ( a3 < 0LL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( a3 )
{
v5 = (_BYTE *)operator new(a3);
v6 = v5;
if ( v3 == 1 )
{
v16 = *v4;
v4 = *(char **)a2;
*v6 = v16;
}
else
{
memmove(v5, v4, v3);
v4 = *(char **)a2;
}
}
else
{
v6 = 0LL;
}
v7 = &v4[v3];
v8 = *(_QWORD *)(a2 + 8) - (_QWORD)v7;
if ( v8 < 0 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( v8 )
{
v9 = (char *)operator new(v8);
v10 = v9;
if ( v8 == 1 )
*v9 = *v7;
else
memmove(v9, v7, v8);
}
else
{
v10 = 0LL;
}
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( v3 )
{
v11 = (_BYTE *)operator new(v3);
v12 = &v11[v3];
*(_QWORD *)(a1 + 16) = &v11[v3];
*(__m128i *)a1 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v11, (__m128i)(unsigned long long)v11);
if ( v3 == 1 )
*v11 = *v6;
else
memcpy(v11, v6, v3);
}
else
{
*(_QWORD *)a1 = 0LL;
v12 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
}
*(_QWORD *)(a1 + 8) = v12;
*(_QWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
if ( v8 )
{
v13 = (char *)operator new(v8);
v14 = &v13[v8];
*(_QWORD *)(a1 + 40) = &v13[v8];
*(__m128i *)(a1 + 24) = _mm_unpacklo_epi64((__m128i)(unsigned long long)v13, (__m128i)(unsigned long long)v13);
if ( v8 == 1 )
*v13 = *v10;
else
memcpy(v13, v10, v8);
*(_QWORD *)(a1 + 32) = v14;
goto LABEL_16;
}
*(_QWORD *)(a1 + 40) = 0LL;
if ( v10 )
LABEL_16:
operator delete(v10, v8);
if ( v6 )
operator delete(v6, v3);
return a1;
} | func0<char>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,EDX
PUSH RBX
SUB RSP,0x58
MOV R13,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
TEST RBP,RBP
JS 0x00102007
MOV RBX,RDI
MOV R12,RSI
JZ 0x00101f60
MOV RDI,RBP
LAB_00101dc2:
CALL 0x00101110
LEA R15,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x10],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x20],R15
CMP RBP,0x1
JZ 0x00101fd0
MOV RSI,R13
MOV RDX,RBP
MOV RDI,RAX
CALL 0x00101140
MOV R13,qword ptr [R12]
LAB_00101df4:
MOV R12,qword ptr [R12 + 0x8]
PXOR XMM0,XMM0
ADD R13,RBP
MOV qword ptr [RSP + 0x18],R15
MOV qword ptr [RSP + 0x40],0x0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
SUB R12,R13
JS 0x00102023
JZ 0x00101f80
MOV RDI,R12
LAB_00101e25:
CALL 0x00101110
LEA RCX,[RAX + R12*0x1]
MOV qword ptr [RSP + 0x30],RAX
MOV R15,RAX
MOV qword ptr [RSP + 0x40],RCX
CMP R12,0x1
JZ 0x00101fc0
MOV RDX,R12
MOV RSI,R13
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RCX
CALL 0x00101140
MOV RCX,qword ptr [RSP + 0x8]
LAB_00101e5d:
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RBX + 0x10],0x0
MOVUPS xmmword ptr [RBX],XMM0
TEST RBP,RBP
JZ 0x00101f48
MOV RDI,RBP
LAB_00101e7d:
CALL 0x00101110
MOVQ XMM0,RAX
LEA R13,[RAX + RBP*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x10],R13
MOVUPS xmmword ptr [RBX],XMM0
CMP RBP,0x1
JZ 0x00101fe8
MOV RDX,RBP
MOV RSI,R14
CALL 0x00101100
LAB_00101eae:
PXOR XMM0,XMM0
MOV qword ptr [RBX + 0x8],R13
MOV qword ptr [RBX + 0x28],0x0
MOVUPS xmmword ptr [RBX + 0x18],XMM0
TEST R12,R12
JZ 0x00101fa0
MOV RDI,R12
LAB_00101ece:
CALL 0x00101110
MOVQ XMM0,RAX
LEA R13,[RAX + R12*0x1]
MOV RDI,RAX
PUNPCKLQDQ XMM0,XMM0
MOV qword ptr [RBX + 0x28],R13
MOVUPS xmmword ptr [RBX + 0x18],XMM0
CMP R12,0x1
JZ 0x00101ff8
MOV RDX,R12
MOV RSI,R15
CALL 0x00101100
MOV qword ptr [RBX + 0x20],R13
LAB_00101f04:
MOV RSI,R12
MOV RDI,R15
CALL 0x00101120
LAB_00101f0f:
TEST R14,R14
JZ 0x00101f1f
MOV RSI,RBP
MOV RDI,R14
CALL 0x00101120
LAB_00101f1f:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010206e
ADD RSP,0x58
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101f48:
MOV qword ptr [RBX],0x0
XOR R13D,R13D
MOV qword ptr [RBX + 0x10],0x0
JMP 0x00101eae
LAB_00101f60:
MOV qword ptr [RSP + 0x10],0x0
XOR R15D,R15D
XOR R14D,R14D
MOV qword ptr [RSP + 0x20],0x0
JMP 0x00101df4
LAB_00101f80:
MOV qword ptr [RSP + 0x30],0x0
XOR ECX,ECX
XOR R15D,R15D
MOV qword ptr [RSP + 0x40],0x0
JMP 0x00101e5d
LAB_00101fa0:
MOV qword ptr [RBX + 0x28],0x0
TEST R15,R15
JZ 0x00101f0f
JMP 0x00101f04
LAB_00101fc0:
MOVZX EAX,byte ptr [R13]
MOV byte ptr [R15],AL
JMP 0x00101e5d
LAB_00101fd0:
MOVZX EAX,byte ptr [R13]
MOV R13,qword ptr [R12]
MOV byte ptr [R14],AL
JMP 0x00101df4
LAB_00101fe8:
MOVZX EAX,byte ptr [R14]
MOV byte ptr [RDI],AL
JMP 0x00101eae
LAB_00101ff8:
MOVZX EAX,byte ptr [R15]
MOV byte ptr [RDI],AL
MOV qword ptr [RBX + 0x20],R13
JMP 0x00101f04
LAB_00102007:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010206e
LEA RDI,[0x103008]
LAB_0010201e:
CALL 0x001010e0
LAB_00102023:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010206e
LEA RDI,[0x103008]
LAB_0010203a:
CALL 0x001010e0
LAB_0010203f:
MOV RDI,RBX
MOV RBX,RBP
CALL 0x00101d40
LAB_0010204a:
LEA RDI,[RSP + 0x30]
CALL 0x00101d40
LAB_00102054:
LEA RDI,[RSP + 0x10]
CALL 0x00101d40
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010208e
LAB_0010206e:
CALL 0x00101130
LAB_0010208e:
MOV RDI,RBX
LAB_00102091:
CALL 0x00101150 | /* std::pair<std::vector<char, std::allocator<char> >, std::vector<char, std::allocator<char> > >
func0<char>(std::vector<char, std::allocator<char> > const&, int) */
pair func0<char>(vector *param_1,int param_2)
{
int uVar1;
int *__dest;
int *__dest_00;
int *puVar2;
int in_EDX;
vector *unaff_RBX;
ulong __n;
int4 in_register_00000034;
int8 *puVar3;
ulong __n_00;
int *puVar4;
long in_FS_OFFSET;
int local_78 [16];
int *local_68;
int local_58 [16];
int *local_48;
long local_40;
puVar3 = (int8 *)CONCAT44(in_register_00000034,param_2);
__n = (ulong)in_EDX;
puVar4 = (int *)*puVar3;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_78 = (int [16])0x0;
local_68 = (int *)0x0;
if ((long)__n < 0) {
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) goto LAB_0010206e;
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
else {
if (__n == 0) {
local_78._0_8_ = (int *)0x0;
puVar2 = (int *)0x0;
__dest = (int *)0x0;
local_68 = (int *)0x0;
}
else {
__dest = (int *)operator_new(__n);
puVar2 = __dest + __n;
local_78._0_8_ = __dest;
local_68 = puVar2;
if (__n == 1) {
uVar1 = *puVar4;
puVar4 = (int *)*puVar3;
*__dest = uVar1;
}
else {
memmove(__dest,puVar4,__n);
puVar4 = (int *)*puVar3;
}
}
puVar4 = puVar4 + __n;
local_78._8_8_ = puVar2;
local_48 = (int *)0x0;
local_58 = (int [16])0x0;
__n_00 = puVar3[1] - (long)puVar4;
unaff_RBX = param_1;
if (-1 < (long)__n_00) {
if (__n_00 == 0) {
local_58._0_8_ = (int *)0x0;
puVar2 = (int *)0x0;
__dest_00 = (int *)0x0;
local_48 = (int *)0x0;
}
else {
/* try { // try from 00101e25 to 00101e29 has its CatchHandler @ 00102085 */
__dest_00 = (int *)operator_new(__n_00);
puVar2 = __dest_00 + __n_00;
local_58._0_8_ = __dest_00;
local_48 = puVar2;
if (__n_00 == 1) {
*__dest_00 = *puVar4;
}
else {
memmove(__dest_00,puVar4,__n_00);
}
}
local_58._8_8_ = puVar2;
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (__n == 0) {
*(int8 *)param_1 = 0;
puVar4 = (int *)0x0;
*(int8 *)(param_1 + 0x10) = 0;
}
else {
/* try { // try from 00101e7d to 00101e81 has its CatchHandler @ 0010207c */
puVar2 = (int *)operator_new(__n);
puVar4 = puVar2 + __n;
*(int **)(param_1 + 0x10) = puVar4;
*(int **)param_1 = puVar2;
*(int **)(param_1 + 8) = puVar2;
if (__n == 1) {
*puVar2 = *__dest;
}
else {
memcpy(puVar2,__dest,__n);
}
}
*(int **)(param_1 + 8) = puVar4;
*(int8 *)(param_1 + 0x28) = 0;
*(int (*) [16])(param_1 + 0x18) = (int [16])0x0;
if (__n_00 == 0) {
*(int8 *)(param_1 + 0x28) = 0;
if (__dest_00 != (int *)0x0) goto LAB_00101f04;
}
else {
/* try { // try from 00101ece to 00101ed2 has its CatchHandler @ 00102073 */
puVar2 = (int *)operator_new(__n_00);
puVar4 = puVar2 + __n_00;
*(int **)(param_1 + 0x28) = puVar4;
*(int **)(param_1 + 0x18) = puVar2;
*(int **)(param_1 + 0x20) = puVar2;
if (__n_00 == 1) {
*puVar2 = *__dest_00;
*(int **)(param_1 + 0x20) = puVar4;
}
else {
memcpy(puVar2,__dest_00,__n_00);
*(int **)(param_1 + 0x20) = puVar4;
}
LAB_00101f04:
operator_delete(__dest_00,__n_00);
}
if (__dest != (int *)0x0) {
operator_delete(__dest,__n);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return (pair)param_1;
}
goto LAB_0010206e;
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 0010203a to 0010203e has its CatchHandler @ 00102085 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<char,std::allocator<char>>::~vector((vector<char,std::allocator<char>> *)unaff_RBX);
std::vector<char,std::allocator<char>>::~vector((vector<char,std::allocator<char>> *)local_58);
std::vector<char,std::allocator<char>>::~vector((vector<char,std::allocator<char>> *)local_78);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(__n);
}
}
LAB_0010206e:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,048 | func0 |
#include <iostream>
#include <map>
#include <assert.h>
| std::map<char, int> func0(std::map<char, int> d1, std::map<char, int> d2) {
std::map<char, int> d = d1;
d.insert(d2.begin(), d2.end());
return d;
}
| int main() {
std::map<char, int> d1 = {{'a', 100}, {'b', 200}};
std::map<char, int> d2 = {{'x', 300}, {'y', 200}};
std::map<char, int> res1 = {{'x', 300}, {'y', 200}, {'a', 100}, {'b', 200}};
assert(func0(d1, d2) == res1);
std::map<char, int> d3 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> d4 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> res2 = {{'a', 900}, {'b', 900}, {'d', 900}, {'a', 900}, {'b', 900}, {'d', 900}};
assert(func0(d3, d4) == res2);
std::map<char, int> d5 = {{'a', 10}, {'b', 20}};
std::map<char, int> d6 = {{'x', 30}, {'y', 40}};
std::map<char, int> res3 = {{'x', 30}, {'y', 40}, {'a', 10}, {'b', 20}};
assert(func0(d5, d6) == res3);
return 0;
}
| O0 | cpp | func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >, std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x30(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 205a <_ZNSt3mapIciSt4lessIcESaISt4pairIKciEEEC1ERKS6_>
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 21ac <_ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE3endEv>
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 218e <_ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE5beginEv>
mov %rax,%rcx
mov -0x28(%rbp),%rax
mov %rbx,%rdx
mov %rcx,%rsi
mov %rax,%rdi
callq 21ca <_ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE6insertISt17_Rb_tree_iteratorIS4_EEEvT_SA_>
jmp 1394 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x8b>
endbr64
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 2084 <_ZNSt3mapIciSt4lessIcESaISt4pairIKciEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1210 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 13a8 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x9f>
callq 11c0 <__stack_chk_fail@plt>
mov -0x28(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZNSt3mapIciSt4lessIcESaISt4pairIKciEEEC2ERKS6_; std::map<char,int>::map(std::map<char,int> const&)
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE3endEv; std::map<char,int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE5beginEv; std::map<char,int>::begin(void)
mov rcx, rax
mov rax, [rbp+var_18]
mov rdx, rbx
mov rsi, rcx
mov rdi, rax
call _ZNSt3mapIciSt4lessIcESaISt4pairIKciEEE6insertISt17_Rb_tree_iteratorIS4_EEEvT_SA_; std::map<char,int>::insert<std::_Rb_tree_iterator<std::pair<char const,int>>>(std::_Rb_tree_iterator<std::pair<char const,int>>,std::_Rb_tree_iterator<std::pair<char const,int>>)
jmp short loc_1365
endbr64
mov rbx, rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNSt3mapIciSt4lessIcESaISt4pairIKciEEED2Ev; std::map<char,int>::~map()
mov rax, rbx
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1365:
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
std::map<char,int>::map(a1, a2);
v3 = std::map<char,int>::end(a3);
v4 = std::map<char,int>::begin(a3);
std::map<char,int>::insert<std::_Rb_tree_iterator<std::pair<char const,int>>>(a1, v4, v3);
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 qword ptr [RBP + -0x28],RDX
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101310:
CALL 0x00101fae
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00102106
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001020e8
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RBX
MOV RSI,RCX
MOV RDI,RAX
LAB_00101340:
CALL 0x00102124
JMP 0x00101365
LAB_00101365:
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >,
std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >) */
map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *
func0(map param_1,map param_2)
{
_Rb_tree_iterator _Var1;
_Rb_tree_iterator _Var2;
map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *in_RDX;
int4 in_register_00000034;
int4 in_register_0000003c;
map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *this;
this = (map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>> *)
CONCAT44(in_register_0000003c,param_1);
std::map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>>::map
(this,(map *)CONCAT44(in_register_00000034,param_2));
_Var1 = std::map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>>::end(in_RDX);
_Var2 = std::map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>>::begin
(in_RDX);
/* try { // try from 00101340 to 00101344 has its CatchHandler @ 00101347 */
std::map<char,int,std::less<char>,std::allocator<std::pair<char_const,int>>>::
insert<std::_Rb_tree_iterator<std::pair<char_const,int>>>(this,_Var2,_Var1);
return this;
} |
1,049 | func0 |
#include <iostream>
#include <map>
#include <assert.h>
| std::map<char, int> func0(std::map<char, int> d1, std::map<char, int> d2) {
std::map<char, int> d = d1;
d.insert(d2.begin(), d2.end());
return d;
}
| int main() {
std::map<char, int> d1 = {{'a', 100}, {'b', 200}};
std::map<char, int> d2 = {{'x', 300}, {'y', 200}};
std::map<char, int> res1 = {{'x', 300}, {'y', 200}, {'a', 100}, {'b', 200}};
assert(func0(d1, d2) == res1);
std::map<char, int> d3 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> d4 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> res2 = {{'a', 900}, {'b', 900}, {'d', 900}, {'a', 900}, {'b', 900}, {'d', 900}};
assert(func0(d3, d4) == res2);
std::map<char, int> d5 = {{'a', 10}, {'b', 20}};
std::map<char, int> d6 = {{'x', 30}, {'y', 40}};
std::map<char, int> res3 = {{'x', 30}, {'y', 40}, {'a', 10}, {'b', 20}};
assert(func0(d5, d6) == res3);
return 0;
}
| O1 | cpp | func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >, std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %rdx,%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rdi,0x8(%rsp)
movl $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
lea 0x8(%rdi),%r14
mov %r14,0x18(%rdi)
mov %r14,0x20(%rdi)
movq $0x0,0x28(%rdi)
mov 0x10(%rsi),%rsi
test %rsi,%rsi
je 138a <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xa1>
mov %rdi,0x10(%rsp)
lea 0x10(%rsp),%rcx
mov %r14,%rdx
callq 1ef2 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyINS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_EPKSC_PSt18_Rb_tree_node_baseRT_>
mov %rax,%rdx
mov %rdx,%rcx
mov 0x10(%rdx),%rdx
test %rdx,%rdx
jne 135a <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x71>
mov %rcx,0x18(%rbx)
mov %rax,%rdx
mov %rdx,%rcx
mov 0x18(%rdx),%rdx
test %rdx,%rdx
jne 136d <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x84>
mov %rcx,0x20(%rbx)
mov 0x28(%r12),%rdx
mov %rdx,0x28(%rbx)
mov %rax,0x10(%rbx)
lea 0x8(%rbp),%r15
mov 0x18(%rbp),%rbp
cmp %r15,%rbp
jne 13f9 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x110>
mov 0x18(%rsp),%rax
xor %fs:0x28,%rax
jne 144c <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x163>
mov %rbx,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
movzbl 0x20(%rdx),%eax
cmp %al,0x20(%rbp)
setl %r12b
jmp 1425 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x13c>
mov %rax,%rsi
mov 0x20(%rbp),%rax
mov %rax,0x20(%rsi)
movzbl %r12b,%edi
mov %r14,%rcx
mov %r13,%rdx
callq 1120 <_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_@plt>
addq $0x1,0x28(%rbx)
mov %rbp,%rdi
callq 1150 <_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,%r15
je 1397 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xae>
lea 0x20(%rbp),%rdx
mov %r14,%rsi
mov 0x8(%rsp),%rdi
callq 2140 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_>
mov %rdx,%r13
test %rdx,%rdx
je 13e9 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x100>
test %rax,%rax
setne %r12b
cmp %rdx,%r14
sete %dil
or %dil,%r12b
je 13bd <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xd4>
mov $0x28,%edi
callq 1180 <_Znwm@plt>
jmp 13ca <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xe1>
endbr64
mov %rax,%rbp
mov 0x10(%rbx),%rsi
mov %rbx,%rdi
callq 1e44 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE8_M_eraseEPSt13_Rb_tree_nodeIS2_E>
mov %rbp,%rdi
callq 11f0 <_Unwind_Resume@plt>
callq 11a0 <__stack_chk_fail@plt>
| _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov rbp, rsi
mov rbx, rdx
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea r14, [rdi+8]
mov [rdi+18h], r14
mov [rdi+20h], r14
mov qword ptr [rdi+28h], 0
mov rsi, [rsi+10h]
test rsi, rsi
jz short loc_1345
mov [rsp+48h+var_48], rdi
mov rcx, rsp
mov rdx, r14
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyILb0ENS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_ESD_PSt18_Rb_tree_node_baseRT0_; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(std::_Rb_tree_node<std::pair<char const,int>> *,std::_Rb_tree_node_base *,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node &)
mov rdx, rax
loc_1312:
mov rcx, rdx
mov rdx, [rdx+10h]
test rdx, rdx
jnz short loc_1312
mov [r12+18h], rcx
mov rdx, rax
loc_1326:
mov rcx, rdx
mov rdx, [rdx+18h]
test rdx, rdx
jnz short loc_1326
mov [r12+20h], rcx
mov rdx, [rbp+28h]
mov [r12+28h], rdx
mov [r12+10h], rax
loc_1345:
lea r15, [rbx+8]
mov rbx, [rbx+18h]
cmp rbx, r15
jnz short loc_13B5
loc_1352:
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz loc_141B
mov rax, r12
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1378:
movzx eax, byte ptr [rdx+20h]
cmp [rbx+20h], al
setl r13b
jmp short loc_13DE
loc_1385:
mov rsi, rax
mov rax, [rbx+20h]
mov [rsi+20h], rax
movzx edi, r13b
mov rcx, r14
mov rdx, rbp
call __ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_; std::_Rb_tree_insert_and_rebalance(bool,std::_Rb_tree_node_base *,std::_Rb_tree_node_base *,std::_Rb_tree_node_base&)
add qword ptr [r12+28h], 1
loc_13A5:
mov rdi, rbx
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov rbx, rax
cmp r15, rax
jz short loc_1352
loc_13B5:
lea rdx, [rbx+20h]
mov rsi, r14
mov rdi, r12
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<char const,int>>,char const&)
mov rbp, rdx
test rdx, rdx
jz short loc_13A5
test rax, rax
setnz r13b
cmp r14, rdx
setz al
or r13b, al
jz short loc_1378
loc_13DE:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1385
endbr64
mov rbx, rax
mov rsi, [r12+10h]
mov rdi, r12
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE8_M_eraseEPSt13_Rb_tree_nodeIS2_E; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_erase(std::_Rb_tree_node<std::pair<char const,int>> *)
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_1413
call ___stack_chk_fail
loc_1413:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_141B:
call ___stack_chk_fail | long long func0(long long a1, long long a2, long long a3)
{
long long v5; // r14
long long v6; // rsi
long long v7; // rax
long long v8; // rdx
long long v9; // rcx
long long v10; // rdx
long long v11; // rcx
long long v12; // r15
long long i; // rbx
long long insert_hint_unique_pos; // rax
long long v16; // rdx
long long v17; // rbp
bool v18; // r13
long long v19; // rax
_QWORD v20[9]; // [rsp+0h] [rbp-48h] BYREF
v20[1] = __readfsqword(0x28u);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
v5 = a1 + 8;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *(_QWORD *)(a2 + 16);
if ( v6 )
{
v20[0] = a1;
v7 = std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(
a1,
v6,
a1 + 8,
v20);
v8 = v7;
do
{
v9 = v8;
v8 = *(_QWORD *)(v8 + 16);
}
while ( v8 );
*(_QWORD *)(a1 + 24) = v9;
v10 = v7;
do
{
v11 = v10;
v10 = *(_QWORD *)(v10 + 24);
}
while ( v10 );
*(_QWORD *)(a1 + 32) = v11;
*(_QWORD *)(a1 + 40) = *(_QWORD *)(a2 + 40);
*(_QWORD *)(a1 + 16) = v7;
}
v12 = a3 + 8;
for ( i = *(_QWORD *)(a3 + 24); v12 != i; i = std::_Rb_tree_increment(i) )
{
insert_hint_unique_pos = std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_get_insert_hint_unique_pos(
a1,
v5,
i + 32);
v17 = v16;
if ( v16 )
{
v18 = v5 == v16 || insert_hint_unique_pos != 0;
if ( !v18 )
v18 = *(_BYTE *)(i + 32) < *(_BYTE *)(v16 + 32);
v19 = operator new(0x28uLL);
*(_QWORD *)(v19 + 32) = *(_QWORD *)(i + 32);
std::_Rb_tree_insert_and_rebalance(v18, v19, v17, v5);
++*(_QWORD *)(a1 + 40);
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV RBP,RSI
MOV RBX,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R14,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R14
MOV qword ptr [RDI + 0x20],R14
MOV qword ptr [RDI + 0x28],0x0
MOV RSI,qword ptr [RSI + 0x10]
TEST RSI,RSI
JZ 0x00101345
MOV qword ptr [RSP],RDI
MOV RCX,RSP
MOV RDX,R14
LAB_0010130a:
CALL 0x00101dc2
MOV RDX,RAX
LAB_00101312:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x10]
TEST RDX,RDX
JNZ 0x00101312
MOV qword ptr [R12 + 0x18],RCX
MOV RDX,RAX
LAB_00101326:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x18]
TEST RDX,RDX
JNZ 0x00101326
MOV qword ptr [R12 + 0x20],RCX
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [R12 + 0x28],RDX
MOV qword ptr [R12 + 0x10],RAX
LAB_00101345:
LEA R15,[RBX + 0x8]
MOV RBX,qword ptr [RBX + 0x18]
CMP RBX,R15
JNZ 0x001013b5
LAB_00101352:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010141b
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101378:
MOVZX EAX,byte ptr [RDX + 0x20]
CMP byte ptr [RBX + 0x20],AL
SETL R13B
JMP 0x001013de
LAB_00101385:
MOV RSI,RAX
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RSI + 0x20],RAX
MOVZX EDI,R13B
MOV RCX,R14
MOV RDX,RBP
CALL 0x00101100
ADD qword ptr [R12 + 0x28],0x1
LAB_001013a5:
MOV RDI,RBX
CALL 0x00101130
MOV RBX,RAX
CMP R15,RAX
JZ 0x00101352
LAB_001013b5:
LEA RDX,[RBX + 0x20]
MOV RSI,R14
MOV RDI,R12
CALL 0x00102018
MOV RBP,RDX
TEST RDX,RDX
JZ 0x001013a5
TEST RAX,RAX
SETNZ R13B
CMP R14,RDX
SETZ AL
OR R13B,AL
JZ 0x00101378
LAB_001013de:
MOV EDI,0x28
LAB_001013e3:
CALL 0x00101140
JMP 0x00101385
LAB_0010141b:
CALL 0x00101170 | /* func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >,
std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >) */
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
* func0(map param_1,map param_2)
{
_Rb_tree_node_base *p_Var1;
_Rb_tree_node *p_Var2;
_Rb_tree_node *p_Var3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_node_base *p_Var5;
long in_RDX;
_Rb_tree_node *p_Var6;
_Rb_tree_node_base *p_Var7;
int4 in_register_00000034;
int4 in_register_0000003c;
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
*this;
bool bVar8;
long in_FS_OFFSET;
bool bVar9;
int auVar10 [16];
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
*local_48;
long local_40;
this = (_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
*)CONCAT44(in_register_0000003c,param_1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int4 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
p_Var1 = (_Rb_tree_node_base *)(this + 8);
*(_Rb_tree_node_base **)(this + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(this + 0x20) = p_Var1;
*(int8 *)(this + 0x28) = 0;
p_Var2 = *(_Rb_tree_node **)(CONCAT44(in_register_00000034,param_2) + 0x10);
if (p_Var2 != (_Rb_tree_node *)0x0) {
local_48 = this;
p_Var3 = std::
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
::
_M_copy<false,std::_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>::_Alloc_node>
(this,p_Var2,p_Var1,(_Alloc_node *)&local_48);
p_Var2 = p_Var3;
do {
p_Var6 = p_Var2;
p_Var2 = *(_Rb_tree_node **)(p_Var6 + 0x10);
} while (p_Var2 != (_Rb_tree_node *)0x0);
*(_Rb_tree_node **)(this + 0x18) = p_Var6;
p_Var2 = p_Var3;
do {
p_Var6 = p_Var2;
p_Var2 = *(_Rb_tree_node **)(p_Var6 + 0x18);
} while (p_Var2 != (_Rb_tree_node *)0x0);
*(_Rb_tree_node **)(this + 0x20) = p_Var6;
*(int8 *)(this + 0x28) = *(int8 *)(CONCAT44(in_register_00000034,param_2) + 0x28);
*(_Rb_tree_node **)(this + 0x10) = p_Var3;
}
for (p_Var4 = *(_Rb_tree_node_base **)(in_RDX + 0x18);
p_Var4 != (_Rb_tree_node_base *)(in_RDX + 8);
p_Var4 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var4)) {
auVar10 = std::
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
::_M_get_insert_hint_unique_pos
(this,(_Rb_tree_const_iterator)p_Var1,(char *)(p_Var4 + 0x20));
p_Var7 = auVar10._8_8_;
if (p_Var7 != (_Rb_tree_node_base *)0x0) {
bVar9 = auVar10._0_8_ != 0;
bVar8 = bVar9 || p_Var1 == p_Var7;
if (!bVar9 && p_Var1 != p_Var7) {
bVar8 = (char)p_Var4[0x20] < (char)p_Var7[0x20];
}
/* try { // try from 001013e3 to 001013e7 has its CatchHandler @ 001013ea */
p_Var5 = (_Rb_tree_node_base *)operator_new(0x28);
*(int8 *)(p_Var5 + 0x20) = *(int8 *)(p_Var4 + 0x20);
std::_Rb_tree_insert_and_rebalance(bVar8,p_Var5,p_Var7,p_Var1);
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
}
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
} |
1,050 | func0 |
#include <iostream>
#include <map>
#include <assert.h>
| std::map<char, int> func0(std::map<char, int> d1, std::map<char, int> d2) {
std::map<char, int> d = d1;
d.insert(d2.begin(), d2.end());
return d;
}
| int main() {
std::map<char, int> d1 = {{'a', 100}, {'b', 200}};
std::map<char, int> d2 = {{'x', 300}, {'y', 200}};
std::map<char, int> res1 = {{'x', 300}, {'y', 200}, {'a', 100}, {'b', 200}};
assert(func0(d1, d2) == res1);
std::map<char, int> d3 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> d4 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> res2 = {{'a', 900}, {'b', 900}, {'d', 900}, {'a', 900}, {'b', 900}, {'d', 900}};
assert(func0(d3, d4) == res2);
std::map<char, int> d5 = {{'a', 10}, {'b', 20}};
std::map<char, int> d6 = {{'x', 30}, {'y', 40}};
std::map<char, int> res3 = {{'x', 30}, {'y', 40}, {'a', 10}, {'b', 20}};
assert(func0(d5, d6) == res3);
return 0;
}
| O2 | cpp | func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >, std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >):
endbr64
push %r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
lea 0x8(%rdi),%rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
mov %rbx,0x18(%rdi)
mov %rbx,0x20(%rdi)
mov 0x10(%rsi),%rsi
movl $0x0,0x8(%rdi)
movq $0x0,0x28(%rdi)
test %rsi,%rsi
je 1d87 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xa7>
mov %rbx,%rdx
mov %rsp,%rcx
mov %rdi,(%rsp)
callq 1e50 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyINS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_EPKSC_PSt18_Rb_tree_node_baseRT_>
mov %rax,%rdx
nopw 0x0(%rax,%rax,1)
mov %rdx,%rcx
mov 0x10(%rdx),%rdx
test %rdx,%rdx
jne 1d50 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x70>
mov %rcx,0x18(%r12)
mov %rax,%rdx
nopl 0x0(%rax)
mov %rdx,%rcx
mov 0x18(%rdx),%rdx
test %rdx,%rdx
jne 1d68 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x88>
mov 0x28(%r13),%rdx
mov %rcx,0x20(%r12)
mov %rax,0x10(%r12)
mov %rdx,0x28(%r12)
lea 0x8(%rbp),%r13
mov 0x18(%rbp),%rbp
cmp %r13,%rbp
je 1dcd <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xed>
nopl 0x0(%rax)
lea 0x20(%rbp),%r14
mov %rbx,%rsi
mov %r12,%rdi
mov %r14,%rdx
callq 20d0 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_>
mov %rax,%rsi
test %rdx,%rdx
je 1dbd <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xdd>
mov %r14,%rcx
mov %r12,%rdi
callq 1c50 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE10_M_insert_IRKS2_NS8_11_Alloc_nodeEEESt17_Rb_tree_iteratorIS2_EPSt18_Rb_tree_node_baseSG_OT_RT0_.isra.0>
mov %rbp,%rdi
callq 1150 <_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,%r13
jne 1d98 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xb8>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1ded <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x10d>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 11a0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1200 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_.cold>
xchg %ax,%ax
| _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_:
endbr64
push r15
push r14
push r13
lea r13, [rdi+8]
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rdx
sub rsp, 18h
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rdi+18h], r13
mov [rdi+20h], r13
mov qword ptr [rdi+28h], 0
mov rdi, [rsi+10h]
test rdi, rdi
jz short loc_1E7F
mov rbp, rsi
mov rsi, r13
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyILb0ENS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_ESD_PSt18_Rb_tree_node_baseRT0__isra_0; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(std::_Rb_tree_node<std::pair<char const,int>> *,std::_Rb_tree_node_base *,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node &) [clone]
mov rdx, rax
nop word ptr [rax+rax+00h]
loc_1E48:
mov rcx, rdx
mov rdx, [rdx+10h]
test rdx, rdx
jnz short loc_1E48
mov [r12+18h], rcx
mov rdx, rax
nop dword ptr [rax+00h]
loc_1E60:
mov rcx, rdx
mov rdx, [rdx+18h]
test rdx, rdx
jnz short loc_1E60
mov rdx, [rbp+28h]
mov [r12+20h], rcx
mov [r12+10h], rax
mov [r12+28h], rdx
loc_1E7F:
lea r15, [rbx+8]
mov rbx, [rbx+18h]
cmp rbx, r15
jnz short loc_1ECB
jmp short loc_1F08
loc_1E90:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, rax
mov rax, [rbx+20h]
movzx edi, [rsp+48h+var_39]
mov rcx, r13
mov rdx, rbp
mov [rsi+20h], rax
call __ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_; std::_Rb_tree_insert_and_rebalance(bool,std::_Rb_tree_node_base *,std::_Rb_tree_node_base *,std::_Rb_tree_node_base&)
add qword ptr [r12+28h], 1
loc_1EBB:
mov rdi, rbx
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov rbx, rax
cmp r15, rax
jz short loc_1F08
loc_1ECB:
movzx r14d, byte ptr [rbx+20h]
mov rsi, r13
mov rdi, r12
mov edx, r14d
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1__isra_0; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<char const,int>>,char const&) [clone]
mov rbp, rdx
test rdx, rdx
jz short loc_1EBB
cmp r13, rdx
setz dl
test rax, rax
setnz al
or dl, al
mov [rsp+48h+var_39], dl
jnz short loc_1E90
cmp r14b, [rbp+20h]
setl [rsp+48h+var_39]
jmp short loc_1E90
loc_1F08:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
endbr64
mov rbx, rax
jmp _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6__cold; func0(std::map<char,int>,std::map<char,int>) [clone] | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r13
long long v6; // rdi
long long v7; // rax
long long v8; // rdx
long long v9; // rcx
long long v10; // rdx
long long v11; // rcx
long long v12; // rdx
long long v13; // r15
long long i; // rbx
long long v15; // rax
unsigned __int8 v16; // r14
long long insert_hint_unique_pos; // rax
long long v18; // rdx
long long v19; // rbp
bool v21; // [rsp+Fh] [rbp-39h]
v3 = a1 + 8;
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *(_QWORD *)(a2 + 16);
if ( v6 )
{
v7 = std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(
v6,
v3);
v8 = v7;
do
{
v9 = v8;
v8 = *(_QWORD *)(v8 + 16);
}
while ( v8 );
*(_QWORD *)(a1 + 24) = v9;
v10 = v7;
do
{
v11 = v10;
v10 = *(_QWORD *)(v10 + 24);
}
while ( v10 );
v12 = *(_QWORD *)(a2 + 40);
*(_QWORD *)(a1 + 32) = v11;
*(_QWORD *)(a1 + 16) = v7;
*(_QWORD *)(a1 + 40) = v12;
}
v13 = a3 + 8;
for ( i = *(_QWORD *)(a3 + 24); v13 != i; i = std::_Rb_tree_increment(i) )
{
v16 = *(_BYTE *)(i + 32);
insert_hint_unique_pos = std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_get_insert_hint_unique_pos(
a1,
v3,
v16);
v19 = v18;
if ( v18 )
{
v21 = insert_hint_unique_pos != 0 || v3 == v18;
if ( !v21 )
v21 = (char)v16 < *(_BYTE *)(v18 + 32);
v15 = operator new(0x28uLL);
*(_QWORD *)(v15 + 32) = *(_QWORD *)(i + 32);
std::_Rb_tree_insert_and_rebalance(v21, v15, v19, v3);
++*(_QWORD *)(a1 + 40);
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13,[RDI + 0x8]
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R13
MOV qword ptr [RDI + 0x20],R13
MOV qword ptr [RDI + 0x28],0x0
MOV RDI,qword ptr [RSI + 0x10]
TEST RDI,RDI
JZ 0x00101e7f
MOV RBP,RSI
MOV RSI,R13
LAB_00101e3a:
CALL 0x00101d10
MOV RDX,RAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101e48:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x10]
TEST RDX,RDX
JNZ 0x00101e48
MOV qword ptr [R12 + 0x18],RCX
MOV RDX,RAX
NOP dword ptr [RAX]
LAB_00101e60:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x18]
TEST RDX,RDX
JNZ 0x00101e60
MOV RDX,qword ptr [RBP + 0x28]
MOV qword ptr [R12 + 0x20],RCX
MOV qword ptr [R12 + 0x10],RAX
MOV qword ptr [R12 + 0x28],RDX
LAB_00101e7f:
LEA R15,[RBX + 0x8]
MOV RBX,qword ptr [RBX + 0x18]
CMP RBX,R15
JNZ 0x00101ecb
JMP 0x00101f08
LAB_00101e90:
MOV EDI,0x28
LAB_00101e95:
CALL 0x00101140
MOV RSI,RAX
MOV RAX,qword ptr [RBX + 0x20]
MOVZX EDI,byte ptr [RSP + 0xf]
MOV RCX,R13
MOV RDX,RBP
MOV qword ptr [RSI + 0x20],RAX
CALL 0x00101100
ADD qword ptr [R12 + 0x28],0x1
LAB_00101ebb:
MOV RDI,RBX
CALL 0x00101130
MOV RBX,RAX
CMP R15,RAX
JZ 0x00101f08
LAB_00101ecb:
MOVZX R14D,byte ptr [RBX + 0x20]
MOV RSI,R13
MOV RDI,R12
MOV EDX,R14D
CALL 0x00101a60
MOV RBP,RDX
TEST RDX,RDX
JZ 0x00101ebb
CMP R13,RDX
SETZ DL
TEST RAX,RAX
SETNZ AL
OR DL,AL
MOV byte ptr [RSP + 0xf],DL
JNZ 0x00101e90
CMP R14B,byte ptr [RBP + 0x20]
SETL byte ptr [RSP + 0xf]
JMP 0x00101e90
LAB_00101f08:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >,
std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >) */
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
* func0(map param_1,map param_2)
{
_Rb_tree_node_base *p_Var1;
_Rb_tree_node_base _Var2;
_Rb_tree_node *p_Var3;
int8 uVar4;
_Rb_tree_node *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
_Alloc_node *in_RDX;
_Rb_tree_node *p_Var8;
_Rb_tree_node_base *p_Var9;
int4 in_register_00000034;
int4 in_register_0000003c;
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
*this;
bool bVar10;
int auVar11 [16];
bool local_39;
this = (_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
*)CONCAT44(in_register_0000003c,param_1);
p_Var1 = (_Rb_tree_node_base *)(this + 8);
*(int4 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(_Rb_tree_node_base **)(this + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(this + 0x20) = p_Var1;
*(int8 *)(this + 0x28) = 0;
p_Var3 = *(_Rb_tree_node **)(CONCAT44(in_register_00000034,param_2) + 0x10);
if (p_Var3 != (_Rb_tree_node *)0x0) {
p_Var5 = std::
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
::
_M_copy<false,std::_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>::_Alloc_node>
(p_Var3,p_Var1,in_RDX);
p_Var3 = p_Var5;
do {
p_Var8 = p_Var3;
p_Var3 = *(_Rb_tree_node **)(p_Var8 + 0x10);
} while (p_Var3 != (_Rb_tree_node *)0x0);
*(_Rb_tree_node **)(this + 0x18) = p_Var8;
p_Var3 = p_Var5;
do {
p_Var8 = p_Var3;
p_Var3 = *(_Rb_tree_node **)(p_Var8 + 0x18);
} while (p_Var3 != (_Rb_tree_node *)0x0);
uVar4 = *(int8 *)(CONCAT44(in_register_00000034,param_2) + 0x28);
*(_Rb_tree_node **)(this + 0x20) = p_Var8;
*(_Rb_tree_node **)(this + 0x10) = p_Var5;
*(int8 *)(this + 0x28) = uVar4;
}
for (p_Var7 = *(_Rb_tree_node_base **)(in_RDX + 0x18);
p_Var7 != (_Rb_tree_node_base *)(in_RDX + 8);
p_Var7 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var7)) {
_Var2 = p_Var7[0x20];
auVar11 = std::
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
::_M_get_insert_hint_unique_pos
(this,(_Rb_tree_const_iterator)p_Var1,(char *)(ulong)(byte)_Var2);
p_Var9 = auVar11._8_8_;
if (p_Var9 != (_Rb_tree_node_base *)0x0) {
bVar10 = auVar11._0_8_ != 0;
local_39 = p_Var1 == p_Var9 || bVar10;
if (p_Var1 != p_Var9 && !bVar10) {
local_39 = (char)_Var2 < (char)p_Var9[0x20];
}
/* try { // try from 00101e95 to 00101e99 has its CatchHandler @ 00101f1a */
p_Var6 = (_Rb_tree_node_base *)operator_new(0x28);
*(int8 *)(p_Var6 + 0x20) = *(int8 *)(p_Var7 + 0x20);
std::_Rb_tree_insert_and_rebalance(local_39,p_Var6,p_Var9,p_Var1);
*(long *)(this + 0x28) = *(long *)(this + 0x28) + 1;
}
}
return this;
} |
1,051 | func0 |
#include <iostream>
#include <map>
#include <assert.h>
| std::map<char, int> func0(std::map<char, int> d1, std::map<char, int> d2) {
std::map<char, int> d = d1;
d.insert(d2.begin(), d2.end());
return d;
}
| int main() {
std::map<char, int> d1 = {{'a', 100}, {'b', 200}};
std::map<char, int> d2 = {{'x', 300}, {'y', 200}};
std::map<char, int> res1 = {{'x', 300}, {'y', 200}, {'a', 100}, {'b', 200}};
assert(func0(d1, d2) == res1);
std::map<char, int> d3 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> d4 = {{'a', 900}, {'b', 900}, {'d', 900}};
std::map<char, int> res2 = {{'a', 900}, {'b', 900}, {'d', 900}, {'a', 900}, {'b', 900}, {'d', 900}};
assert(func0(d3, d4) == res2);
std::map<char, int> d5 = {{'a', 10}, {'b', 20}};
std::map<char, int> d6 = {{'x', 30}, {'y', 40}};
std::map<char, int> res3 = {{'x', 30}, {'y', 40}, {'a', 10}, {'b', 20}};
assert(func0(d5, d6) == res3);
return 0;
}
| O3 | cpp | func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >, std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >):
endbr64
push %r15
push %r14
lea 0x8(%rdi),%r14
push %r13
mov %rsi,%r13
push %r12
mov %rdi,%r12
push %rbp
mov %rdx,%rbp
push %rbx
xor %ebx,%ebx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
mov %r14,0x18(%rdi)
mov %r14,0x20(%rdi)
mov 0x10(%rsi),%rsi
movl $0x0,0x8(%rdi)
movq $0x0,0x28(%rdi)
test %rsi,%rsi
je 1e07 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xa7>
mov %r14,%rdx
mov %rsp,%rcx
mov %rdi,(%rsp)
callq 1fb0 <_ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyINS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_EPKSC_PSt18_Rb_tree_node_baseRT_>
mov %rax,%rdx
nopl 0x0(%rax,%rax,1)
mov %rdx,%rcx
mov 0x10(%rdx),%rdx
test %rdx,%rdx
jne 1dd0 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x70>
mov %rcx,0x18(%r12)
mov %rax,%rdx
nopl 0x0(%rax)
mov %rdx,%rcx
mov 0x18(%rdx),%rdx
test %rdx,%rdx
jne 1de8 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x88>
mov 0x28(%r13),%rbx
mov %rcx,0x20(%r12)
mov %rax,0x10(%r12)
mov %rbx,0x28(%r12)
lea 0x8(%rbp),%r15
mov 0x18(%rbp),%rbp
cmp %r15,%rbp
je 1ed7 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x177>
nopl 0x0(%rax,%rax,1)
test %rbx,%rbx
je 1e34 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xd4>
mov 0x20(%r12),%r13
movzbl 0x20(%rbp),%eax
cmp %al,0x20(%r13)
jl 1e83 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x123>
mov 0x10(%r12),%r13
test %r13,%r13
je 1f10 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x1b0>
movzbl 0x20(%rbp),%esi
jmp 1e61 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x101>
nopl 0x0(%rax,%rax,1)
mov 0x10(%r13),%rax
mov $0x1,%edx
test %rax,%rax
je 1e76 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x116>
mov %rax,%r13
movzbl 0x20(%r13),%ecx
cmp %cl,%sil
jl 1e50 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xf0>
mov 0x18(%r13),%rax
xor %edx,%edx
test %rax,%rax
jne 1e5e <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xfe>
test %dl,%dl
jne 1f13 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x1b3>
cmp %cl,%sil
jle 1ec3 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x163>
mov $0x1,%ebx
cmp %r13,%r14
jne 1f00 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x1a0>
mov $0x28,%edi
callq 1180 <_Znwm@plt>
movzbl 0x20(%rbp),%edx
mov %rax,%rsi
mov 0x24(%rbp),%eax
movzbl %bl,%edi
mov %r14,%rcx
mov %dl,0x20(%rsi)
mov %r13,%rdx
mov %eax,0x24(%rsi)
callq 1120 <_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_@plt>
mov 0x28(%r12),%rax
lea 0x1(%rax),%rbx
mov %rbx,0x28(%r12)
mov %rbp,%rdi
callq 1150 <_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,%r15
jne 1e20 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xc0>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1f49 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x1e9>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
movzbl 0x20(%r13),%eax
cmp %al,0x20(%rbp)
setl %bl
jmp 1e8d <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x12d>
nopl (%rax)
mov %r14,%r13
cmp %r13,0x18(%r12)
je 1e83 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x123>
mov %r13,%rdi
callq 1190 <_ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base@plt>
movzbl 0x20(%rbp),%ecx
cmp %cl,0x20(%rax)
jl 1e83 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x123>
mov %rbp,%rdi
callq 1150 <_ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,%r15
jne 1e20 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0xc0>
jmp 1ed7 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_+0x177>
callq 11a0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1214 <_Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_.cold>
nopw 0x0(%rax,%rax,1)
| _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6_:
endbr64
push r15
xor r15d, r15d
push r14
push r13
lea r13, [rdi+8]
push r12
mov r12, rdi
push rbp
push rbx
mov rbx, rdx
sub rsp, 18h
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rdi+18h], r13
mov [rdi+20h], r13
mov qword ptr [rdi+28h], 0
mov rdi, [rsi+10h]
test rdi, rdi
jz short loc_1E0F
mov rbp, rsi
mov rsi, r13
call _ZNSt8_Rb_treeIcSt4pairIKciESt10_Select1stIS2_ESt4lessIcESaIS2_EE7_M_copyILb0ENS8_11_Alloc_nodeEEEPSt13_Rb_tree_nodeIS2_ESD_PSt18_Rb_tree_node_baseRT0__isra_0; std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(std::_Rb_tree_node<std::pair<char const,int>> *,std::_Rb_tree_node_base *,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node &) [clone]
mov rdx, rax
nop dword ptr [rax]
loc_1DD8:
mov rcx, rdx
mov rdx, [rdx+10h]
test rdx, rdx
jnz short loc_1DD8
mov [r12+18h], rcx
mov rdx, rax
nop dword ptr [rax+00h]
loc_1DF0:
mov rcx, rdx
mov rdx, [rdx+18h]
test rdx, rdx
jnz short loc_1DF0
mov r15, [rbp+28h]
mov [r12+20h], rcx
mov [r12+10h], rax
mov [r12+28h], r15
loc_1E0F:
mov rbp, [rbx+18h]
lea r14, [rbx+8]
cmp rbp, r14
jz short loc_1E84
nop dword ptr [rax+00h]
loc_1E20:
movzx ecx, byte ptr [rbp+20h]
test r15, r15
jz short loc_1EA0
mov rbx, [r12+20h]
cmp cl, [rbx+20h]
jle short loc_1EA0
loc_1E33:
mov r15d, 1
cmp r13, rbx
jnz loc_1EE8
loc_1E42:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov rsi, rax
mov rax, [rbp+20h]
movzx edi, r15b
mov rcx, r13
mov rdx, rbx
mov [rsi+20h], rax
call __ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_; std::_Rb_tree_insert_and_rebalance(bool,std::_Rb_tree_node_base *,std::_Rb_tree_node_base *,std::_Rb_tree_node_base&)
mov rax, [r12+28h]
lea r15, [rax+1]
mov [r12+28h], r15
loc_1E74:
mov rdi, rbp
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov rbp, rax
cmp r14, rax
jnz short loc_1E20
loc_1E84:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1EA0:
mov rbx, [r12+10h]
test rbx, rbx
jnz short loc_1EB3
jmp short loc_1EF8
loc_1EB0:
mov rbx, rax
loc_1EB3:
movzx edx, byte ptr [rbx+20h]
mov rax, [rbx+18h]
cmp cl, dl
cmovl rax, [rbx+10h]
setl sil
test rax, rax
jnz short loc_1EB0
test sil, sil
jnz short loc_1EFB
loc_1ED0:
cmp cl, dl
jle short loc_1E74
mov r15d, 1
cmp r13, rbx
jz loc_1E42
nop dword ptr [rax+rax+00h]
loc_1EE8:
cmp cl, [rbx+20h]
setl r15b
jmp loc_1E42
loc_1EF8:
mov rbx, r13
loc_1EFB:
cmp rbx, [r12+18h]
jz loc_1E33
mov rdi, rbx
mov [rsp+48h+var_39], cl
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
movzx ecx, [rsp+48h+var_39]
movzx edx, byte ptr [rax+20h]
jmp short loc_1ED0
endbr64
mov rbx, rax
jmp _Z5func0St3mapIciSt4lessIcESaISt4pairIKciEEES6__cold; func0(std::map<char,int>,std::map<char,int>) [clone] | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // r15
long long v4; // r13
long long v7; // rdi
long long v8; // rax
long long v9; // rdx
long long v10; // rcx
long long v11; // rdx
long long v12; // rcx
long long v13; // rbp
long long v14; // r14
char v15; // cl
long long v16; // rbx
bool v17; // r15
long long v18; // rax
char v20; // dl
long long v21; // rax
long long v22; // rax
char v23; // [rsp+Fh] [rbp-39h]
v3 = 0LL;
v4 = a1 + 8;
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *(_QWORD *)(a2 + 16);
if ( v7 )
{
v8 = std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_M_copy<false,std::_Rb_tree<char,std::pair<char const,int>,std::_Select1st<std::pair<char const,int>>,std::less<char>,std::allocator<std::pair<char const,int>>>::_Alloc_node>(
v7,
v4);
v9 = v8;
do
{
v10 = v9;
v9 = *(_QWORD *)(v9 + 16);
}
while ( v9 );
*(_QWORD *)(a1 + 24) = v10;
v11 = v8;
do
{
v12 = v11;
v11 = *(_QWORD *)(v11 + 24);
}
while ( v11 );
v3 = *(_QWORD *)(a2 + 40);
*(_QWORD *)(a1 + 32) = v12;
*(_QWORD *)(a1 + 16) = v8;
*(_QWORD *)(a1 + 40) = v3;
}
v13 = *(_QWORD *)(a3 + 24);
v14 = a3 + 8;
while ( v14 != v13 )
{
v15 = *(_BYTE *)(v13 + 32);
if ( v3 )
{
v16 = *(_QWORD *)(a1 + 32);
if ( v15 > *(char *)(v16 + 32) )
{
LABEL_10:
v17 = 1;
if ( v4 != v16 )
goto LABEL_23;
goto LABEL_11;
}
}
v16 = *(_QWORD *)(a1 + 16);
if ( v16 )
{
while ( 1 )
{
v20 = *(_BYTE *)(v16 + 32);
v21 = *(_QWORD *)(v16 + 24);
if ( v15 < v20 )
v21 = *(_QWORD *)(v16 + 16);
if ( !v21 )
break;
v16 = v21;
}
if ( v15 >= v20 )
goto LABEL_21;
}
else
{
v16 = v4;
}
if ( v16 == *(_QWORD *)(a1 + 24) )
goto LABEL_10;
v23 = *(_BYTE *)(v13 + 32);
v22 = std::_Rb_tree_decrement(v16);
v15 = v23;
v20 = *(_BYTE *)(v22 + 32);
LABEL_21:
if ( v15 <= v20 )
goto LABEL_12;
v17 = 1;
if ( v4 != v16 )
LABEL_23:
v17 = v15 < *(_BYTE *)(v16 + 32);
LABEL_11:
v18 = operator new(0x28uLL);
*(_QWORD *)(v18 + 32) = *(_QWORD *)(v13 + 32);
std::_Rb_tree_insert_and_rebalance(v17, v18, v16, v4);
v3 = *(_QWORD *)(a1 + 40) + 1LL;
*(_QWORD *)(a1 + 40) = v3;
LABEL_12:
v13 = std::_Rb_tree_increment(v13);
}
return a1;
} | func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
PUSH R13
LEA R13,[RDI + 0x8]
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV RBX,RDX
SUB RSP,0x18
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R13
MOV qword ptr [RDI + 0x20],R13
MOV qword ptr [RDI + 0x28],0x0
MOV RDI,qword ptr [RSI + 0x10]
TEST RDI,RDI
JZ 0x00101e0f
MOV RBP,RSI
MOV RSI,R13
LAB_00101dcd:
CALL 0x00101b60
MOV RDX,RAX
NOP dword ptr [RAX]
LAB_00101dd8:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x10]
TEST RDX,RDX
JNZ 0x00101dd8
MOV qword ptr [R12 + 0x18],RCX
MOV RDX,RAX
NOP dword ptr [RAX]
LAB_00101df0:
MOV RCX,RDX
MOV RDX,qword ptr [RDX + 0x18]
TEST RDX,RDX
JNZ 0x00101df0
MOV R15,qword ptr [RBP + 0x28]
MOV qword ptr [R12 + 0x20],RCX
MOV qword ptr [R12 + 0x10],RAX
MOV qword ptr [R12 + 0x28],R15
LAB_00101e0f:
MOV RBP,qword ptr [RBX + 0x18]
LEA R14,[RBX + 0x8]
CMP RBP,R14
JZ 0x00101e84
NOP dword ptr [RAX]
LAB_00101e20:
MOVZX ECX,byte ptr [RBP + 0x20]
TEST R15,R15
JZ 0x00101ea0
MOV RBX,qword ptr [R12 + 0x20]
CMP CL,byte ptr [RBX + 0x20]
JLE 0x00101ea0
LAB_00101e33:
MOV R15D,0x1
CMP R13,RBX
JNZ 0x00101ee8
LAB_00101e42:
MOV EDI,0x28
LAB_00101e47:
CALL 0x00101140
MOV RSI,RAX
MOV RAX,qword ptr [RBP + 0x20]
MOVZX EDI,R15B
MOV RCX,R13
MOV RDX,RBX
MOV qword ptr [RSI + 0x20],RAX
CALL 0x00101100
MOV RAX,qword ptr [R12 + 0x28]
LEA R15,[RAX + 0x1]
MOV qword ptr [R12 + 0x28],R15
LAB_00101e74:
MOV RDI,RBP
CALL 0x00101130
MOV RBP,RAX
CMP R14,RAX
JNZ 0x00101e20
LAB_00101e84:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101ea0:
MOV RBX,qword ptr [R12 + 0x10]
TEST RBX,RBX
JNZ 0x00101eb3
JMP 0x00101ef8
LAB_00101eb0:
MOV RBX,RAX
LAB_00101eb3:
MOVZX EDX,byte ptr [RBX + 0x20]
MOV RAX,qword ptr [RBX + 0x18]
CMP CL,DL
CMOVL RAX,qword ptr [RBX + 0x10]
SETL SIL
TEST RAX,RAX
JNZ 0x00101eb0
TEST SIL,SIL
JNZ 0x00101efb
LAB_00101ed0:
CMP CL,DL
JLE 0x00101e74
MOV R15D,0x1
CMP R13,RBX
JZ 0x00101e42
NOP dword ptr [RAX + RAX*0x1]
LAB_00101ee8:
CMP CL,byte ptr [RBX + 0x20]
SETL R15B
JMP 0x00101e42
LAB_00101ef8:
MOV RBX,R13
LAB_00101efb:
CMP RBX,qword ptr [R12 + 0x18]
JZ 0x00101e33
MOV RDI,RBX
MOV byte ptr [RSP + 0xf],CL
CALL 0x00101160
MOVZX ECX,byte ptr [RSP + 0xf]
MOVZX EDX,byte ptr [RAX + 0x20]
JMP 0x00101ed0 | /* func0(std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >,
std::map<char, int, std::less<char>, std::allocator<std::pair<char const, int> > >) */
long func0(map param_1,map param_2)
{
_Rb_tree_node_base *p_Var1;
_Rb_tree_node_base _Var2;
_Rb_tree_node *p_Var3;
_Rb_tree_node *p_Var4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
long lVar7;
_Rb_tree_node_base _Var8;
_Alloc_node *in_RDX;
_Rb_tree_node *p_Var9;
_Rb_tree_node_base *p_Var10;
int4 in_register_00000034;
int4 in_register_0000003c;
long lVar11;
bool bVar12;
long lVar13;
lVar11 = CONCAT44(in_register_0000003c,param_1);
lVar13 = 0;
p_Var1 = (_Rb_tree_node_base *)(lVar11 + 8);
*(int4 *)(lVar11 + 8) = 0;
*(int8 *)(lVar11 + 0x10) = 0;
*(_Rb_tree_node_base **)(lVar11 + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(lVar11 + 0x20) = p_Var1;
*(int8 *)(lVar11 + 0x28) = 0;
p_Var3 = *(_Rb_tree_node **)(CONCAT44(in_register_00000034,param_2) + 0x10);
if (p_Var3 != (_Rb_tree_node *)0x0) {
p_Var4 = std::
_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>
::
_M_copy<false,std::_Rb_tree<char,std::pair<char_const,int>,std::_Select1st<std::pair<char_const,int>>,std::less<char>,std::allocator<std::pair<char_const,int>>>::_Alloc_node>
(p_Var3,p_Var1,in_RDX);
p_Var3 = p_Var4;
do {
p_Var9 = p_Var3;
p_Var3 = *(_Rb_tree_node **)(p_Var9 + 0x10);
} while (p_Var3 != (_Rb_tree_node *)0x0);
*(_Rb_tree_node **)(lVar11 + 0x18) = p_Var9;
p_Var3 = p_Var4;
do {
p_Var9 = p_Var3;
p_Var3 = *(_Rb_tree_node **)(p_Var9 + 0x18);
} while (p_Var3 != (_Rb_tree_node *)0x0);
lVar13 = *(long *)(CONCAT44(in_register_00000034,param_2) + 0x28);
*(_Rb_tree_node **)(lVar11 + 0x20) = p_Var9;
*(_Rb_tree_node **)(lVar11 + 0x10) = p_Var4;
*(long *)(lVar11 + 0x28) = lVar13;
}
p_Var6 = *(_Rb_tree_node_base **)(in_RDX + 0x18);
do {
if (p_Var6 == (_Rb_tree_node_base *)(in_RDX + 8)) {
return lVar11;
}
_Var2 = p_Var6[0x20];
if ((lVar13 == 0) ||
(p_Var10 = *(_Rb_tree_node_base **)(lVar11 + 0x20), (char)_Var2 <= (char)p_Var10[0x20])) {
p_Var5 = *(_Rb_tree_node_base **)(lVar11 + 0x10);
p_Var10 = p_Var1;
if (*(_Rb_tree_node_base **)(lVar11 + 0x10) == (_Rb_tree_node_base *)0x0) {
LAB_00101efb:
if (p_Var10 == *(_Rb_tree_node_base **)(lVar11 + 0x18)) goto joined_r0x00101edd;
lVar7 = std::_Rb_tree_decrement(p_Var10);
_Var8 = *(_Rb_tree_node_base *)(lVar7 + 0x20);
}
else {
do {
p_Var10 = p_Var5;
_Var8 = p_Var10[0x20];
p_Var5 = *(_Rb_tree_node_base **)(p_Var10 + 0x18);
if ((char)_Var2 < (char)_Var8) {
p_Var5 = *(_Rb_tree_node_base **)(p_Var10 + 0x10);
}
} while (p_Var5 != (_Rb_tree_node_base *)0x0);
if ((char)_Var2 < (char)_Var8) goto LAB_00101efb;
}
if ((char)_Var8 < (char)_Var2) goto joined_r0x00101edd;
}
else {
joined_r0x00101edd:
bVar12 = true;
if (p_Var1 != p_Var10) {
bVar12 = (char)_Var2 < (char)p_Var10[0x20];
}
/* try { // try from 00101e47 to 00101e4b has its CatchHandler @ 00101f1d */
p_Var5 = (_Rb_tree_node_base *)operator_new(0x28);
*(int8 *)(p_Var5 + 0x20) = *(int8 *)(p_Var6 + 0x20);
std::_Rb_tree_insert_and_rebalance(bVar12,p_Var5,p_Var10,p_Var1);
lVar13 = *(long *)(lVar11 + 0x28) + 1;
*(long *)(lVar11 + 0x28) = lVar13;
}
p_Var6 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var6);
} while( true );
} |
1,052 | func0 | #include <iostream>
#include <assert.h>
| double func0(int h_age) {
if (h_age < 0) {
exit(1);
} else if (h_age <= 2) {
return h_age * 10.5;
} else {
return 21 + (h_age - 2) * 4;
}
}
| int main() {
assert(func0(12) == 61);
assert(func0(15) == 73);
assert(func0(24) == 109);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 11c8 <_Z5func0i+0x1f>
mov $0x1,%edi
callq 10a0 <exit@plt>
cmpl $0x2,-0x4(%rbp)
jg 11e1 <_Z5func0i+0x38>
cvtsi2sdl -0x4(%rbp),%xmm1
movsd 0xeb5(%rip),%xmm0
mulsd %xmm1,%xmm0
jmp 11f1 <_Z5func0i+0x48>
mov -0x4(%rbp),%eax
sub $0x2,%eax
shl $0x2,%eax
add $0x15,%eax
cvtsi2sd %eax,%xmm0
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
cmp [rbp+var_4], 0
jns short loc_1188
mov edi, 1; status
call _exit
loc_1188:
cmp [rbp+var_4], 2
jg short loc_11A5
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_4]
movsd xmm0, cs:qword_2070
mulsd xmm0, xmm1
jmp short locret_11B9
loc_11A5:
mov eax, [rbp+var_4]
sub eax, 2
shl eax, 2
add eax, 15h
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
locret_11B9:
leave
retn | double func0(int a1)
{
if ( a1 < 0 )
exit(1);
if ( a1 > 2 )
return (double)(4 * (a1 - 2) + 21);
else
return 10.5 * (double)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNS 0x00101188
MOV EDI,0x1
CALL 0x00101070
LAB_00101188:
CMP dword ptr [RBP + -0x4],0x2
JG 0x001011a5
PXOR XMM1,XMM1
CVTSI2SD XMM1,dword ptr [RBP + -0x4]
MOVSD XMM0,qword ptr [0x00102070]
MULSD XMM0,XMM1
JMP 0x001011b9
LAB_001011a5:
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x2
SHL EAX,0x2
ADD EAX,0x15
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
LAB_001011b9:
LEAVE
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
if (param_1 < 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (param_1 < 3) {
dVar1 = DAT_00102070 * (double)param_1;
}
else {
dVar1 = (double)((param_1 + -2) * 4 + 0x15);
}
return dVar1;
} |
1,053 | func0 | #include <iostream>
#include <assert.h>
| double func0(int h_age) {
if (h_age < 0) {
exit(1);
} else if (h_age <= 2) {
return h_age * 10.5;
} else {
return 21 + (h_age - 2) * 4;
}
}
| int main() {
assert(func0(12) == 61);
assert(func0(15) == 73);
assert(func0(24) == 109);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
js 11a7 <_Z5func0i+0x1e>
cmp $0x2,%edi
jg 11b5 <_Z5func0i+0x2c>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xe62(%rip),%xmm0
retq
sub $0x8,%rsp
mov $0x1,%edi
callq 1080 <exit@plt>
lea 0xd(,%rdi,4),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
retq
| _Z5func0i:
endbr64
test edi, edi
js short loc_1167
cmp edi, 2
jg short loc_1175
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2008
retn
loc_1167:
sub rsp, 8
mov edi, 1; status
call _exit
loc_1175:
lea eax, ds:0Dh[rdi*4]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
retn | double func0(int a1)
{
if ( a1 < 0 )
exit(1);
if ( a1 > 2 )
return (double)(4 * a1 + 13);
else
return (double)a1 * 10.5;
} | func0:
ENDBR64
TEST EDI,EDI
JS 0x00101167
CMP EDI,0x2
JG 0x00101175
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102008]
RET
LAB_00101167:
SUB RSP,0x8
MOV EDI,0x1
CALL 0x00101050
LAB_00101175:
LEA EAX,[0xd + RDI*0x4]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
if (param_1 < 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (param_1 < 3) {
return (double)param_1 * _DAT_00102008;
}
return (double)(param_1 * 4 + 0xd);
} |
1,054 | func0 | #include <iostream>
#include <assert.h>
| double func0(int h_age) {
if (h_age < 0) {
exit(1);
} else if (h_age <= 2) {
return h_age * 10.5;
} else {
return 21 + (h_age - 2) * 4;
}
}
| int main() {
assert(func0(12) == 61);
assert(func0(15) == 73);
assert(func0(24) == 109);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
js 1210 <_Z5func0i+0x30>
cmp $0x2,%edi
jg 1200 <_Z5func0i+0x20>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xe0b(%rip),%xmm0
retq
xchg %ax,%ax
lea 0xd(,%rdi,4),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
retq
push %rax
mov $0x1,%edi
callq 1080 <exit@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
test edi, edi
js short loc_1190
cmp edi, 2
jg short loc_1180
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2008
retn
loc_1180:
lea eax, ds:0Dh[rdi*4]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
retn
loc_1190:
push rax
mov edi, 1; status
call _exit | double func0(int a1)
{
if ( a1 < 0 )
exit(1);
if ( a1 > 2 )
return (double)(4 * a1 + 13);
else
return (double)a1 * 10.5;
} | func0:
ENDBR64
TEST EDI,EDI
JS 0x00101190
CMP EDI,0x2
JG 0x00101180
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102008]
RET
LAB_00101180:
LEA EAX,[0xd + RDI*0x4]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
RET
LAB_00101190:
PUSH RAX
MOV EDI,0x1
CALL 0x00101050 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
if (param_1 < 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (param_1 < 3) {
return (double)param_1 * _DAT_00102008;
}
return (double)(param_1 * 4 + 0xd);
} |
1,055 | func0 | #include <iostream>
#include <assert.h>
| double func0(int h_age) {
if (h_age < 0) {
exit(1);
} else if (h_age <= 2) {
return h_age * 10.5;
} else {
return 21 + (h_age - 2) * 4;
}
}
| int main() {
assert(func0(12) == 61);
assert(func0(15) == 73);
assert(func0(24) == 109);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
js 1210 <_Z5func0i+0x30>
cmp $0x2,%edi
jg 1200 <_Z5func0i+0x20>
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd 0xe0b(%rip),%xmm0
retq
xchg %ax,%ax
lea 0xd(,%rdi,4),%eax
pxor %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
retq
push %rax
mov $0x1,%edi
callq 1080 <exit@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
test edi, edi
js short loc_1190
cmp edi, 2
jg short loc_1180
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
mulsd xmm0, cs:qword_2008
retn
loc_1180:
lea eax, ds:0Dh[rdi*4]
pxor xmm0, xmm0
cvtsi2sd xmm0, eax
retn
loc_1190:
push rax
mov edi, 1; status
call _exit | double func0(int a1)
{
if ( a1 < 0 )
exit(1);
if ( a1 > 2 )
return (double)(4 * a1 + 13);
else
return (double)a1 * 10.5;
} | func0:
ENDBR64
TEST EDI,EDI
JS 0x00101190
CMP EDI,0x2
JG 0x00101180
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
MULSD XMM0,qword ptr [0x00102008]
RET
LAB_00101180:
LEA EAX,[0xd + RDI*0x4]
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
RET
LAB_00101190:
PUSH RAX
MOV EDI,0x1
CALL 0x00101050 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
double func0(int param_1)
{
if (param_1 < 0) {
/* WARNING: Subroutine does not return */
exit(1);
}
if (param_1 < 3) {
return (double)param_1 * _DAT_00102008;
}
return (double)(param_1 * 4 + 0xd);
} |
1,056 | func0 |
#include <vector>
#include <string>
#include <cassert>
template <typename T>
| std::vector<std::vector<T>> func0(const std::vector<T>& S, int step) {
std::vector<std::vector<T>> result(step, std::vector<T>());
for(int i = 0; i < S.size(); ++i) {
result[i % step].push_back(S[i]);
}
return result;
}
| int main() {
// Test case 1
std::vector<std::string> S1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"};
std::vector<std::vector<std::string>> expected1 = {
{"a", "d", "g", "j", "m"},
{"b", "e", "h", "k", "n"},
{"c", "f", "i", "l"}
};
assert(func0(S1, 3) == expected1);
// Test case 2
std::vector<int> S2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
std::vector<std::vector<int>> expected2 = {
{1,4,7,10,13},
{2,5,8,11,14},
{3,6,9,12}
};
assert(func0(S2, 3) == expected2);
// Test case 3
std::vector<std::string> S3 = {"python","java","C","C++","DBMS","SQL"};
std::vector<std::vector<std::string>> expected3 = {
{"python", "C", "DBMS"},
{"java", "C++", "SQL"}
};
assert(func0(S3, 2) == expected3);
return 0;
}
| O0 | cpp | std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > > func0<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&, int):
endbr64
push %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
lea -0x35(%rbp),%rax
mov %rax,%rdi
callq 44c2 <_ZNSaISt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEEC1Ev>
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 463e <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC1Ev>
mov -0x54(%rbp),%eax
movslq %eax,%rsi
lea -0x35(%rbp),%rcx
lea -0x30(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 51ee <_ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EEC1EmRKS7_RKS8_>
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 447a <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
lea -0x35(%rbp),%rax
mov %rax,%rdi
callq 44e2 <_ZNSaISt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEED1Ev>
movl $0x0,-0x34(%rbp)
mov -0x34(%rbp),%eax
movslq %eax,%rbx
mov -0x50(%rbp),%rax
mov %rax,%rdi
callq 5276 <_ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv>
cmp %rax,%rbx
setb %al
test %al,%al
je 47b9 <_Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIS6_IT_SaIS7_EESaIS9_EERKS9_i+0x13c>
mov -0x34(%rbp),%eax
cltd
idivl -0x54(%rbp)
mov %edx,%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 529e <_ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EEixEm>
mov %rax,%rbx
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 52cc <_ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm>
mov %rax,%rsi
mov %rbx,%rdi
callq 52f0 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_>
addl $0x1,-0x34(%rbp)
jmp 470d <_Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIS6_IT_SaIS7_EESaIS9_EERKS9_i+0x90>
endbr64
mov %rax,%rbx
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 447a <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
lea -0x35(%rbp),%rax
mov %rax,%rdi
callq 44e2 <_ZNSaISt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23c0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 45b6 <_ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 23c0 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 47ce <_Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIS6_IT_SaIS7_EESaIS9_EERKS9_i+0x151>
callq 2360 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIS6_IT_SaIS7_EESaIS9_EERKS9_i:
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
lea rax, [rbp+var_3D]
mov [rbp+var_38], rax
nop
nop
pxor xmm0, xmm0
movaps [rbp+var_30], xmm0
movq [rbp+var_20], xmm0
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov eax, [rbp+var_54]
movsxd rsi, eax
lea rcx, [rbp+var_3D]
lea rdx, [rbp+var_30]
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EEC2EmRKS7_RKS8_; std::vector<std::vector<std::string>>::vector(ulong,std::vector<std::string> const&,std::allocator<std::vector<std::string>> const&)
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rax, [rbp+var_3D]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEED2Ev; std::__new_allocator<std::vector<std::string>>::~__new_allocator()
nop
mov [rbp+var_3C], 0
jmp short loc_3806
loc_37C4:
mov eax, [rbp+var_3C]
cdq
idiv [rbp+var_54]
mov eax, edx
movsxd rdx, eax
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EEixEm; std::vector<std::vector<std::string>>::operator[](ulong)
mov rbx, rax
mov eax, [rbp+var_3C]
movsxd rdx, eax
mov rax, [rbp+var_50]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backERKS5_; std::vector<std::string>::push_back(std::string const&)
add [rbp+var_3C], 1
loc_3806:
mov eax, [rbp+var_3C]
movsxd rbx, eax
mov rax, [rbp+var_50]
mov rdi, rax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
cmp rbx, rax
setb al
test al, al
jnz short loc_37C4
jmp short loc_3895
endbr64
mov rbx, rax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rax, [rbp+var_3D]
mov rdi, rax
call _ZNSt15__new_allocatorISt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEED2Ev; std::__new_allocator<std::vector<std::string>>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_385B
call ___stack_chk_fail
loc_385B:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EED2Ev; std::vector<std::vector<std::string>>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_388D
call ___stack_chk_fail
loc_388D:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_3895:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_38A9
call ___stack_chk_fail
loc_38A9:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0<std::string>(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rax
unsigned long long v5; // rbx
char v8; // [rsp+23h] [rbp-3Dh] BYREF
int i; // [rsp+24h] [rbp-3Ch]
char *v10; // [rsp+28h] [rbp-38h]
__int128 v11; // [rsp+30h] [rbp-30h] BYREF
long long v12; // [rsp+40h] [rbp-20h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = __readfsqword(0x28u);
v10 = &v8;
v11 = 0LL;
v12 = 0LL;
std::vector<std::string>::vector(&v11);
std::vector<std::vector<std::string>>::vector(a1, a3, &v11, &v8);
std::vector<std::string>::~vector(&v11);
std::__new_allocator<std::vector<std::string>>::~__new_allocator(&v8);
for ( i = 0; ; ++i )
{
v5 = i;
if ( v5 >= std::vector<std::string>::size(a2) )
break;
v3 = std::vector<std::vector<std::string>>::operator[](a1, i % a3);
v4 = std::vector<std::string>::operator[](a2, i);
std::vector<std::string>::push_back(v3, v4);
}
return a1;
} | func0<std::string>:
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
LEA RAX,[RBP + -0x3d]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],XMM0
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001036f6
MOV EAX,dword ptr [RBP + -0x54]
MOVSXD RSI,EAX
LEA RCX,[RBP + -0x3d]
LEA RDX,[RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
LAB_0010379d:
CALL 0x00104376
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x00103534
LEA RAX,[RBP + -0x3d]
MOV RDI,RAX
CALL 0x00104134
NOP
MOV dword ptr [RBP + -0x3c],0x0
JMP 0x00103806
LAB_001037c4:
MOV EAX,dword ptr [RBP + -0x3c]
CDQ
IDIV dword ptr [RBP + -0x54]
MOV EAX,EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00104424
MOV RBX,RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00104452
MOV RSI,RAX
MOV RDI,RBX
LAB_001037fd:
CALL 0x00104476
ADD dword ptr [RBP + -0x3c],0x1
LAB_00103806:
MOV EAX,dword ptr [RBP + -0x3c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x001043fc
CMP RBX,RAX
SETC AL
TEST AL,AL
JNZ 0x001037c4
JMP 0x00103895
LAB_00103895:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001038a9
CALL 0x00102350
LAB_001038a9:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > func0<std::string
>(std::vector<std::string, std::allocator<std::string > > const&, int) */
vector func0<std::string>(vector_conflict *param_1,int param_2)
{
vector<std::string,std::allocator<std::string>> *this;
string *psVar1;
ulong uVar2;
int in_EDX;
ulong uVar3;
int4 in_register_00000034;
long in_FS_OFFSET;
allocator local_45;
int local_44;
allocator *local_40;
vector<std::string,std::allocator<std::string>> local_38 [16];
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = &local_45;
local_38[0] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[1] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[2] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[3] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[4] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[5] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[6] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[7] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[8] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[9] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[10] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[0xb] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[0xc] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[0xd] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[0xe] = (vector<std::string,std::allocator<std::string>>)0x0;
local_38[0xf] = (vector<std::string,std::allocator<std::string>>)0x0;
local_28 = 0;
std::vector<std::string,std::allocator<std::string>>::vector(local_38);
/* try { // try from 0010379d to 001037a1 has its CatchHandler @ 00103824 */
std::
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
::vector((vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
*)param_1,(long)in_EDX,(vector_conflict *)local_38,&local_45);
std::vector<std::string,std::allocator<std::string>>::~vector(local_38);
std::__new_allocator<std::vector<std::string,std::allocator<std::string>>>::~__new_allocator
((__new_allocator<std::vector<std::string,std::allocator<std::string>>> *)&local_45);
local_44 = 0;
while( true ) {
uVar3 = (ulong)local_44;
uVar2 = std::vector<std::string,std::allocator<std::string>>::size
((vector<std::string,std::allocator<std::string>> *)
CONCAT44(in_register_00000034,param_2));
if (uVar2 <= uVar3) break;
this = (vector<std::string,std::allocator<std::string>> *)
std::
vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
::operator[]((vector<std::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<std::string,std::allocator<std::string>>>>
*)param_1,(long)(local_44 % in_EDX));
psVar1 = (string *)
std::vector<std::string,std::allocator<std::string>>::operator[]
((vector<std::string,std::allocator<std::string>> *)
CONCAT44(in_register_00000034,param_2),(long)local_44);
/* try { // try from 001037fd to 00103801 has its CatchHandler @ 00103863 */
std::vector<std::string,std::allocator<std::string>>::push_back(this,psVar1);
local_44 = local_44 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (vector)param_1;
} |
1,057 | func0 |
#include <vector>
#include <string>
#include <cassert>
template <typename T>
| std::vector<std::vector<T>> func0(const std::vector<T>& S, int step) {
std::vector<std::vector<T>> result(step, std::vector<T>());
for(int i = 0; i < S.size(); ++i) {
result[i % step].push_back(S[i]);
}
return result;
}
| int main() {
// Test case 1
std::vector<std::string> S1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"};
std::vector<std::vector<std::string>> expected1 = {
{"a", "d", "g", "j", "m"},
{"b", "e", "h", "k", "n"},
{"c", "f", "i", "l"}
};
assert(func0(S1, 3) == expected1);
// Test case 2
std::vector<int> S2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
std::vector<std::vector<int>> expected2 = {
{1,4,7,10,13},
{2,5,8,11,14},
{3,6,9,12}
};
assert(func0(S2, 3) == expected2);
// Test case 3
std::vector<std::string> S3 = {"python","java","C","C++","DBMS","SQL"};
std::vector<std::vector<std::string>> expected3 = {
{"python", "C", "DBMS"},
{"java", "C++", "SQL"}
};
assert(func0(S3, 2) == expected3);
return 0;
}
| O1 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
movslq %edx,%rbx
movabs $0x555555555555555,%rax
cmp %rax,%rbx
ja 279b <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x9c>
mov %rdi,%r13
mov %rsi,%rbp
mov %edx,%r12d
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
test %rbx,%rbx
je 2809 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x10a>
lea (%rbx,%rbx,2),%r14
shl $0x3,%r14
mov %r14,%rdi
callq 11b0 <_Znwm@plt>
mov %rax,0x0(%r13)
add %rax,%r14
mov %r14,0x10(%r13)
movq $0x0,(%rax)
movq $0x0,0x8(%rax)
movq $0x0,0x10(%rax)
add $0x18,%rax
sub $0x1,%rbx
jne 2761 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x62>
mov %r14,0x8(%r13)
mov 0x0(%rbp),%rcx
cmp %rcx,0x8(%rbp)
je 2823 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x124>
mov $0x0,%ebx
jmp 27c8 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xc9>
lea 0x1896(%rip),%rdi
callq 1160 <_ZSt20__throw_length_errorPKc@plt>
mov (%rdx),%eax
mov %eax,(%rsi)
addq $0x4,0x8(%rdi)
add $0x1,%rbx
mov 0x0(%rbp),%rcx
mov 0x8(%rbp),%rax
sub %rcx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 2823 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x124>
mov %ebx,%eax
cltd
idiv %r12d
movslq %edx,%rdx
lea (%rdx,%rdx,2),%rdx
mov 0x0(%r13),%rax
lea (%rax,%rdx,8),%rdi
lea (%rcx,%rbx,4),%rdx
mov 0x8(%rdi),%rsi
cmp 0x10(%rdi),%rsi
jne 27a7 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xa8>
callq 25d0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 27b0 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xb1>
endbr64
mov %rax,%rbx
mov %r13,%rdi
callq 258e <_ZNSt6vectorIS_IiSaIiEESaIS1_EED1Ev>
mov %rbx,%rdi
callq 1200 <_Unwind_Resume@plt>
movq $0x0,(%rdi)
movq $0x0,0x10(%rdi)
mov $0x0,%r14d
jmpq 2782 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x83>
mov %r13,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
| _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov [rsp+48h+var_48], 0
mov [rsp+48h+var_40], 0
mov [rsp+48h+var_38], 0
movsxd rbx, edx
mov rax, 555555555555555h
cmp rax, rbx
jb short loc_2B5F
mov r13, rdi
mov rbp, rsi
mov r12d, edx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
test rbx, rbx
jz short loc_2BAD
lea rdi, [rbx+rbx*2]
shl rdi, 3; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_2B89
loc_2B5F:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_2B84
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 short loc_2BF8
loc_2B84:
call ___stack_chk_fail
loc_2B89:
mov rdi, rax
loc_2B8C:
mov [r13+0], rdi
mov [r13+8], rdi
lea rax, [rbx+rbx*2]
lea rax, [rdi+rax*8]
mov [r13+10h], rax
mov rdx, rsp
mov rsi, rbx
call _ZSt18__do_uninit_fill_nIPSt6vectorIiSaIiEEmS2_ET_S4_T0_RKT1_; std::__do_uninit_fill_n<std::vector<int> *,ulong,std::vector<int>>(std::vector<int> *,ulong,std::vector<int> const&)
jmp short loc_2BB4
loc_2BAD:
mov edi, 0
jmp short loc_2B8C
loc_2BB4:
mov [r13+8], rax
mov rcx, [rbp+0]
mov ebx, 0
cmp rcx, [rbp+8]
jnz short loc_2C32
loc_2BC7:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz loc_2C94
mov rax, r13
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
retn
endbr64
mov rbx, rax
mov rdi, r13
call _ZNSt12_Vector_baseISt6vectorIiSaIiEESaIS2_EED2Ev; std::_Vector_base<std::vector<int>>::~_Vector_base()
loc_2BF8:
mov rdi, rsp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jz short loc_2C60
call ___stack_chk_fail
loc_2C15:
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_2C1A:
add rbx, 1
mov rcx, [rbp+0]
mov rax, [rbp+8]
sub rax, rcx
sar rax, 2
cmp rbx, rax
jnb short loc_2BC7
loc_2C32:
mov eax, ebx
cdq
idiv r12d
movsxd rdx, edx
lea rdx, [rdx+rdx*2]
mov rax, [r13+0]
lea rdi, [rax+rdx*8]
lea rdx, [rcx+rbx*4]
mov rsi, [rdi+8]
cmp rsi, [rdi+10h]
jz short loc_2C15
mov eax, [rdx]
mov [rsi], eax
add qword ptr [rdi+8], 4
jmp short loc_2C1A
loc_2C60:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
mov rdi, r13
call _ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jz short loc_2C8C
call ___stack_chk_fail
loc_2C8C:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_2C94:
call ___stack_chk_fail | _QWORD * func0<int>(_QWORD *a1, long long *a2, int a3)
{
long long v3; // rbx
long long v7; // rdi
long long v8; // rax
long long v9; // r8
long long v10; // r9
long long v11; // rcx
unsigned long long v12; // rbx
long long v14; // rdi
_DWORD *v15; // rdx
_DWORD *v16; // rsi
long long v17; // [rsp+0h] [rbp-48h] BYREF
long long v18; // [rsp+8h] [rbp-40h]
long long v19; // [rsp+10h] [rbp-38h]
unsigned long long v20; // [rsp+18h] [rbp-30h]
v20 = __readfsqword(0x28u);
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v3 = a3;
if ( (unsigned long long)a3 > 0x555555555555555LL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
if ( a3 )
v7 = operator new(24LL * a3);
else
v7 = 0LL;
*a1 = v7;
a1[1] = v7;
a1[2] = v7 + 24 * v3;
v8 = ((long long ( *)(long long, long long, long long *))std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>)(
v7,
v3,
&v17);
a1[1] = v8;
v11 = *a2;
v12 = 0LL;
if ( *a2 != a2[1] )
{
do
{
v14 = *a1 + 24LL * ((int)v12 % a3);
v15 = (_DWORD *)(v11 + 4 * v12);
v16 = *(_DWORD **)(v14 + 8);
if ( v16 == *(_DWORD **)(v14 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(v14, v16, v15, v11, v9, v10, v17, v18, v19, v20);
}
else
{
*v16 = *v15;
*(_QWORD *)(v14 + 8) += 4LL;
}
++v12;
v11 = *a2;
}
while ( v12 < (a2[1] - *a2) >> 2 );
}
return a1;
} | func0<int>:
ENDBR64
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
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOVSXD RBX,EDX
MOV RAX,0x555555555555555
CMP RAX,RBX
JC 0x00102b5f
MOV R13,RDI
MOV RBP,RSI
MOV R12D,EDX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
TEST RBX,RBX
JZ 0x00102bad
LEA RDI,[RBX + RBX*0x2]
SHL RDI,0x3
LAB_00102b58:
CALL 0x001011d0
JMP 0x00102b89
LAB_00102b5f:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102b84
LEA RDI,[0x104008]
CALL 0x00101180
LAB_00102b7b:
ENDBR64
MOV RBX,RAX
JMP 0x00102bf8
LAB_00102b84:
CALL 0x001011f0
LAB_00102b89:
MOV RDI,RAX
LAB_00102b8c:
MOV qword ptr [R13],RDI
MOV qword ptr [R13 + 0x8],RDI
LEA RAX,[RBX + RBX*0x2]
LEA RAX,[RDI + RAX*0x8]
MOV qword ptr [R13 + 0x10],RAX
MOV RDX,RSP
MOV RSI,RBX
LAB_00102ba6:
CALL 0x001029c0
JMP 0x00102bb4
LAB_00102bad:
MOV EDI,0x0
JMP 0x00102b8c
LAB_00102bb4:
MOV qword ptr [R13 + 0x8],RAX
MOV RCX,qword ptr [RBP]
MOV EBX,0x0
CMP RCX,qword ptr [RBP + 0x8]
JNZ 0x00102c32
LAB_00102bc7:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102c94
MOV RAX,R13
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00102bf8:
MOV RDI,RSP
CALL 0x00102050
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102c60
CALL 0x001011f0
LAB_00102c15:
CALL 0x00102520
LAB_00102c1a:
ADD RBX,0x1
MOV RCX,qword ptr [RBP]
MOV RAX,qword ptr [RBP + 0x8]
SUB RAX,RCX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00102bc7
LAB_00102c32:
MOV EAX,EBX
CDQ
IDIV R12D
MOVSXD RDX,EDX
LEA RDX,[RDX + RDX*0x2]
MOV RAX,qword ptr [R13]
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[RCX + RBX*0x4]
MOV RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JZ 0x00102c15
MOV EAX,dword ptr [RDX]
MOV dword ptr [RSI],EAX
ADD qword ptr [RDI + 0x8],0x4
JMP 0x00102c1a
LAB_00102c60:
MOV RDI,RBX
LAB_00102c63:
CALL 0x00101240
LAB_00102c94:
CALL 0x001011f0 | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> > const&, int) */
long * func0<int>(long *param_1,long *param_2,int param_3)
{
vector<int,std::allocator<int>> *this;
int *piVar1;
int *piVar2;
vector *pvVar3;
int8 uVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
int8 local_48;
int8 local_40;
int8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
local_48 = 0;
local_40 = 0;
local_38 = 0;
uVar6 = (ulong)param_3;
if (uVar6 < 0x555555555555556) {
*param_1 = 0;
param_1[1] = 0;
param_1[2] = 0;
if (uVar6 == 0) {
pvVar3 = (vector *)0x0;
}
else {
/* try { // try from 00102b58 to 00102b7a has its CatchHandler @ 00102b7b */
pvVar3 = (vector *)operator_new(uVar6 * 0x18);
}
*param_1 = (long)pvVar3;
param_1[1] = (long)pvVar3;
param_1[2] = (long)(pvVar3 + uVar6 * 0x18);
/* try { // try from 00102ba6 to 00102baa has its CatchHandler @ 00102be9 */
pvVar3 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar3,uVar6,(vector *)&local_48);
param_1[1] = (long)pvVar3;
lVar5 = *param_2;
uVar6 = 0;
if (lVar5 != param_2[1]) {
do {
this = (vector<int,std::allocator<int>> *)
(*param_1 +
(long)(int)((long)((ulong)(uint)((int)uVar6 >> 0x1f) << 0x20 | uVar6 & 0xffffffff) %
(long)param_3) * 0x18);
piVar1 = (int *)(lVar5 + uVar6 * 4);
piVar2 = *(int **)(this + 8);
if (piVar2 == *(int **)(this + 0x10)) {
/* try { // try from 00102c15 to 00102c19 has its CatchHandler @ 00102c68 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)piVar2,piVar1);
}
else {
*piVar2 = *piVar1;
*(long *)(this + 8) = *(long *)(this + 8) + 4;
}
uVar6 = uVar6 + 1;
lVar5 = *param_2;
} while (uVar6 < (ulong)(param_2[1] - lVar5 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
uVar4 = std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<int,std::allocator<int>>::~vector((vector<int,std::allocator<int>> *)&local_48);
/* catch() { ... } // from try @ 00102b58 with catch @ 00102b7b */
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar4);
} |
1,058 | func0 |
#include <vector>
#include <string>
#include <cassert>
template <typename T>
| std::vector<std::vector<T>> func0(const std::vector<T>& S, int step) {
std::vector<std::vector<T>> result(step, std::vector<T>());
for(int i = 0; i < S.size(); ++i) {
result[i % step].push_back(S[i]);
}
return result;
}
| int main() {
// Test case 1
std::vector<std::string> S1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"};
std::vector<std::vector<std::string>> expected1 = {
{"a", "d", "g", "j", "m"},
{"b", "e", "h", "k", "n"},
{"c", "f", "i", "l"}
};
assert(func0(S1, 3) == expected1);
// Test case 2
std::vector<int> S2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
std::vector<std::vector<int>> expected2 = {
{1,4,7,10,13},
{2,5,8,11,14},
{3,6,9,12}
};
assert(func0(S2, 3) == expected2);
// Test case 3
std::vector<std::string> S3 = {"python","java","C","C++","DBMS","SQL"};
std::vector<std::vector<std::string>> expected3 = {
{"python", "C", "DBMS"},
{"java", "C++", "SQL"}
};
assert(func0(S3, 2) == expected3);
return 0;
}
| O2 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
movslq %edx,%rax
movabs $0x555555555555555,%rdx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
cmp %rdx,%rax
ja 26d2 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x212>
lea (%rax,%rax,2),%rbx
movq $0x0,(%rdi)
mov %rdi,%r14
xor %edx,%edx
movq $0x0,0x8(%rdi)
mov %rsi,%r12
mov %rax,%r13
shl $0x3,%rbx
movq $0x0,0x10(%rdi)
test %rax,%rax
je 2550 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x90>
mov %rbx,%rdi
callq 11d0 <_Znwm@plt>
lea (%rax,%rbx,1),%rdx
mov %rax,(%r14)
mov %rdx,0x10(%r14)
nopw 0x0(%rax,%rax,1)
movq $0x0,(%rax)
add $0x18,%rax
movq $0x0,-0x10(%rax)
movq $0x0,-0x8(%rax)
cmp %rax,%rdx
jne 2530 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x70>
mov %rdx,0x8(%r14)
mov (%r12),%rcx
xor %ebx,%ebx
cmp 0x8(%r12),%rcx
jne 259b <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xdb>
jmpq 2660 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1a0>
nopw %cs:0x0(%rax,%rax,1)
mov (%r15),%edx
add $0x4,%rax
mov %edx,-0x4(%rax)
mov %rax,0x8(%rbp)
mov (%r12),%rcx
mov 0x8(%r12),%rax
add $0x1,%rbx
sub %rcx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 2660 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1a0>
mov %ebx,%eax
lea (%rcx,%rbx,4),%r15
cltd
idiv %r13d
mov (%r14),%rax
movslq %edx,%rdx
lea (%rdx,%rdx,2),%rdx
lea (%rax,%rdx,8),%rbp
mov 0x8(%rbp),%rax
cmp 0x10(%rbp),%rax
jne 2570 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xb0>
movabs $0x1fffffffffffffff,%rdi
mov 0x0(%rbp),%rsi
sub %rsi,%rax
mov %rsi,0x8(%rsp)
mov %rax,0x18(%rsp)
sar $0x2,%rax
cmp %rdi,%rax
je 26c6 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x206>
test %rax,%rax
je 26b8 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1f8>
movabs $0x7ffffffffffffffc,%rdi
lea (%rax,%rax,1),%rdx
mov %rdi,0x10(%rsp)
cmp %rdx,%rax
jbe 2650 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x190>
mov 0x10(%rsp),%rdi
callq 11d0 <_Znwm@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
add %rax,%r8
mov (%r15),%eax
mov 0x18(%rsp),%rdx
mov %eax,(%rcx,%rdx,1)
lea 0x4(%rcx,%rdx,1),%r15
test %rdx,%rdx
jg 2678 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1b8>
cmpq $0x0,0x8(%rsp)
jne 2692 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1d2>
mov %rcx,0x0(%rbp)
mov %r15,0x8(%rbp)
mov %r8,0x10(%rbp)
jmpq 257e <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xbe>
nopl 0x0(%rax)
test %rdx,%rdx
jne 26de <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x21e>
xor %r8d,%r8d
xor %ecx,%ecx
jmp 261b <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x15b>
add $0x28,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rsi
mov %rcx,%rdi
mov %r8,0x10(%rsp)
callq 1200 <memmove@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
mov 0x8(%rsp),%rdi
mov %rcx,0x18(%rsp)
mov %r8,0x10(%rsp)
callq 11c0 <_ZdlPv@plt>
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%r8
jmp 2638 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x178>
nopw 0x0(%rax,%rax,1)
movq $0x4,0x10(%rsp)
jmpq 2606 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x146>
lea 0x19e4(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
lea 0x19a7(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
lea 0x0(,%rdx,4),%rax
mov %rax,0x10(%rsp)
jmpq 2606 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x146>
endbr64
mov %rax,%rbp
mov %r14,%rdi
callq 2460 <_ZNSt6vectorIS_IiSaIiEESaIS1_EED1Ev>
mov %rbp,%rdi
callq 1220 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov ebp, edx
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
movsxd rax, edx
movaps [rsp+48h+var_48], xmm0
mov rdx, 555555555555555h
mov [rsp+48h+var_38], 0
cmp rdx, rax
jb loc_28A4
mov qword ptr [rdi+10h], 0
mov r12, rdi
mov r13, rsi
movups xmmword ptr [rdi], xmm0
test rax, rax
jz loc_2890
lea rdx, [rax+rax*2]
lea rbx, ds:0[rdx*8]
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
lea rdx, [rax+rbx]
mov [r12], rax
pxor xmm0, xmm0
mov [r12+10h], rdx
nop word ptr [rax+rax+00000000h]
loc_27F0:
mov qword ptr [rax+10h], 0
add rax, 18h
movups xmmword ptr [rax-18h], xmm0
cmp rdx, rax
jnz short loc_27F0
loc_2805:
mov [r12+8], rax
mov rcx, [r13+0]
cmp rcx, [r13+8]
jz short loc_2870
xor ebx, ebx
jmp short loc_2841
loc_2820:
mov eax, [rdx]
add rsi, 4
mov [rsi-4], eax
mov [rdi+8], rsi
loc_282D:
mov rax, [r13+8]
add rbx, 1
sub rax, rcx
sar rax, 2
cmp rbx, rax
jnb short loc_2870
loc_2841:
mov eax, ebx
cdq
idiv ebp
mov rax, [r12]
movsxd rdx, edx
lea rdx, [rdx+rdx*2]
lea rdi, [rax+rdx*8]
lea rdx, [rcx+rbx*4]
mov rsi, [rdi+8]
cmp rsi, [rdi+10h]
jnz short loc_2820
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&)
mov rcx, [r13+0]
jmp short loc_282D
loc_2870:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_28D8
add rsp, 28h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
retn
loc_2890:
mov qword ptr [rdi], 0
mov qword ptr [rdi+10h], 0
jmp loc_2805
loc_28A4:
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_28D8
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_28C0:
mov rdi, rsp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jz short loc_2907
loc_28D8:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_28EF
endbr64
mov rbx, rax
jmp short loc_28C0
loc_28EF:
mov rdi, r12
call _ZNSt6vectorIS_IiSaIiEESaIS1_EED2Ev; std::vector<std::vector<int>>::~vector()
mov rax, [rsp+48h+var_30]
sub rax, fs:28h
jnz short loc_28D8
loc_2907:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<int>(long long a1, long long *a2, int a3, long long a4, long long a5, long long a6)
{
long long v7; // rax
unsigned long long v10; // rbx
long long v11; // rdx
long long v12; // rcx
unsigned long long v13; // rbx
long long v14; // rsi
long long v15; // rdi
_DWORD *v16; // rdx
long long v17; // rsi
__int128 v19; // [rsp+0h] [rbp-48h]
long long v20; // [rsp+10h] [rbp-38h]
unsigned long long v21; // [rsp+18h] [rbp-30h]
v21 = __readfsqword(0x28u);
v7 = a3;
v19 = 0LL;
v20 = 0LL;
if ( (unsigned long long)a3 > 0x555555555555555LL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
if ( a3 )
{
v10 = 24LL * a3;
v7 = operator new(v10);
v11 = v7 + v10;
*(_QWORD *)a1 = v7;
*(_QWORD *)(a1 + 16) = v7 + v10;
do
{
*(_QWORD *)(v7 + 16) = 0LL;
v7 += 24LL;
*(_OWORD *)(v7 - 24) = 0LL;
}
while ( v11 != v7 );
}
else
{
*(_QWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
}
*(_QWORD *)(a1 + 8) = v7;
v12 = *a2;
if ( *a2 != a2[1] )
{
v13 = 0LL;
do
{
v15 = *(_QWORD *)a1 + 24LL * ((int)v13 % a3);
v16 = (_DWORD *)(v12 + 4 * v13);
v17 = *(_QWORD *)(v15 + 8);
if ( v17 == *(_QWORD *)(v15 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(
v15,
v17,
v16,
v12,
a5,
a6,
0.0,
v19,
*((_QWORD *)&v19 + 1),
v20,
v21);
v12 = *a2;
}
else
{
v14 = v17 + 4;
*(_DWORD *)(v14 - 4) = *v16;
*(_QWORD *)(v15 + 8) = v14;
}
++v13;
}
while ( v13 < (a2[1] - v12) >> 2 );
}
return a1;
} | func0<int>:
ENDBR64
PUSH R13
PXOR XMM0,XMM0
PUSH R12
PUSH RBP
MOV EBP,EDX
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
MOVAPS xmmword ptr [RSP],XMM0
MOV RDX,0x555555555555555
MOV qword ptr [RSP + 0x10],0x0
CMP RDX,RAX
JC 0x001028a4
MOV qword ptr [RDI + 0x10],0x0
MOV R12,RDI
MOV R13,RSI
MOVUPS xmmword ptr [RDI],XMM0
TEST RAX,RAX
JZ 0x00102890
LEA RDX,[RAX + RAX*0x2]
LEA RBX,[RDX*0x8]
MOV RDI,RBX
LAB_001027d0:
CALL 0x001011f0
LEA RDX,[RAX + RBX*0x1]
MOV qword ptr [R12],RAX
PXOR XMM0,XMM0
MOV qword ptr [R12 + 0x10],RDX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_001027f0:
MOV qword ptr [RAX + 0x10],0x0
ADD RAX,0x18
MOVUPS xmmword ptr [RAX + -0x18],XMM0
CMP RDX,RAX
JNZ 0x001027f0
LAB_00102805:
MOV qword ptr [R12 + 0x8],RAX
MOV RCX,qword ptr [R13]
CMP RCX,qword ptr [R13 + 0x8]
JZ 0x00102870
XOR EBX,EBX
JMP 0x00102841
LAB_00102820:
MOV EAX,dword ptr [RDX]
ADD RSI,0x4
MOV dword ptr [RSI + -0x4],EAX
MOV qword ptr [RDI + 0x8],RSI
LAB_0010282d:
MOV RAX,qword ptr [R13 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00102870
LAB_00102841:
MOV EAX,EBX
CDQ
IDIV EBP
MOV RAX,qword ptr [R12]
MOVSXD RDX,EDX
LEA RDX,[RDX + RDX*0x2]
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[RCX + RBX*0x4]
MOV RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JNZ 0x00102820
LAB_00102863:
CALL 0x001025d0
MOV RCX,qword ptr [R13]
JMP 0x0010282d
LAB_00102870:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001028d8
ADD RSP,0x28
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00102890:
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x10],0x0
JMP 0x00102805
LAB_001028a4:
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001028d8
LEA RDI,[0x104008]
LAB_001028bb:
CALL 0x001011a0
LAB_001028c0:
MOV RDI,RSP
CALL 0x00102100
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102907
LAB_001028d8:
CALL 0x00101210
LAB_00102907:
MOV RDI,RBX
LAB_0010290a:
CALL 0x00101260 | /* std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> > const&, int) */
int (*) [16] func0<int>(int (*param_1) [16],long *param_2,int param_3)
{
int (*pauVar1) [16];
vector<int,std::allocator<int>> *this;
int *piVar2;
int *piVar3;
ulong uVar4;
int (*pauVar5) [16];
int (*pauVar6) [16];
long lVar7;
long in_FS_OFFSET;
vector<int,std::allocator<int>> local_48 [16];
int8 local_38;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = (ulong)param_3;
local_48[0] = (vector<int,std::allocator<int>>)0x0;
local_48[1] = (vector<int,std::allocator<int>>)0x0;
local_48[2] = (vector<int,std::allocator<int>>)0x0;
local_48[3] = (vector<int,std::allocator<int>>)0x0;
local_48[4] = (vector<int,std::allocator<int>>)0x0;
local_48[5] = (vector<int,std::allocator<int>>)0x0;
local_48[6] = (vector<int,std::allocator<int>>)0x0;
local_48[7] = (vector<int,std::allocator<int>>)0x0;
local_48[8] = (vector<int,std::allocator<int>>)0x0;
local_48[9] = (vector<int,std::allocator<int>>)0x0;
local_48[10] = (vector<int,std::allocator<int>>)0x0;
local_48[0xb] = (vector<int,std::allocator<int>>)0x0;
local_48[0xc] = (vector<int,std::allocator<int>>)0x0;
local_48[0xd] = (vector<int,std::allocator<int>>)0x0;
local_48[0xe] = (vector<int,std::allocator<int>>)0x0;
local_48[0xf] = (vector<int,std::allocator<int>>)0x0;
local_38 = 0;
if (uVar4 < 0x555555555555556) {
*(int8 *)param_1[1] = 0;
*param_1 = (int [16])0x0;
if (uVar4 == 0) {
*(int8 *)*param_1 = 0;
*(int8 *)param_1[1] = 0;
pauVar6 = (int (*) [16])0x0;
}
else {
/* try { // try from 001027d0 to 001027d4 has its CatchHandler @ 001028e6 */
pauVar5 = (int (*) [16])operator_new(uVar4 * 0x18);
pauVar1 = (int (*) [16])((long)pauVar5 + uVar4 * 0x18);
*(int (**) [16])*param_1 = pauVar5;
*(int (**) [16])param_1[1] = pauVar1;
do {
*(int8 *)pauVar5[1] = 0;
pauVar6 = (int (*) [16])(pauVar5[1] + 8);
*pauVar5 = (int [16])0x0;
pauVar5 = pauVar6;
} while (pauVar1 != pauVar6);
}
*(int (**) [16])(*param_1 + 8) = pauVar6;
lVar7 = *param_2;
if (lVar7 != param_2[1]) {
uVar4 = 0;
do {
this = (vector<int,std::allocator<int>> *)
(*(long *)*param_1 +
(long)(int)((long)((ulong)(uint)((int)uVar4 >> 0x1f) << 0x20 | uVar4 & 0xffffffff) %
(long)param_3) * 0x18);
piVar2 = (int *)(lVar7 + uVar4 * 4);
piVar3 = *(int **)(this + 8);
if (piVar3 == *(int **)(this + 0x10)) {
/* try { // try from 00102863 to 00102867 has its CatchHandler @ 001028dd */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)piVar3,piVar2);
lVar7 = *param_2;
}
else {
*piVar3 = *piVar2;
*(int **)(this + 8) = piVar3 + 1;
}
uVar4 = uVar4 + 1;
} while (uVar4 < (ulong)(param_2[1] - lVar7 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
}
else if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 001028bb to 001028bf has its CatchHandler @ 001028e6 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<int,std::allocator<int>>::~vector(local_48);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume();
}
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,059 | func0 |
#include <vector>
#include <string>
#include <cassert>
template <typename T>
| std::vector<std::vector<T>> func0(const std::vector<T>& S, int step) {
std::vector<std::vector<T>> result(step, std::vector<T>());
for(int i = 0; i < S.size(); ++i) {
result[i % step].push_back(S[i]);
}
return result;
}
| int main() {
// Test case 1
std::vector<std::string> S1 = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n"};
std::vector<std::vector<std::string>> expected1 = {
{"a", "d", "g", "j", "m"},
{"b", "e", "h", "k", "n"},
{"c", "f", "i", "l"}
};
assert(func0(S1, 3) == expected1);
// Test case 2
std::vector<int> S2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14};
std::vector<std::vector<int>> expected2 = {
{1,4,7,10,13},
{2,5,8,11,14},
{3,6,9,12}
};
assert(func0(S2, 3) == expected2);
// Test case 3
std::vector<std::string> S3 = {"python","java","C","C++","DBMS","SQL"};
std::vector<std::vector<std::string>> expected3 = {
{"python", "C", "DBMS"},
{"java", "C++", "SQL"}
};
assert(func0(S3, 2) == expected3);
return 0;
}
| O3 | cpp | std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > func0<int>(std::vector<int, std::allocator<int> > const&, int):
endbr64
movabs $0x555555555555555,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
movslq %edx,%rbx
sub $0x28,%rsp
cmp %rax,%rbx
ja 2d58 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x2c8>
pxor %xmm0,%xmm0
lea (%rbx,%rbx,2),%rcx
mov %rdi,%r15
mov %rsi,%r12
mov %rbx,%r13
movq $0x0,0x10(%rdi)
lea 0x0(,%rcx,8),%rbp
movups %xmm0,(%rdi)
test %rbx,%rbx
je 2d20 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x290>
mov %rbp,%rdi
callq 11d0 <_Znwm@plt>
mov %rbx,%rdi
mov %rax,%rsi
movq %rax,%xmm0
lea (%rax,%rbp,1),%rcx
lea -0x1(%rbx),%rax
punpcklqdq %xmm0,%xmm0
mov %rcx,0x10(%r15)
cmp $0x2,%rax
movups %xmm0,(%r15)
mov %rsi,%rax
jbe 2b5e <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xce>
mov %rbx,%rdx
shr %rdi
pxor %xmm0,%xmm0
and $0xfffffffffffffffe,%rdx
add %rdi,%rdx
shl $0x4,%rdx
add %rsi,%rdx
nopl (%rax)
movups %xmm0,(%rax)
add $0x30,%rax
movups %xmm0,-0x20(%rax)
movups %xmm0,-0x10(%rax)
cmp %rdx,%rax
jne 2b30 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0xa0>
mov %rbx,%rdx
mov %rbx,%rdi
and $0xfffffffffffffffe,%rdx
and $0x1,%edi
lea (%rdx,%rdx,2),%rax
lea (%rsi,%rax,8),%rax
cmp %rdx,%rbx
je 2b91 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x101>
pxor %xmm0,%xmm0
movq $0x0,0x10(%rax)
movups %xmm0,(%rax)
cmp $0x1,%rdi
je 2b91 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x101>
movq $0x0,0x28(%rax)
movups %xmm0,0x18(%rax)
cmp $0x2,%rdi
je 2b91 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x101>
movq $0x0,0x40(%rax)
movups %xmm0,0x30(%rax)
mov %rcx,0x8(%r15)
mov (%r12),%rcx
cmp 0x8(%r12),%rcx
je 2cb0 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x220>
xor %ebx,%ebx
jmp 2bde <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x14e>
nopl 0x0(%rax,%rax,1)
mov (%r14),%edx
add $0x4,%rax
mov %edx,-0x4(%rax)
mov %rax,0x8(%rbp)
mov (%r12),%rcx
mov 0x8(%r12),%rax
add $0x1,%rbx
sub %rcx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 2cb0 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x220>
mov (%r15),%rsi
mov %ebx,%eax
lea (%rcx,%rbx,4),%r14
cltd
idiv %r13d
movslq %edx,%rdx
lea (%rdx,%rdx,2),%rax
lea (%rsi,%rax,8),%rbp
mov 0x8(%rbp),%rax
cmp 0x10(%rbp),%rax
jne 2bb0 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x120>
mov 0x0(%rbp),%rdi
sub %rdi,%rax
mov %rdi,0x8(%rsp)
movabs $0x1fffffffffffffff,%rdi
mov %rax,0x18(%rsp)
sar $0x2,%rax
cmp %rdi,%rax
je 2d29 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x299>
test %rax,%rax
je 2d08 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x278>
movabs $0x7ffffffffffffffc,%rsi
lea (%rax,%rax,1),%rdx
mov %rsi,0x10(%rsp)
cmp %rdx,%rax
jbe 2c98 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x208>
mov 0x10(%rsp),%rdi
callq 11d0 <_Znwm@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
add %rax,%r8
mov (%r14),%eax
mov 0x18(%rsp),%rdx
mov %eax,(%rcx,%rdx,1)
lea 0x4(%rcx,%rdx,1),%r14
test %rdx,%rdx
jg 2cc8 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x238>
cmpq $0x0,0x8(%rsp)
jne 2ce2 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x252>
movq %rcx,%xmm0
movq %r14,%xmm1
mov %r8,0x10(%rbp)
punpcklqdq %xmm1,%xmm0
movups %xmm0,0x0(%rbp)
jmpq 2bbe <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x12e>
nopl 0x0(%rax,%rax,1)
test %rdx,%rdx
jne 2d35 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x2a5>
xor %r8d,%r8d
xor %ecx,%ecx
jmp 2c5b <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1cb>
nopl 0x0(%rax,%rax,1)
add $0x28,%rsp
mov %r15,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rsi
mov %rcx,%rdi
mov %r8,0x10(%rsp)
callq 1200 <memmove@plt>
mov 0x10(%rsp),%r8
mov %rax,%rcx
mov 0x8(%rsp),%rdi
mov %rcx,0x18(%rsp)
mov %r8,0x10(%rsp)
callq 11c0 <_ZdlPv@plt>
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%r8
jmpq 2c78 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1e8>
nopl (%rax)
movq $0x4,0x10(%rsp)
jmpq 2c46 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1b6>
nopw %cs:0x0(%rax,%rax,1)
xor %esi,%esi
xor %ecx,%ecx
jmpq 2b91 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x101>
lea 0x1381(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
lea 0x0(,%rdx,4),%rax
mov %rax,0x10(%rsp)
jmpq 2c46 <_Z5func0IiESt6vectorIS0_IT_SaIS1_EESaIS3_EERKS3_i+0x1b6>
lea 0x1321(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbp
mov %r15,%rdi
callq 2a20 <_ZNSt6vectorIS_IiSaIiEESaIS1_EED1Ev>
mov %rbp,%rdi
callq 1220 <_Unwind_Resume@plt>
nopl 0x0(%rax,%rax,1)
| _Z5func0INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIS6_IT_SaIS7_EESaIS9_EERKS9_i:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
movsxd rbx, edx
sub rsp, 48h
mov [rsp+78h+var_6C], edx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movaps [rsp+78h+var_58], xmm0
mov rax, 555555555555555h
mov [rsp+78h+var_48], 0
cmp rax, rbx
jb loc_2D1A
mov qword ptr [rdi+10h], 0
mov r15, rdi
mov r14, rsi
movups xmmword ptr [rdi], xmm0
test rbx, rbx
jz loc_2D02
lea rcx, [rbx+rbx*2]
lea rbp, ds:0[rcx*8]
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+rbp]
cmp [rsp+78h+var_6C], 1
mov [r15], rax
mov rsi, rax
mov [r15+10h], rcx
jz short loc_2BD7
mov rdi, rbx
mov rdx, rbx
pxor xmm0, xmm0
shr rdi, 1
and rdx, 0FFFFFFFFFFFFFFFEh
add rdx, rdi
shl rdx, 4
add rdx, rax
nop dword ptr [rax+00h]
loc_2BB0:
movups xmmword ptr [rax], xmm0
add rax, 30h ; '0'
movups xmmword ptr [rax-20h], xmm0
movups xmmword ptr [rax-10h], xmm0
cmp rdx, rax
jnz short loc_2BB0
test byte ptr [rsp+78h+var_6C], 1
jz short loc_2BE6
and rbx, 0FFFFFFFFFFFFFFFEh
lea rax, [rbx+rbx*2]
lea rax, [rsi+rax*8]
loc_2BD7:
mov qword ptr [rax+10h], 0
pxor xmm0, xmm0
movups xmmword ptr [rax], xmm0
loc_2BE6:
mov [r15+8], rcx
mov rcx, [r14]
cmp rcx, [r14+8]
jz loc_2CE0
lea rax, [rsp+78h+var_58]
xor ebx, ebx
mov [rsp+78h+var_60], rax
jmp short loc_2C60
loc_2C08:
lea rdi, [rbp+10h]
mov r13, [rdx+8]
mov [rbp+0], rdi
mov rax, [rdx]
mov qword ptr [rsp+78h+var_58], r13
mov [rsp+78h+src], rax
cmp r13, 0Fh
ja short loc_2CA0
cmp r13, 1
jnz short loc_2C98
movzx eax, byte ptr [rax]
mov [rbp+10h], al
loc_2C33:
mov [rbp+8], r13
mov byte ptr [rdi+r13], 0
add qword ptr [r12+8], 20h ; ' '
loc_2C42:
mov rcx, [r14]
mov rax, [r14+8]
add rbx, 1
sub rax, rcx
sar rax, 5
cmp rbx, rax
jnb loc_2CE0
mov rsi, [r15]
loc_2C60:
mov eax, ebx
cdq
idiv [rsp+78h+var_6C]
movsxd rdx, edx
lea rax, [rdx+rdx*2]
mov rdx, rbx
lea r12, [rsi+rax*8]
shl rdx, 5
mov rbp, [r12+8]
add rdx, rcx
cmp rbp, [r12+10h]
jnz short loc_2C08
mov rsi, rbp
mov rdi, r12
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJRKS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string const&>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string const&)
jmp short loc_2C42
loc_2C98:
test r13, r13
jz short loc_2C33
jmp short loc_2CBF
loc_2CA0:
mov rsi, [rsp+78h+var_60]
xor edx, edx
mov rdi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+0], rax
mov rdi, rax; dest
mov rax, qword ptr [rsp+78h+var_58]
mov [rbp+10h], rax
loc_2CBF:
mov rsi, [rsp+78h+src]; src
mov rdx, r13; n
call _memcpy
mov r13, qword ptr [rsp+78h+var_58]
mov rdi, [rbp+0]
jmp loc_2C33
loc_2CE0:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_2D50
add rsp, 48h
mov rax, r15
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2D02:
mov qword ptr [rdi], 0
xor esi, esi
xor ecx, ecx
mov qword ptr [rdi+10h], 0
jmp loc_2BE6
loc_2D1A:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_2D50
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_2D36:
lea rdi, [rsp+78h+var_58]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jz short loc_2D7D
loc_2D50:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_2D36
endbr64
mov rbx, rax
mov rdi, r15
call _ZNSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EED2Ev; std::vector<std::vector<std::string>>::~vector()
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_2D50
loc_2D7D:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long * func0<std::string>(long long *a1, long long *a2, int a3)
{
unsigned long long v3; // rbx
unsigned long long v6; // rbp
long long v7; // rax
long long v8; // rcx
long long v9; // rsi
long long v10; // rdx
long long v11; // rcx
long long v12; // rbx
_BYTE *v13; // rdi
size_t v14; // r13
_BYTE *v15; // rax
long long v16; // r12
long long *v17; // rbp
long long v18; // rdx
long long v19; // rax
void *src; // [rsp+8h] [rbp-68h]
__int128 v23; // [rsp+18h] [rbp-58h] BYREF
long long v24; // [rsp+28h] [rbp-48h]
unsigned long long v25; // [rsp+30h] [rbp-40h]
v3 = a3;
v25 = __readfsqword(0x28u);
v23 = 0LL;
v24 = 0LL;
if ( (unsigned long long)a3 > 0x555555555555555LL )
std::__throw_length_error("cannot create std::vector larger than max_size()");
a1[2] = 0LL;
*(_OWORD *)a1 = 0LL;
if ( a3 )
{
v6 = 24LL * a3;
v7 = operator new(v6);
v8 = v7 + v6;
*a1 = v7;
v9 = v7;
a1[2] = v7 + v6;
if ( a3 == 1 )
{
LABEL_8:
*(_QWORD *)(v7 + 16) = 0LL;
*(_OWORD *)v7 = 0LL;
goto LABEL_9;
}
v10 = v7 + 16 * ((v3 >> 1) + (v3 & 0xFFFFFFFFFFFFFFFELL));
do
{
*(_OWORD *)v7 = 0LL;
v7 += 48LL;
*(_OWORD *)(v7 - 32) = 0LL;
*(_OWORD *)(v7 - 16) = 0LL;
}
while ( v10 != v7 );
if ( (a3 & 1) != 0 )
{
v7 = v9 + 24 * (v3 & 0xFFFFFFFFFFFFFFFELL);
goto LABEL_8;
}
}
else
{
*a1 = 0LL;
v9 = 0LL;
v8 = 0LL;
a1[2] = 0LL;
}
LABEL_9:
a1[1] = v8;
v11 = *a2;
if ( *a2 != a2[1] )
{
v12 = 0LL;
while ( 1 )
{
v16 = v9 + 24LL * ((int)v12 % a3);
v17 = *(long long **)(v16 + 8);
v18 = v11 + 32 * v12;
if ( v17 != *(long long **)(v16 + 16) )
break;
std::vector<std::string>::_M_realloc_insert<std::string const&>(v16, *(_QWORD *)(v16 + 8), v18, 0.0);
LABEL_15:
v11 = *a2;
if ( ++v12 >= (unsigned long long)((a2[1] - *a2) >> 5) )
return a1;
v9 = *a1;
}
v13 = v17 + 2;
v14 = *(_QWORD *)(v18 + 8);
*v17 = (long long)(v17 + 2);
v15 = *(_BYTE **)v18;
*(_QWORD *)&v23 = v14;
src = v15;
if ( v14 > 0xF )
{
v19 = std::string::_M_create(v17, &v23, 0LL, 0.0);
*v17 = v19;
v13 = (_BYTE *)v19;
v17[2] = v23;
}
else
{
if ( v14 == 1 )
{
*((_BYTE *)v17 + 16) = *v15;
LABEL_14:
v17[1] = v14;
v13[v14] = 0;
*(_QWORD *)(v16 + 8) += 32LL;
goto LABEL_15;
}
if ( !v14 )
goto LABEL_14;
}
memcpy(v13, src, v14);
v14 = v23;
v13 = (_BYTE *)*v17;
goto LABEL_14;
}
return a1;
} | func0<std::string>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOVSXD RBX,EDX
SUB RSP,0x48
MOV dword ptr [RSP + 0xc],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV RAX,0x555555555555555
MOV qword ptr [RSP + 0x30],0x0
CMP RAX,RBX
JC 0x00102d1a
MOV qword ptr [RDI + 0x10],0x0
MOV R15,RDI
MOV R14,RSI
MOVUPS xmmword ptr [RDI],XMM0
TEST RBX,RBX
JZ 0x00102d02
LEA RCX,[RBX + RBX*0x2]
LEA RBP,[RCX*0x8]
MOV RDI,RBP
LAB_00102b77:
CALL 0x001011f0
LEA RCX,[RAX + RBP*0x1]
CMP dword ptr [RSP + 0xc],0x1
MOV qword ptr [R15],RAX
MOV RSI,RAX
MOV qword ptr [R15 + 0x10],RCX
JZ 0x00102bd7
MOV RDI,RBX
MOV RDX,RBX
PXOR XMM0,XMM0
SHR RDI,0x1
AND RDX,-0x2
ADD RDX,RDI
SHL RDX,0x4
ADD RDX,RAX
NOP dword ptr [RAX]
LAB_00102bb0:
MOVUPS xmmword ptr [RAX],XMM0
ADD RAX,0x30
MOVUPS xmmword ptr [RAX + -0x20],XMM0
MOVUPS xmmword ptr [RAX + -0x10],XMM0
CMP RDX,RAX
JNZ 0x00102bb0
TEST byte ptr [RSP + 0xc],0x1
JZ 0x00102be6
AND RBX,-0x2
LEA RAX,[RBX + RBX*0x2]
LEA RAX,[RSI + RAX*0x8]
LAB_00102bd7:
MOV qword ptr [RAX + 0x10],0x0
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LAB_00102be6:
MOV qword ptr [R15 + 0x8],RCX
MOV RCX,qword ptr [R14]
CMP RCX,qword ptr [R14 + 0x8]
JZ 0x00102ce0
LEA RAX,[RSP + 0x20]
XOR EBX,EBX
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00102c60
LAB_00102c08:
LEA RDI,[RBP + 0x10]
MOV R13,qword ptr [RDX + 0x8]
MOV qword ptr [RBP],RDI
MOV RAX,qword ptr [RDX]
MOV qword ptr [RSP + 0x20],R13
MOV qword ptr [RSP + 0x10],RAX
CMP R13,0xf
JA 0x00102ca0
CMP R13,0x1
JNZ 0x00102c98
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + 0x10],AL
LAB_00102c33:
MOV qword ptr [RBP + 0x8],R13
MOV byte ptr [RDI + R13*0x1],0x0
ADD qword ptr [R12 + 0x8],0x20
LAB_00102c42:
MOV RCX,qword ptr [R14]
MOV RAX,qword ptr [R14 + 0x8]
ADD RBX,0x1
SUB RAX,RCX
SAR RAX,0x5
CMP RBX,RAX
JNC 0x00102ce0
MOV RSI,qword ptr [R15]
LAB_00102c60:
MOV EAX,EBX
CDQ
IDIV dword ptr [RSP + 0xc]
MOVSXD RDX,EDX
LEA RAX,[RDX + RDX*0x2]
MOV RDX,RBX
LEA R12,[RSI + RAX*0x8]
SHL RDX,0x5
MOV RBP,qword ptr [R12 + 0x8]
ADD RDX,RCX
CMP RBP,qword ptr [R12 + 0x10]
JNZ 0x00102c08
MOV RSI,RBP
MOV RDI,R12
LAB_00102c8e:
CALL 0x00102680
JMP 0x00102c42
LAB_00102c98:
TEST R13,R13
JZ 0x00102c33
JMP 0x00102cbf
LAB_00102ca0:
MOV RSI,qword ptr [RSP + 0x18]
XOR EDX,EDX
MOV RDI,RBP
CALL 0x00101270
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RBP + 0x10],RAX
LAB_00102cbf:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,R13
CALL 0x001011e0
MOV R13,qword ptr [RSP + 0x20]
MOV RDI,qword ptr [RBP]
JMP 0x00102c33
LAB_00102ce0:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102d50
ADD RSP,0x48
MOV RAX,R15
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102d02:
MOV qword ptr [RDI],0x0
XOR ESI,ESI
XOR ECX,ECX
MOV qword ptr [RDI + 0x10],0x0
JMP 0x00102be6
LAB_00102d1a:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102d50
LEA RDI,[0x104008]
LAB_00102d31:
CALL 0x001011a0
LAB_00102d36:
LEA RDI,[RSP + 0x20]
CALL 0x00102030
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00102d7d
LAB_00102d50:
CALL 0x00101210
LAB_00102d7d:
MOV RDI,RBX
LAB_00102d80:
CALL 0x00101260 | /* std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > func0<std::string
>(std::vector<std::string, std::allocator<std::string > > const&, int) */
int (*) [16] func0<std::string>(int (*param_1) [16],long *param_2,uint param_3)
{
vector<std::string,std::allocator<std::string>> *this;
int *__src;
ulong *puVar1;
int (*pauVar2) [16];
int (*pauVar3) [16];
int (*pauVar4) [16];
ulong *__dest;
long lVar5;
string *psVar6;
ulong uVar7;
ulong __n;
long in_FS_OFFSET;
int local_58 [16];
int8 local_48;
long local_40;
uVar7 = (ulong)(int)param_3;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = (int [16])0x0;
local_48 = 0;
if (0x555555555555555 < uVar7) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* try { // try from 00102d31 to 00102d35 has its CatchHandler @ 00102d55 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
std::vector<std::string,std::allocator<std::string>>::~vector
((vector<std::string,std::allocator<std::string>> *)local_58);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar7);
}
}
goto LAB_00102d50;
}
*(int8 *)param_1[1] = 0;
*param_1 = (int [16])0x0;
if (uVar7 == 0) {
*(int8 *)*param_1 = 0;
pauVar2 = (int (*) [16])0x0;
lVar5 = 0;
*(int8 *)param_1[1] = 0;
}
else {
/* try { // try from 00102b77 to 00102b7b has its CatchHandler @ 00102d55 */
pauVar2 = (int (*) [16])operator_new(uVar7 * 0x18);
lVar5 = (long)pauVar2 + uVar7 * 0x18;
*(int (**) [16])*param_1 = pauVar2;
*(long *)param_1[1] = lVar5;
pauVar4 = pauVar2;
if (param_3 != 1) {
do {
*pauVar4 = (int [16])0x0;
pauVar3 = pauVar4 + 3;
pauVar4[1] = (int [16])0x0;
pauVar4[2] = (int [16])0x0;
pauVar4 = pauVar3;
} while (pauVar2 + (uVar7 & 0xfffffffffffffffe) + (uVar7 >> 1) != pauVar3);
if ((param_3 & 1) == 0) goto LAB_00102be6;
pauVar4 = (int (*) [16])((long)pauVar2 + (uVar7 & 0xfffffffffffffffe) * 0x18);
}
*(int8 *)pauVar4[1] = 0;
*pauVar4 = (int [16])0x0;
}
LAB_00102be6:
*(long *)(*param_1 + 8) = lVar5;
lVar5 = *param_2;
if (lVar5 != param_2[1]) {
uVar7 = 0;
do {
this = (vector<std::string,std::allocator<std::string>> *)
((long)pauVar2 +
(long)(int)((long)((ulong)(uint)((int)uVar7 >> 0x1f) << 0x20 | uVar7 & 0xffffffff) %
(long)(int)param_3) * 0x18);
puVar1 = *(ulong **)(this + 8);
psVar6 = (string *)(uVar7 * 0x20 + lVar5);
if (puVar1 == *(ulong **)(this + 0x10)) {
/* try { // try from 00102c8e to 00102cae has its CatchHandler @ 00102d5e */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string_const&>
(this,(__normal_iterator)puVar1,psVar6);
}
else {
__dest = puVar1 + 2;
__n = *(ulong *)(psVar6 + 8);
*puVar1 = (ulong)__dest;
__src = *(int **)psVar6;
local_58._0_8_ = __n;
if (__n < 0x10) {
if (__n == 1) {
*(int *)(puVar1 + 2) = *__src;
}
else if (__n != 0) goto LAB_00102cbf;
}
else {
__dest = (ulong *)std::string::_M_create(puVar1,(ulong)local_58);
*puVar1 = (ulong)__dest;
puVar1[2] = local_58._0_8_;
LAB_00102cbf:
memcpy(__dest,__src,__n);
__dest = (ulong *)*puVar1;
__n = local_58._0_8_;
}
puVar1[1] = __n;
*(int *)((long)__dest + __n) = 0;
*(long *)(this + 8) = *(long *)(this + 8) + 0x20;
}
lVar5 = *param_2;
uVar7 = uVar7 + 1;
if ((ulong)(param_2[1] - lVar5 >> 5) <= uVar7) break;
pauVar2 = *(int (**) [16])*param_1;
} while( true );
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
LAB_00102d50:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
1,060 | func0 |
#include <assert.h>
| int func0(int l) {
int LSA = 4 * (l * l);
return LSA;
}
| int main() {
assert(func0(5) == 100);
assert(func0(9) == 324);
assert(func0(10) == 400);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
imul %eax,%eax
shl $0x2,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
imul eax, eax
shl eax, 2
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,EAX
SHL EAX,0x2
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 4;
} |
1,061 | func0 |
#include <assert.h>
| int func0(int l) {
int LSA = 4 * (l * l);
return LSA;
}
| int main() {
assert(func0(5) == 100);
assert(func0(9) == 324);
assert(func0(10) == 400);
return 0;
}
| O1 | cpp | func0(int):
endbr64
imul %edi,%edi
lea 0x0(,%rdi,4),%eax
retq
| _Z5func0i:
endbr64
imul edi, edi
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 4;
} |
1,062 | func0 |
#include <assert.h>
| int func0(int l) {
int LSA = 4 * (l * l);
return LSA;
}
| int main() {
assert(func0(5) == 100);
assert(func0(9) == 324);
assert(func0(10) == 400);
return 0;
}
| O2 | cpp | func0(int):
endbr64
imul %edi,%edi
lea 0x0(,%rdi,4),%eax
retq
| _Z5func0i:
endbr64
imul edi, edi
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 4;
} |
1,063 | func0 |
#include <assert.h>
| int func0(int l) {
int LSA = 4 * (l * l);
return LSA;
}
| int main() {
assert(func0(5) == 100);
assert(func0(9) == 324);
assert(func0(10) == 400);
return 0;
}
| O3 | cpp | func0(int):
endbr64
imul %edi,%edi
lea 0x0(,%rdi,4),%eax
retq
| _Z5func0i:
endbr64
imul edi, edi
lea eax, ds:0[rdi*4]
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1 * a1);
} | func0:
ENDBR64
IMUL EDI,EDI
LEA EAX,[RDI*0x4]
RET | /* func0(int) */
int func0(int param_1)
{
return param_1 * param_1 * 4;
} |
1,064 | func0 |
#include <assert.h>
| int func0(int n) {
return int(n * (4 * n * n - 1) / 3);
}
| int main() {
assert(func0(2) == 10);
assert(func0(3) == 35);
assert(func0(4) == 84);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
shl $0x2,%eax
sub $0x1,%eax
imul -0x4(%rbp),%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%ecx
sub %eax,%ecx
mov %ecx,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
shl eax, 2
sub eax, 1
imul eax, [rbp+var_4]
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
mov eax, edx
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (4 * a1 * a1 - 1) / 3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
SHL EAX,0x2
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * param_1 * 4 + -1) * param_1) / 3;
} |
1,065 | func0 |
#include <assert.h>
| int func0(int n) {
return int(n * (4 * n * n - 1) / 3);
}
| int main() {
assert(func0(2) == 10);
assert(func0(3) == 35);
assert(func0(4) == 84);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
mov %edi,%edx
imul %edi,%edx
lea -0x1(,%rdx,4),%edi
imul %eax,%edi
movslq %edi,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sar $0x1f,%edi
sub %edi,%eax
retq
| _Z5func0i:
endbr64
mov eax, edi
mov edx, edi
imul edx, edi
lea edi, ds:0FFFFFFFFFFFFFFFFh[rdx*4]
imul edi, eax
movsxd rax, edi
imul rax, 55555556h
shr rax, 20h
sar edi, 1Fh
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (4 * a1 * a1 - 1) / 3);
} | func0:
ENDBR64
MOV EAX,EDI
MOV EDX,EDI
IMUL EDX,EDI
LEA EDI,[-0x1 + RDX*0x4]
IMUL EDI,EAX
MOVSXD RAX,EDI
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SAR EDI,0x1f
SUB EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * param_1 * 4 + -1) * param_1) / 3;
} |
1,066 | func0 |
#include <assert.h>
| int func0(int n) {
return int(n * (4 * n * n - 1) / 3);
}
| int main() {
assert(func0(2) == 10);
assert(func0(3) == 35);
assert(func0(4) == 84);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%edx
mov %edi,%eax
imul %edi,%edx
lea -0x1(,%rdx,4),%edi
imul %eax,%edi
movslq %edi,%rax
sar $0x1f,%edi
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sub %edi,%eax
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov edx, edi
mov eax, edi
imul edx, edi
lea edi, ds:0FFFFFFFFFFFFFFFFh[rdx*4]
imul edi, eax
movsxd rax, edi
sar edi, 1Fh
imul rax, 55555556h
shr rax, 20h
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (4 * a1 * a1 - 1) / 3);
} | func0:
ENDBR64
MOV EDX,EDI
MOV EAX,EDI
IMUL EDX,EDI
LEA EDI,[-0x1 + RDX*0x4]
IMUL EDI,EAX
MOVSXD RAX,EDI
SAR EDI,0x1f
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SUB EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * param_1 * 4 + -1) * param_1) / 3;
} |
1,067 | func0 |
#include <assert.h>
| int func0(int n) {
return int(n * (4 * n * n - 1) / 3);
}
| int main() {
assert(func0(2) == 10);
assert(func0(3) == 35);
assert(func0(4) == 84);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%edx
mov %edi,%eax
imul %edi,%edx
lea -0x1(,%rdx,4),%edi
imul %eax,%edi
movslq %edi,%rax
sar $0x1f,%edi
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sub %edi,%eax
retq
nopl 0x0(%rax)
| _Z5func0i:
endbr64
mov edx, edi
mov eax, edi
imul edx, edi
lea edi, ds:0FFFFFFFFFFFFFFFFh[rdx*4]
imul edi, eax
movsxd rax, edi
sar edi, 1Fh
imul rax, 55555556h
shr rax, 20h
sub eax, edi
retn | long long func0(int a1)
{
return (unsigned int)(a1 * (4 * a1 * a1 - 1) / 3);
} | func0:
ENDBR64
MOV EDX,EDI
MOV EAX,EDI
IMUL EDX,EDI
LEA EDI,[-0x1 + RDX*0x4]
IMUL EDI,EAX
MOVSXD RAX,EDI
SAR EDI,0x1f
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SUB EAX,EDI
RET | /* func0(int) */
int func0(int param_1)
{
return ((param_1 * param_1 * 4 + -1) * param_1) / 3;
} |
1,068 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (6 * n * (n - 1) + 1);
}
| int main() {
assert(func0(3) == 37);
assert(func0(4) == 73);
assert(func0(5) == 121);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
imul -0x4(%rbp),%eax
mov %eax,%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
add %eax,%eax
add $0x1,%eax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
sub eax, 1
imul eax, [rbp+var_4]
mov edx, eax
mov eax, edx
add eax, eax
add eax, edx
add eax, eax
add eax, 1
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
ADD EAX,EAX
ADD EAX,0x1
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
return (param_1 + -1) * param_1 * 6 + 1;
} |
1,069 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (6 * n * (n - 1) + 1);
}
| int main() {
assert(func0(3) == 37);
assert(func0(4) == 73);
assert(func0(5) == 121);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
lea -0x1(%rdi),%edi
imul %eax,%edi
lea (%rdi,%rdi,2),%eax
lea 0x1(%rax,%rax,1),%eax
retq
| _Z5func0i:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2]
lea eax, [rax+rax+1]
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2]
LEA EAX,[RAX + RAX*0x1 + 0x1]
RET | /* func0(int) */
int func0(int param_1)
{
return (param_1 + -1) * param_1 * 6 + 1;
} |
1,070 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (6 * n * (n - 1) + 1);
}
| int main() {
assert(func0(3) == 37);
assert(func0(4) == 73);
assert(func0(5) == 121);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%r8d
lea -0x1(%rdi),%edi
imul %r8d,%edi
lea (%rdi,%rdi,2),%eax
lea 0x1(%rax,%rax,1),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2]
lea eax, [rax+rax+1]
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2]
LEA EAX,[RAX + RAX*0x1 + 0x1]
RET | /* func0(int) */
int func0(int param_1)
{
return (param_1 + -1) * param_1 * 6 + 1;
} |
1,071 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
return (6 * n * (n - 1) + 1);
}
| int main() {
assert(func0(3) == 37);
assert(func0(4) == 73);
assert(func0(5) == 121);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%r8d
lea -0x1(%rdi),%edi
imul %r8d,%edi
lea (%rdi,%rdi,2),%eax
lea 0x1(%rax,%rax,1),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
lea eax, [rdi-1]
imul eax, edi
lea eax, [rax+rax*2]
lea eax, [rax+rax+1]
retn | long long func0(int a1)
{
return (unsigned int)(6 * a1 * (a1 - 1) + 1);
} | func0:
ENDBR64
LEA EAX,[RDI + -0x1]
IMUL EAX,EDI
LEA EAX,[RAX + RAX*0x2]
LEA EAX,[RAX + RAX*0x1 + 0x1]
RET | /* func0(int) */
int func0(int param_1)
{
return (param_1 + -1) * param_1 * 6 + 1;
} |
1,072 | func0 |
#include <assert.h>
| int func0(char k) {
return int(k);
}
| int main() {
assert(func0('A') == 65);
assert(func0('R') == 82);
assert(func0('S') == 83);
return 0;
}
| O0 | cpp | func0(char):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,%eax
mov %al,-0x4(%rbp)
movsbl -0x4(%rbp),%eax
pop %rbp
retq
| _Z5func0c:
endbr64
push rbp
mov rbp, rsp
mov eax, edi
mov [rbp+var_4], al
movsx eax, [rbp+var_4]
pop rbp
retn | long long func0(char a1)
{
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
MOV byte ptr [RBP + -0x4],AL
MOVSX EAX,byte ptr [RBP + -0x4]
POP RBP
RET | /* func0(char) */
int func0(char param_1)
{
return (int)param_1;
} |
1,073 | func0 |
#include <assert.h>
| int func0(char k) {
return int(k);
}
| int main() {
assert(func0('A') == 65);
assert(func0('R') == 82);
assert(func0('S') == 83);
return 0;
}
| O1 | cpp | func0(char):
endbr64
movsbl %dil,%eax
retq
| _Z5func0c:
endbr64
movsx eax, dil
retn | long long func0(char a1)
{
return (unsigned int)a1;
} | func0:
ENDBR64
MOVSX EAX,DIL
RET | /* func0(char) */
int func0(char param_1)
{
return (int)param_1;
} |
1,074 | func0 |
#include <assert.h>
| int func0(char k) {
return int(k);
}
| int main() {
assert(func0('A') == 65);
assert(func0('R') == 82);
assert(func0('S') == 83);
return 0;
}
| O2 | cpp | func0(char):
endbr64
movsbl %dil,%eax
retq
nopl 0x0(%rax)
| _Z5func0c:
endbr64
movsx eax, dil
retn | long long func0(char a1)
{
return (unsigned int)a1;
} | func0:
ENDBR64
MOVSX EAX,DIL
RET | /* func0(char) */
int func0(char param_1)
{
return (int)param_1;
} |
1,075 | func0 |
#include <assert.h>
| int func0(char k) {
return int(k);
}
| int main() {
assert(func0('A') == 65);
assert(func0('R') == 82);
assert(func0('S') == 83);
return 0;
}
| O3 | cpp | func0(char):
endbr64
movsbl %dil,%eax
retq
nopl 0x0(%rax)
| _Z5func0c:
endbr64
movsx eax, dil
retn | long long func0(char a1)
{
return (unsigned int)a1;
} | func0:
ENDBR64
MOVSX EAX,DIL
RET | /* func0(char) */
int func0(char param_1)
{
return (int)param_1;
} |
1,076 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i += 2) {
if (arr[i] % 2 == 0) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {5, 6, 12, 1, 18, 8};
int arr2[] = {3, 20, 17, 9, 2, 10, 18, 13, 6, 18};
int arr3[] = {5, 6, 12, 1};
assert(func0(arr1, 6) == 30);
assert(func0(arr2, 10) == 26);
assert(func0(arr3, 4) == 12);
return 0;
}
| O0 | cpp | func0(int*, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 120a <_Z5func0Pii+0x61>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 1204 <_Z5func0Pii+0x5b>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x2,-0x4(%rbp)
jmp 11c6 <_Z5func0Pii+0x1d>
mov -0x8(%rbp),%eax
pop %rbp
retq
| _Z5func0Pii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11C2
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11BE
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11BE:
add [rbp+var_4], 2
loc_11C2:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn | long long func0(int *a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; i += 2 )
{
if ( (a1[i] & 1) == 0 )
v3 += a1[i];
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c2
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011be
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011be:
ADD dword ptr [RBP + -0x4],0x2
LAB_001011c2:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET | /* func0(int*, int) */
int func0(int *param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 2) {
if ((param_1[local_c] & 1U) == 0) {
local_10 = local_10 + param_1[local_c];
}
}
return local_10;
} |
1,077 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i += 2) {
if (arr[i] % 2 == 0) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {5, 6, 12, 1, 18, 8};
int arr2[] = {3, 20, 17, 9, 2, 10, 18, 13, 6, 18};
int arr3[] = {5, 6, 12, 1};
assert(func0(arr1, 6) == 30);
assert(func0(arr2, 10) == 26);
assert(func0(arr3, 4) == 12);
return 0;
}
| O1 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 11dc <_Z5func0Pii+0x33>
mov %rdi,%rax
sub $0x1,%esi
shr %esi
mov %esi,%esi
lea 0x8(%rdi,%rsi,8),%rdi
mov $0x0,%edx
mov (%rax),%ecx
lea (%rdx,%rcx,1),%esi
test $0x1,%cl
cmove %esi,%edx
add $0x8,%rax
cmp %rdi,%rax
jne 11c5 <_Z5func0Pii+0x1c>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 11d9 <_Z5func0Pii+0x30>
| _Z5func0Pii:
endbr64
test esi, esi
jle short loc_119C
mov rax, rdi
sub esi, 1
shr esi, 1
mov esi, esi
lea rdi, [rdi+rsi*8+8]
mov edx, 0
loc_1185:
mov ecx, [rax]
lea esi, [rdx+rcx]
test cl, 1
cmovz edx, esi
add rax, 8
cmp rax, rdi
jnz short loc_1185
loc_1199:
mov eax, edx
retn
loc_119C:
mov edx, 0
jmp short loc_1199 | long long func0(int *a1, int a2)
{
int *v2; // rax
int *v3; // rdi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
v4 = 0;
do
{
if ( (*v2 & 1) == 0 )
v4 += *v2;
v2 += 2;
}
while ( v2 != v3 );
}
return v4;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119c
MOV RAX,RDI
SUB ESI,0x1
SHR ESI,0x1
MOV ESI,ESI
LEA RDI,[RDI + RSI*0x8 + 0x8]
MOV EDX,0x0
LAB_00101185:
MOV ECX,dword ptr [RAX]
LEA ESI,[RDX + RCX*0x1]
TEST CL,0x1
CMOVZ EDX,ESI
ADD RAX,0x8
CMP RAX,RDI
JNZ 0x00101185
LAB_00101199:
MOV EAX,EDX
RET
LAB_0010119c:
MOV EDX,0x0
JMP 0x00101199 | /* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
puVar1 = (uint *)(param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2);
iVar2 = 0;
do {
if ((*param_1 & 1U) == 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = (int *)((uint *)param_1 + 2);
} while ((uint *)param_1 != puVar1);
}
return iVar2;
} |
1,078 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i += 2) {
if (arr[i] % 2 == 0) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {5, 6, 12, 1, 18, 8};
int arr2[] = {3, 20, 17, 9, 2, 10, 18, 13, 6, 18};
int arr3[] = {5, 6, 12, 1};
assert(func0(arr1, 6) == 30);
assert(func0(arr2, 10) == 26);
assert(func0(arr3, 4) == 12);
return 0;
}
| O2 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 12f0 <_Z5func0Pii+0x30>
sub $0x1,%esi
xor %eax,%eax
shr %esi
lea 0x8(%rdi,%rsi,8),%rsi
nopl 0x0(%rax)
mov (%rdi),%edx
lea (%rax,%rdx,1),%ecx
and $0x1,%edx
cmove %ecx,%eax
add $0x8,%rdi
cmp %rsi,%rdi
jne 12d8 <_Z5func0Pii+0x18>
retq
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0Pii:
endbr64
test esi, esi
jle short loc_12A0
sub esi, 1
xor eax, eax
shr esi, 1
lea rsi, [rdi+rsi*8+8]
nop dword ptr [rax+00h]
loc_1288:
mov edx, [rdi]
lea ecx, [rax+rdx]
and edx, 1
cmovz eax, ecx
add rdi, 8
cmp rsi, rdi
jnz short loc_1288
retn
loc_12A0:
xor eax, eax
retn | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rsi
if ( a2 <= 0 )
return 0LL;
result = 0LL;
v3 = &a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
do
{
if ( (*a1 & 1) == 0 )
result = (unsigned int)(result + *a1);
a1 += 2;
}
while ( v3 != a1 );
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012a0
SUB ESI,0x1
XOR EAX,EAX
SHR ESI,0x1
LEA RSI,[RDI + RSI*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_00101288:
MOV EDX,dword ptr [RDI]
LEA ECX,[RAX + RDX*0x1]
AND EDX,0x1
CMOVZ EAX,ECX
ADD RDI,0x8
CMP RSI,RDI
JNZ 0x00101288
RET
LAB_001012a0:
XOR EAX,EAX
RET | /* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
puVar1 = (uint *)(param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2);
do {
if ((*param_1 & 1U) == 0) {
iVar2 = iVar2 + *param_1;
}
param_1 = (int *)((uint *)param_1 + 2);
} while (puVar1 != (uint *)param_1);
return iVar2;
}
return 0;
} |
1,079 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int n) {
int sum = 0;
for(int i = 0; i < n; i += 2) {
if (arr[i] % 2 == 0) {
sum += arr[i];
}
}
return sum;
}
| int main() {
int arr1[] = {5, 6, 12, 1, 18, 8};
int arr2[] = {3, 20, 17, 9, 2, 10, 18, 13, 6, 18};
int arr3[] = {5, 6, 12, 1};
assert(func0(arr1, 6) == 30);
assert(func0(arr2, 10) == 26);
assert(func0(arr3, 4) == 12);
return 0;
}
| O3 | cpp | func0(int*, int):
endbr64
test %esi,%esi
jle 13a8 <_Z5func0Pii+0xe8>
lea -0x1(%rsi),%edx
cmp $0x7,%edx
jbe 13ab <_Z5func0Pii+0xeb>
shr $0x3,%edx
pxor %xmm2,%xmm2
movdqa 0xd89(%rip),%xmm4
mov %rdi,%rax
mov %edx,%ecx
movdqa %xmm2,%xmm3
shl $0x5,%rcx
add %rdi,%rcx
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
movdqu 0x10(%rax),%xmm5
add $0x20,%rax
shufps $0x88,%xmm5,%xmm1
movdqa %xmm1,%xmm0
pand %xmm4,%xmm0
pcmpeqd %xmm3,%xmm0
pand %xmm1,%xmm0
paddd %xmm0,%xmm2
cmp %rcx,%rax
jne 1300 <_Z5func0Pii+0x40>
movdqa %xmm2,%xmm0
shl $0x3,%edx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm2
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%eax
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
and $0x1,%ecx
lea 0x2(%rdx),%ecx
cmove %r8d,%eax
cmp %ecx,%esi
jle 13aa <_Z5func0Pii+0xea>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
and $0x1,%ecx
lea 0x4(%rdx),%ecx
cmove %r8d,%eax
cmp %esi,%ecx
jge 13aa <_Z5func0Pii+0xea>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
lea (%rax,%rcx,1),%r8d
and $0x1,%ecx
cmove %r8d,%eax
add $0x6,%edx
cmp %edx,%esi
jle 13aa <_Z5func0Pii+0xea>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
lea (%rax,%rdx,1),%ecx
and $0x1,%edx
cmove %ecx,%eax
retq
nopl 0x0(%rax,%rax,1)
xor %eax,%eax
retq
xor %edx,%edx
xor %eax,%eax
jmp 134b <_Z5func0Pii+0x8b>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0Pii:
endbr64
test esi, esi
jle loc_1230
lea edx, [rsi-1]
cmp edx, 7
jbe loc_1233
shr edx, 3
pxor xmm2, xmm2
movdqa xmm4, cs:xmmword_2010
mov rax, rdi
mov ecx, edx
movdqa xmm3, xmm2
shl rcx, 5
add rcx, rdi
nop word ptr [rax+rax+00000000h]
loc_1180:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm5, xmmword ptr [rax+10h]
add rax, 20h ; ' '
shufps xmm1, xmm5, 88h
movdqa xmm0, xmm1
pand xmm0, xmm4
pcmpeqd xmm0, xmm3
pand xmm0, xmm1
paddd xmm2, xmm0
cmp rcx, rax
jnz short loc_1180
movdqa xmm0, xmm2
shl edx, 3
psrldq xmm0, 8
paddd xmm2, xmm0
movdqa xmm0, xmm2
psrldq xmm0, 4
paddd xmm2, xmm0
movd eax, xmm2
loc_11CB:
movsxd r8, edx
lea rcx, ds:0[r8*4]
mov r8d, [rdi+r8*4]
lea r9d, [rax+r8]
and r8d, 1
lea r8d, [rdx+2]
cmovz eax, r9d
cmp esi, r8d
jle short locret_1232
mov r8d, [rdi+rcx+8]
lea r9d, [rax+r8]
and r8d, 1
lea r8d, [rdx+4]
cmovz eax, r9d
cmp esi, r8d
jle short locret_1232
mov r8d, [rdi+rcx+10h]
lea r9d, [rax+r8]
and r8d, 1
cmovz eax, r9d
add edx, 6
cmp edx, esi
jge short locret_1232
mov edx, [rdi+rcx+18h]
lea ecx, [rax+rdx]
and edx, 1
cmovz eax, ecx
retn
loc_1230:
xor eax, eax
locret_1232:
retn
loc_1233:
xor edx, edx
xor eax, eax
jmp short loc_11CB | long long func0(const __m128i *a1, int a2)
{
unsigned int v2; // edx
__m128i v3; // xmm2
__m128i si128; // xmm4
const __m128i *v5; // rax
__m128 v6; // xmm1
__m128 v7; // xmm5
__m128i v8; // xmm1
int v9; // edx
__m128i v10; // xmm2
long long result; // rax
long long v12; // rcx
int v13; // r8d
int v14; // r8d
int v15; // r8d
int v16; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 7 )
{
v9 = 0;
result = 0LL;
}
else
{
v2 = (unsigned int)(a2 - 1) >> 3;
v3 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v5 = a1;
do
{
v6 = (__m128)_mm_loadu_si128(v5);
v7 = (__m128)_mm_loadu_si128(v5 + 1);
v5 += 2;
v8 = (__m128i)_mm_shuffle_ps(v6, v7, 136);
v3 = _mm_add_epi32(v3, _mm_and_si128(_mm_cmpeq_epi32(_mm_and_si128(v8, si128), (__m128i)0LL), v8));
}
while ( &a1[2 * v2] != v5 );
v9 = 8 * v2;
v10 = _mm_add_epi32(v3, _mm_srli_si128(v3, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v10, _mm_srli_si128(v10, 4)));
}
v12 = v9;
v13 = a1->m128i_i32[v12];
if ( (v13 & 1) == 0 )
result = (unsigned int)(result + v13);
if ( a2 > v9 + 2 )
{
v14 = a1->m128i_i32[v12 + 2];
if ( (v14 & 1) == 0 )
result = (unsigned int)(result + v14);
if ( a2 > v9 + 4 )
{
v15 = a1[1].m128i_i32[v12];
if ( (v15 & 1) == 0 )
result = (unsigned int)(result + v15);
if ( v9 + 6 < a2 )
{
v16 = a1[1].m128i_i32[v12 + 2];
if ( (v16 & 1) == 0 )
return (unsigned int)(result + v16);
}
}
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101230
LEA EDX,[RSI + -0x1]
CMP EDX,0x7
JBE 0x00101233
SHR EDX,0x3
PXOR XMM2,XMM2
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RDI
MOV ECX,EDX
MOVDQA XMM3,XMM2
SHL RCX,0x5
ADD RCX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101180:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM5,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
SHUFPS XMM1,XMM5,0x88
MOVDQA XMM0,XMM1
PAND XMM0,XMM4
PCMPEQD XMM0,XMM3
PAND XMM0,XMM1
PADDD XMM2,XMM0
CMP RCX,RAX
JNZ 0x00101180
MOVDQA XMM0,XMM2
SHL EDX,0x3
PSRLDQ XMM0,0x8
PADDD XMM2,XMM0
MOVDQA XMM0,XMM2
PSRLDQ XMM0,0x4
PADDD XMM2,XMM0
MOVD EAX,XMM2
LAB_001011cb:
MOVSXD R8,EDX
LEA RCX,[R8*0x4]
MOV R8D,dword ptr [RDI + R8*0x4]
LEA R9D,[RAX + R8*0x1]
AND R8D,0x1
LEA R8D,[RDX + 0x2]
CMOVZ EAX,R9D
CMP ESI,R8D
JLE 0x00101232
MOV R8D,dword ptr [RDI + RCX*0x1 + 0x8]
LEA R9D,[RAX + R8*0x1]
AND R8D,0x1
LEA R8D,[RDX + 0x4]
CMOVZ EAX,R9D
CMP ESI,R8D
JLE 0x00101232
MOV R8D,dword ptr [RDI + RCX*0x1 + 0x10]
LEA R9D,[RAX + R8*0x1]
AND R8D,0x1
CMOVZ EAX,R9D
ADD EDX,0x6
CMP EDX,ESI
JGE 0x00101232
MOV EDX,dword ptr [RDI + RCX*0x1 + 0x18]
LEA ECX,[RAX + RDX*0x1]
AND EDX,0x1
CMOVZ EAX,ECX
RET
LAB_00101230:
XOR EAX,EAX
LAB_00101232:
RET
LAB_00101233:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011cb | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int*, int) */
int func0(int *param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint uVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
if (param_2 < 1) {
iVar8 = 0;
}
else {
if (param_2 - 1U < 8) {
iVar7 = 0;
iVar8 = 0;
}
else {
uVar6 = param_2 - 1U >> 3;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
puVar5 = (uint *)param_1;
do {
uVar2 = *puVar5;
puVar3 = puVar5 + 2;
puVar1 = puVar5 + 4;
puVar4 = puVar5 + 6;
puVar5 = puVar5 + 8;
iVar8 = iVar8 + (-(uint)((uVar2 & _DAT_00102010) == 0) & uVar2);
iVar9 = iVar9 + (-(uint)((*puVar3 & _UNK_00102014) == 0) & *puVar3);
iVar10 = iVar10 + (-(uint)((*puVar1 & _UNK_00102018) == 0) & *puVar1);
iVar11 = iVar11 + (-(uint)((*puVar4 & _UNK_0010201c) == 0) & *puVar4);
} while ((uint *)(param_1 + (ulong)uVar6 * 8) != puVar5);
iVar7 = uVar6 << 3;
iVar8 = iVar8 + iVar10 + iVar9 + iVar11;
}
if ((param_1[iVar7] & 1U) == 0) {
iVar8 = iVar8 + param_1[iVar7];
}
if (iVar7 + 2 < param_2) {
if ((param_1[(long)iVar7 + 2] & 1U) == 0) {
iVar8 = iVar8 + param_1[(long)iVar7 + 2];
}
if (iVar7 + 4 < param_2) {
if ((param_1[(long)iVar7 + 4] & 1U) == 0) {
iVar8 = iVar8 + param_1[(long)iVar7 + 4];
}
if (iVar7 + 6 < param_2) {
if ((param_1[(long)iVar7 + 6] & 1U) == 0) {
iVar8 = iVar8 + param_1[(long)iVar7 + 6];
}
return iVar8;
}
}
}
}
return iVar8;
} |
1,080 | func0 |
#include <assert.h>
| long long func0(int n) {
long long sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += (long long)j * j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 1056);
assert(func0(3) == 8832);
assert(func0(1) == 32);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movq $0x0,-0x8(%rbp)
movl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 11a7 <_Z5func0i+0x5e>
mov -0x10(%rbp),%eax
add %eax,%eax
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov -0xc(%rbp),%eax
cltq
imul %rax,%rdx
mov -0xc(%rbp),%eax
cltq
imul %rax,%rdx
mov -0xc(%rbp),%eax
cltq
imul %rax,%rdx
mov -0xc(%rbp),%eax
cltq
imul %rdx,%rax
add %rax,-0x8(%rbp)
addl $0x1,-0x10(%rbp)
jmp 1163 <_Z5func0i+0x1a>
mov -0x8(%rbp),%rax
pop %rbp
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_10], 1
jmp short loc_119F
loc_1165:
mov eax, [rbp+var_10]
add eax, eax
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
movsxd rdx, eax
mov eax, [rbp+var_C]
cdqe
imul rdx, rax
mov eax, [rbp+var_C]
cdqe
imul rdx, rax
mov eax, [rbp+var_C]
cdqe
imul rdx, rax
mov eax, [rbp+var_C]
cdqe
imul rax, rdx
add [rbp+var_8], rax
add [rbp+var_10], 1
loc_119F:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jle short loc_1165
mov rax, [rbp+var_8]
pop rbp
retn | long long func0(int a1)
{
int i; // [rsp+4h] [rbp-10h]
long long v3; // [rsp+Ch] [rbp-8h]
v3 = 0LL;
for ( i = 1; i <= a1; ++i )
v3 += 2 * i * 2 * i * 2 * i * (long long)(2 * i) * 2 * i;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x10],0x1
JMP 0x0010119f
LAB_00101165:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,EAX
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
IMUL RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
IMUL RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
IMUL RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
IMUL RAX,RDX
ADD qword ptr [RBP + -0x8],RAX
ADD dword ptr [RBP + -0x10],0x1
LAB_0010119f:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101165
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET | /* func0(int) */
long func0(int param_1)
{
int iVar1;
int4 local_18;
int8 local_10;
local_10 = 0;
for (local_18 = 1; local_18 <= param_1; local_18 = local_18 + 1) {
iVar1 = local_18 * 2;
local_10 = local_10 + (long)iVar1 * (long)iVar1 * (long)iVar1 * (long)iVar1 * (long)iVar1;
}
return local_10;
} |
1,081 | func0 |
#include <assert.h>
| long long func0(int n) {
long long sum = 0;
for (int i = 1; i <= n; i++) {
int j = 2 * i;
sum += (long long)j * j * j * j * j;
}
return sum;
}
| int main() {
assert(func0(2) == 1056);
assert(func0(3) == 8832);
assert(func0(1) == 32);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1182 <_Z5func0i+0x39>
lea -0x1(%rdi),%eax
lea 0x4(%rax,%rax,1),%rsi
mov $0x2,%edx
mov $0x0,%ecx
mov %rdx,%rax
imul %rdx,%rax
imul %rax,%rax
imul %rdx,%rax
add %rax,%rcx
add $0x2,%rdx
cmp %rsi,%rdx
jne 1163 <_Z5func0i+0x1a>
mov %rcx,%rax
retq
mov $0x0,%ecx
jmp 117e <_Z5func0i+0x35>
| _Z5func0i:
endbr64
test edi, edi
jle short loc_1180
lea esi, [rdi+1]
add rsi, rsi
mov edx, 2
mov ecx, 0
loc_1161:
mov rax, rdx
imul rax, rdx
imul rax, rax
imul rax, rdx
add rcx, rax
add rdx, 2
cmp rdx, rsi
jnz short loc_1161
loc_117C:
mov rax, rcx
retn
loc_1180:
mov ecx, 0
jmp short loc_117C | long long func0(int a1)
{
long long v1; // rdx
long long v2; // rcx
if ( a1 <= 0 )
return 0LL;
v1 = 2LL;
v2 = 0LL;
do
{
v2 += v1 * v1 * v1 * v1 * v1;
v1 += 2LL;
}
while ( v1 != 2LL * (unsigned int)(a1 + 1) );
return v2;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101180
LEA ESI,[RDI + 0x1]
ADD RSI,RSI
MOV EDX,0x2
MOV ECX,0x0
LAB_00101161:
MOV RAX,RDX
IMUL RAX,RDX
IMUL RAX,RAX
IMUL RAX,RDX
ADD RCX,RAX
ADD RDX,0x2
CMP RDX,RSI
JNZ 0x00101161
LAB_0010117c:
MOV RAX,RCX
RET
LAB_00101180:
MOV ECX,0x0
JMP 0x0010117c | /* func0(int) */
long func0(int param_1)
{
long lVar1;
long lVar2;
if (param_1 < 1) {
lVar1 = 0;
}
else {
lVar2 = 2;
lVar1 = 0;
do {
lVar1 = lVar1 + lVar2 * lVar2 * lVar2 * lVar2 * lVar2;
lVar2 = lVar2 + 2;
} while (lVar2 != (ulong)(param_1 + 1) * 2);
}
return lVar1;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.