index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
2,882 | func0 | #include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| double func0(vector<vector<int>> cost, int N) {
vector<vector<int>> dp(N, vector<int>(N, 0));
dp[0][0] = cost[0][0];
for (int i = 1; i < N; i++) {
dp[i][0] = dp[i - 1][0] + cost[i][0];
}
for (int j = 1; j < N; j++) {
dp[0][j] = dp[0][j - 1] + cost[0][j];
}
for (int i = 1; i < N; i++) {
for (int j = 1; j < N; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + cost[i][j];
}
}
return static_cast<double>(dp[N - 1][N - 1]) / (2 * N - 1);
}
| int main() {
assert(func0({{1, 2, 3}, {6, 5, 4}, {7, 3, 9}}, 3) == 5.2);
assert(func0({{2, 3, 4}, {7, 6, 5}, {8, 4, 10}}, 3) == 6.2);
assert(func0({{3, 4, 5}, {8, 7, 6}, {9, 5, 11}}, 3) == 7.2);
cout << "All assertions passed." << endl;
return 0;
}
| O2 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
push %r12
push %rbp
movslq %esi,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,0x18(%rsp)
mov %ebp,0x14(%rsp)
cmp %rax,%rbp
ja 1b0c <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x25c>
test %rbp,%rbp
je 1a6a <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1ba>
lea 0x0(,%rbp,4),%r12
mov %r12,%rdi
callq 11c0 <_Znwm@plt>
mov %rax,%r15
lea (%rax,%r12,1),%rdx
nopl 0x0(%rax)
movl $0x0,(%rax)
add $0x4,%rax
cmp %rdx,%rax
jne 1908 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x58>
lea 0x0(%rbp,%rbp,2),%rdi
shl $0x3,%rdi
callq 11c0 <_Znwm@plt>
mov %rax,%r13
mov %r12,%rax
sar $0x2,%rax
mov %r13,%rbx
mov %rax,0x8(%rsp)
jmp 1982 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0xd2>
nopl 0x0(%rax)
movabs $0x1fffffffffffffff,%rsi
cmp %rsi,%rax
ja 1b07 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x257>
mov %r12,%rdi
callq 11c0 <_Znwm@plt>
mov %rax,%rdi
lea (%rdi,%r12,1),%r14
mov %rdi,(%rbx)
mov %r12,%rdx
mov %r15,%rsi
mov %r14,0x10(%rbx)
add $0x18,%rbx
callq 1190 <memcpy@plt>
mov %r14,-0x10(%rbx)
sub $0x1,%rbp
je 19b0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x100>
mov 0x8(%rsp),%rax
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
test %rax,%rax
jne 1940 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x90>
xor %edi,%edi
jmp 195e <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0xae>
nopw 0x0(%rax,%rax,1)
mov %r15,%rdi
callq 11b0 <_ZdlPv@plt>
mov 0x18(%rsp),%rax
mov 0x0(%r13),%r10
cmpl $0x1,0x14(%rsp)
mov (%rax),%r11
mov (%r11),%rdi
mov (%rdi),%eax
mov %eax,(%r10)
jle 1a90 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1e0>
mov 0x14(%rsp),%esi
mov $0x18,%r9d
sub $0x2,%esi
lea 0x3(%rsi,%rsi,2),%rcx
shl $0x3,%rcx
jmp 19f4 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x144>
add $0x18,%r9
mov (%r11,%r9,1),%rdx
add (%rdx),%eax
mov 0x0(%r13,%r9,1),%rdx
mov %eax,(%rdx)
cmp %r9,%rcx
jne 19f0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x140>
add $0x2,%rsi
mov $0x1,%eax
mov (%rdi,%rax,4),%edx
add -0x4(%r10,%rax,4),%edx
mov %edx,(%r10,%rax,4)
add $0x1,%rax
cmp %rax,%rsi
jne 1a10 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x160>
mov %r10,%rdi
mov $0x18,%ebp
nopl (%rax)
mov 0x0(%r13,%rbp,1),%rcx
mov (%r11,%rbp,1),%r8
mov $0x1,%eax
xchg %ax,%ax
mov (%rdi,%rax,4),%edx
cmp %edx,-0x4(%rcx,%rax,4)
cmovge -0x4(%rcx,%rax,4),%edx
add (%r8,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
add $0x1,%rax
cmp %rsi,%rax
jne 1a40 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x190>
cmp %rbp,%r9
je 1a90 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1e0>
add $0x18,%rbp
mov %rcx,%rdi
jmp 1a30 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x180>
mov 0x18(%rsp),%rax
mov 0x0,%r10
xor %r13d,%r13d
xor %ebx,%ebx
mov (%rax),%rax
mov (%rax),%rax
mov (%rax),%eax
mov %eax,(%r10)
nopw 0x0(%rax,%rax,1)
mov 0x14(%rsp),%esi
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
lea -0x1(%rsi),%eax
cltq
lea (%rax,%rax,2),%rdx
mov 0x0(%r13,%rdx,8),%rdx
cvtsi2sdl (%rdx,%rax,4),%xmm1
lea -0x1(%rsi,%rsi,1),%eax
cvtsi2sd %eax,%xmm0
divsd %xmm0,%xmm1
movsd %xmm1,0x8(%rsp)
cmp %r13,%rbx
je 1aea <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x23a>
mov %r13,%rbp
jmp 1ad4 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x224>
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp),%r10
test %r10,%r10
je 1ae1 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x231>
mov %r10,%rdi
callq 11b0 <_ZdlPv@plt>
add $0x18,%rbp
cmp %rbp,%rbx
jne 1ad0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x220>
mov %r13,%rdi
callq 11b0 <_ZdlPv@plt>
movsd 0x8(%rsp),%xmm0
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1140 <_ZSt17__throw_bad_allocv@plt>
lea 0x4f5(%rip),%rdi
callq 1170 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rdi
jmpq 1240 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi.cold>
endbr64
mov %rax,%rbp
jmpq 1266 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi.cold+0x26>
| _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
sub rsp, 58h
mov [rsp+88h+var_88], rdi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
mov rax, rbp
shr rax, 3Dh
jnz loc_1C51
pxor xmm0, xmm0
lea r13, [rbp+rbp*2+0]
mov r12, rbp
movups [rsp+88h+var_58+8], xmm0
shl r13, 3
test rbp, rbp
jz loc_1C36
lea r15, ds:0[rbp*4]
mov rdi, r15; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r15; n
xor esi, esi; c
lea rbx, [rax+r15]
mov rdi, rax; s
mov qword ptr [rsp+88h+var_58], rax
mov r14, rax
mov [rsp+88h+var_48], rbx
call _memset
pxor xmm0, xmm0
mov rdi, r13; unsigned __int64
mov qword ptr [rsp+88h+var_58+8], rbx
mov [rsp+88h+var_68], 0
movaps [rsp+88h+var_78], xmm0
call __Znwm; operator new(ulong)
mov rbx, rax
loc_1A92:
lea rax, [rbx+r13]
movq xmm0, rbx
mov rsi, rbp
mov rdi, rbx
mov [rsp+88h+var_68], rax
lea rax, [rsp+88h+var_58]
punpcklqdq xmm0, xmm0
mov rdx, rax
mov [rsp+88h+var_80], rax
movaps [rsp+88h+var_78], xmm0
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 qword ptr [rsp+88h+var_78+8], rax
mov rbp, rax
test r14, r14
jz short loc_1AD9
mov rsi, r15; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_1AD9:
mov rax, [rsp+88h+var_88]
mov r8, [rbx]
mov r11, [rax]
mov r9, [r11]
mov eax, [r9]
mov [r8], eax
cmp r12d, 1
jle loc_1BB2
mov rcx, [r11+18h]
mov rdx, [rbx+18h]
add eax, [rcx]
mov [rdx], eax
cmp r12d, 2
jz short loc_1B3C
lea eax, [r12-3]
lea rax, [rax+rax*2]
lea rdi, ds:48h[rax*8]
mov eax, 30h ; '0'
xchg ax, ax
loc_1B20:
mov rsi, [r11+rax]
mov rdx, [rbx+rax-18h]
mov rcx, [rbx+rax]
add rax, 18h
mov edx, [rdx]
add edx, [rsi]
mov [rcx], edx
cmp rdi, rax
jnz short loc_1B20
loc_1B3C:
mov edx, [r8]
lea ecx, [r12-2]
mov edi, r12d
mov eax, 1
nop dword ptr [rax+00h]
loc_1B50:
add edx, [r9+rax*4]
mov [r8+rax*4], edx
add rax, 1
cmp rdi, rax
jnz short loc_1B50
lea rax, [rcx+rcx*2]
mov r10d, 18h
lea r14, ds:30h[rax*8]
nop dword ptr [rax+rax+00h]
loc_1B78:
mov rsi, [rbx+r10]
mov r9, [rbx+r10-18h]
mov eax, 1
mov r8, [r11+r10]
mov edx, [rsi]
nop dword ptr [rax+00h]
loc_1B90:
mov ecx, [r9+rax*4]
cmp edx, ecx
cmovl edx, ecx
add edx, [r8+rax*4]
mov [rsi+rax*4], edx
add rax, 1
cmp rdi, rax
jnz short loc_1B90
add r10, 18h
cmp r14, r10
jnz short loc_1B78
loc_1BB2:
mov rdx, [rbx+r13-18h]
lea eax, [r12-1]
pxor xmm1, xmm1
pxor xmm0, xmm0
cdqe
cvtsi2sd xmm1, dword ptr [rdx+rax*4]
lea eax, [r12+r12-1]
cvtsi2sd xmm0, eax
divsd xmm1, xmm0
movq r14, xmm1
cmp rbp, rbx
jz short loc_1C07
mov r12, rbx
nop dword ptr [rax]
loc_1BE8:
mov rdi, [r12]; void *
test rdi, rdi
jz short loc_1BFE
mov rsi, [r12+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1BFE:
add r12, 18h
cmp rbp, r12
jnz short loc_1BE8
loc_1C07:
mov rsi, r13; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_1C6D
add rsp, 58h
movq xmm0, r14
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1C36:
movaps [rsp+88h+var_58], xmm0
xor r15d, r15d
xor r14d, r14d
xor ebx, ebx
mov [rsp+88h+var_48], 0
jmp loc_1A92
loc_1C51:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz short loc_1C6D
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1C6D:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi_cold; func0(std::vector<std::vector<int>>,int) [clone]
endbr64
mov rbx, rax
lea rax, [rsp+arg_28]
mov [rsp+arg_0], rax
jmp loc_12AA | double func0(int ***a1, int a2)
{
unsigned long long v3; // r13
unsigned long long v4; // r15
char *v5; // rax
char *v6; // rbx
void *v7; // r14
void **v8; // rbx
long long v9; // rbp
int *v10; // r8
int **v11; // r11
int *v12; // r9
int v13; // eax
long long v14; // rax
int *v15; // rsi
_DWORD *v16; // rdx
_DWORD *v17; // rcx
int v18; // edx
long long v19; // rax
long long v20; // r10
int *v21; // rsi
_DWORD *v22; // r9
long long v23; // rax
int *v24; // r8
int v25; // edx
double v26; // r14
void **v27; // r12
_BYTE v29[24]; // [rsp+30h] [rbp-58h] BYREF
unsigned long long v30; // [rsp+48h] [rbp-40h]
v30 = __readfsqword(0x28u);
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*(_OWORD *)&v29[8] = 0LL;
v3 = 3LL * a2;
if ( a2 )
{
v4 = 4LL * a2;
v5 = (char *)operator new(v4);
v6 = &v5[v4];
*(_QWORD *)v29 = v5;
v7 = v5;
*(_QWORD *)&v29[16] = &v5[v4];
memset(v5, 0, v4);
*(_QWORD *)&v29[8] = v6;
v8 = (void **)operator new(24LL * a2);
}
else
{
memset(v29, 0, sizeof(v29));
v4 = 0LL;
v7 = 0LL;
v8 = 0LL;
}
v9 = std::__do_uninit_fill_n<std::vector<int> *,unsigned long,std::vector<int>>(v8, a2, v29);
if ( v7 )
operator delete(v7, v4);
v10 = (int *)*v8;
v11 = *a1;
v12 = **a1;
v13 = *v12;
*(_DWORD *)*v8 = *v12;
if ( a2 > 1 )
{
*(_DWORD *)v8[3] = *v11[3] + v13;
if ( a2 != 2 )
{
v14 = 48LL;
do
{
v15 = v11[(unsigned long long)v14 / 8];
v16 = v8[(unsigned long long)v14 / 8 - 3];
v17 = v8[(unsigned long long)v14 / 8];
v14 += 24LL;
*v17 = *v15 + *v16;
}
while ( 24LL * (unsigned int)(a2 - 3) + 72 != v14 );
}
v18 = *v10;
v19 = 1LL;
do
{
v18 += v12[v19];
v10[v19++] = v18;
}
while ( a2 != v19 );
v20 = 24LL;
do
{
v21 = (int *)v8[(unsigned long long)v20 / 8];
v22 = v8[(unsigned long long)v20 / 8 - 3];
v23 = 1LL;
v24 = v11[(unsigned long long)v20 / 8];
v25 = *v21;
do
{
if ( v25 < v22[v23] )
v25 = v22[v23];
v25 += v24[v23];
v21[v23++] = v25;
}
while ( a2 != v23 );
v20 += 24LL;
}
while ( 24LL * (unsigned int)(a2 - 2) + 48 != v20 );
}
v26 = (double)*((int *)v8[v3 - 3] + a2 - 1) / (double)(2 * a2 - 1);
if ( (void **)v9 != v8 )
{
v27 = v8;
do
{
if ( *v27 )
operator delete(*v27, (_BYTE *)v27[2] - (_BYTE *)*v27);
v27 += 3;
}
while ( (void **)v9 != v27 );
}
operator delete(v8, v3 * 8);
return v26;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RSP],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x00101c51
PXOR XMM0,XMM0
LEA R13,[RBP + RBP*0x2]
MOV R12,RBP
MOVUPS xmmword ptr [RSP + 0x38],XMM0
SHL R13,0x3
TEST RBP,RBP
JZ 0x00101c36
LEA R15,[RBP*0x4]
MOV RDI,R15
LAB_00101a4d:
CALL 0x00101210
MOV RDX,R15
XOR ESI,ESI
LEA RBX,[RAX + R15*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x30],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x40],RBX
CALL 0x001011b0
PXOR XMM0,XMM0
MOV RDI,R13
MOV qword ptr [RSP + 0x38],RBX
MOV qword ptr [RSP + 0x20],0x0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_00101a8a:
CALL 0x00101210
MOV RBX,RAX
LAB_00101a92:
LEA RAX,[RBX + R13*0x1]
MOVQ XMM0,RBX
MOV RSI,RBP
MOV RDI,RBX
MOV qword ptr [RSP + 0x20],RAX
LEA RAX,[RSP + 0x30]
PUNPCKLQDQ XMM0,XMM0
MOV RDX,RAX
MOV qword ptr [RSP + 0x8],RAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_00101abc:
CALL 0x00102040
MOV qword ptr [RSP + 0x18],RAX
MOV RBP,RAX
TEST R14,R14
JZ 0x00101ad9
MOV RSI,R15
MOV RDI,R14
CALL 0x00101220
LAB_00101ad9:
MOV RAX,qword ptr [RSP]
MOV R8,qword ptr [RBX]
MOV R11,qword ptr [RAX]
MOV R9,qword ptr [R11]
MOV EAX,dword ptr [R9]
MOV dword ptr [R8],EAX
CMP R12D,0x1
JLE 0x00101bb2
MOV RCX,qword ptr [R11 + 0x18]
MOV RDX,qword ptr [RBX + 0x18]
ADD EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
CMP R12D,0x2
JZ 0x00101b3c
LEA EAX,[R12 + -0x3]
LEA RAX,[RAX + RAX*0x2]
LEA RDI,[0x48 + RAX*0x8]
MOV EAX,0x30
NOP
LAB_00101b20:
MOV RSI,qword ptr [R11 + RAX*0x1]
MOV RDX,qword ptr [RBX + RAX*0x1 + -0x18]
MOV RCX,qword ptr [RBX + RAX*0x1]
ADD RAX,0x18
MOV EDX,dword ptr [RDX]
ADD EDX,dword ptr [RSI]
MOV dword ptr [RCX],EDX
CMP RDI,RAX
JNZ 0x00101b20
LAB_00101b3c:
MOV EDX,dword ptr [R8]
LEA ECX,[R12 + -0x2]
MOV EDI,R12D
MOV EAX,0x1
NOP dword ptr [RAX]
LAB_00101b50:
ADD EDX,dword ptr [R9 + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x00101b50
LEA RAX,[RCX + RCX*0x2]
MOV R10D,0x18
LEA R14,[0x30 + RAX*0x8]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101b78:
MOV RSI,qword ptr [RBX + R10*0x1]
MOV R9,qword ptr [RBX + R10*0x1 + -0x18]
MOV EAX,0x1
MOV R8,qword ptr [R11 + R10*0x1]
MOV EDX,dword ptr [RSI]
NOP dword ptr [RAX]
LAB_00101b90:
MOV ECX,dword ptr [R9 + RAX*0x4]
CMP EDX,ECX
CMOVL EDX,ECX
ADD EDX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
ADD RAX,0x1
CMP RDI,RAX
JNZ 0x00101b90
ADD R10,0x18
CMP R14,R10
JNZ 0x00101b78
LAB_00101bb2:
MOV RDX,qword ptr [RBX + R13*0x1 + -0x18]
LEA EAX,[R12 + -0x1]
PXOR XMM1,XMM1
PXOR XMM0,XMM0
CDQE
CVTSI2SD XMM1,dword ptr [RDX + RAX*0x4]
LEA EAX,[R12 + R12*0x1 + -0x1]
CVTSI2SD XMM0,EAX
DIVSD XMM1,XMM0
MOVQ R14,XMM1
CMP RBP,RBX
JZ 0x00101c07
MOV R12,RBX
NOP dword ptr [RAX]
LAB_00101be8:
MOV RDI,qword ptr [R12]
TEST RDI,RDI
JZ 0x00101bfe
MOV RSI,qword ptr [R12 + 0x10]
SUB RSI,RDI
CALL 0x00101220
LAB_00101bfe:
ADD R12,0x18
CMP RBP,R12
JNZ 0x00101be8
LAB_00101c07:
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101220
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c6d
ADD RSP,0x58
MOVQ XMM0,R14
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101c36:
MOVAPS xmmword ptr [RSP + 0x30],XMM0
XOR R15D,R15D
XOR R14D,R14D
XOR EBX,EBX
MOV qword ptr [RSP + 0x40],0x0
JMP 0x00101a92
LAB_00101c51:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c6d
LEA RDI,[0x103008]
LAB_00101c68:
CALL 0x001011a0
LAB_00101c6d:
CALL 0x00101230 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
double func0(vector param_1,int param_2)
{
int8 *puVar1;
int8 *puVar2;
int iVar3;
int *piVar4;
int8 *puVar5;
int *piVar6;
long lVar7;
long lVar8;
void *pvVar9;
vector *pvVar10;
vector *pvVar11;
long lVar12;
ulong uVar13;
int iVar14;
ulong uVar15;
int4 in_register_0000003c;
vector *pvVar16;
long in_FS_OFFSET;
void *local_58;
void *pvStack_50;
void *pvStack_48;
long local_40;
uVar15 = (ulong)param_2;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
if (uVar15 >> 0x3d == 0) {
pvStack_50 = (void *)0x0;
pvStack_48 = (void *)0x0;
if (uVar15 == 0) {
local_58 = (void *)0x0;
pvStack_50 = (void *)0x0;
uVar13 = 0;
pvVar9 = (void *)0x0;
pvVar10 = (vector *)0x0;
pvStack_48 = (void *)0x0;
}
else {
uVar13 = uVar15 * 4;
pvVar9 = operator_new(uVar13);
local_58 = pvVar9;
pvStack_48 = (void *)((long)pvVar9 + uVar13);
memset(pvVar9,0,uVar13);
pvStack_50 = (void *)((long)pvVar9 + uVar13);
/* try { // try from 00101a8a to 00101a8e has its CatchHandler @ 00101c7e */
pvVar10 = (vector *)operator_new(uVar15 * 0x18);
}
/* try { // try from 00101abc to 00101ac0 has its CatchHandler @ 00101c72 */
pvVar11 = std::
__do_uninit_fill_n<std::vector<int,std::allocator<int>>*,unsigned_long,std::vector<int,std::allocator<int>>>
(pvVar10,uVar15,(vector *)&local_58);
if (pvVar9 != (void *)0x0) {
operator_delete(pvVar9,uVar13);
}
piVar4 = *(int **)pvVar10;
puVar5 = *(int8 **)CONCAT44(in_register_0000003c,param_1);
piVar6 = (int *)*puVar5;
iVar14 = *piVar6;
*piVar4 = iVar14;
if (1 < param_2) {
**(int **)(pvVar10 + 6) = iVar14 + *(int *)puVar5[3];
if (param_2 != 2) {
lVar12 = 0x30;
do {
puVar1 = (int8 *)((long)puVar5 + lVar12);
lVar7 = lVar12 + -0x18;
puVar2 = (int8 *)((long)pvVar10 + lVar12);
lVar12 = lVar12 + 0x18;
*(int *)*puVar2 = **(int **)((long)pvVar10 + lVar7) + *(int *)*puVar1;
} while ((ulong)(param_2 - 3) * 0x18 + 0x48 != lVar12);
}
iVar14 = *piVar4;
uVar13 = 1;
do {
iVar14 = iVar14 + piVar6[uVar13];
piVar4[uVar13] = iVar14;
uVar13 = uVar13 + 1;
} while ((uint)param_2 != uVar13);
lVar12 = 0x18;
do {
piVar4 = *(int **)((long)pvVar10 + lVar12);
lVar7 = *(long *)((long)pvVar10 + lVar12 + -0x18);
uVar13 = 1;
lVar8 = *(long *)((long)puVar5 + lVar12);
iVar14 = *piVar4;
do {
iVar3 = *(int *)(lVar7 + uVar13 * 4);
if (iVar14 < iVar3) {
iVar14 = iVar3;
}
iVar14 = iVar14 + *(int *)(lVar8 + uVar13 * 4);
piVar4[uVar13] = iVar14;
uVar13 = uVar13 + 1;
} while ((uint)param_2 != uVar13);
lVar12 = lVar12 + 0x18;
} while ((ulong)(param_2 - 2) * 0x18 + 0x30 != lVar12);
}
iVar14 = *(int *)(*(long *)(pvVar10 + uVar15 * 6 + -6) + (long)(param_2 + -1) * 4);
for (pvVar16 = pvVar10; pvVar11 != pvVar16; pvVar16 = pvVar16 + 6) {
pvVar9 = *(void **)pvVar16;
if (pvVar9 != (void *)0x0) {
operator_delete(pvVar9,*(long *)(pvVar16 + 4) - (long)pvVar9);
}
}
operator_delete(pvVar10,uVar15 * 0x18);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return (double)iVar14 / (double)(param_2 * 2 + -1);
}
}
else if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,883 | func0 | #include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
| double func0(vector<vector<int>> cost, int N) {
vector<vector<int>> dp(N, vector<int>(N, 0));
dp[0][0] = cost[0][0];
for (int i = 1; i < N; i++) {
dp[i][0] = dp[i - 1][0] + cost[i][0];
}
for (int j = 1; j < N; j++) {
dp[0][j] = dp[0][j - 1] + cost[0][j];
}
for (int i = 1; i < N; i++) {
for (int j = 1; j < N; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + cost[i][j];
}
}
return static_cast<double>(dp[N - 1][N - 1]) / (2 * N - 1);
}
| int main() {
assert(func0({{1, 2, 3}, {6, 5, 4}, {7, 3, 9}}, 3) == 5.2);
assert(func0({{2, 3, 4}, {7, 6, 5}, {8, 4, 10}}, 3) == 6.2);
assert(func0({{3, 4, 5}, {8, 7, 6}, {9, 5, 11}}, 3) == 7.2);
cout << "All assertions passed." << endl;
return 0;
}
| O3 | cpp | func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r15
push %r14
push %r13
movslq %esi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,0x8(%rsp)
cmp %rax,%r13
ja 1c6e <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x32e>
mov %r13,%r14
test %r13,%r13
je 1c25 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x2e5>
lea 0x0(,%r13,4),%r12
lea 0x0(%r13,%r13,2),%rbx
mov %r12,%rdi
shl $0x3,%rbx
callq 11e0 <_Znwm@plt>
mov %r12,%rdx
xor %esi,%esi
mov %rax,%rdi
mov %rax,%r15
callq 1190 <memset@plt>
mov %rbx,%rdi
callq 11e0 <_Znwm@plt>
mov %rax,%rbp
mov %r12,%rax
sar $0x2,%rax
je 1bab <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x26b>
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1c7a <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x33a>
mov %rbp,%rbx
movq $0x0,0x10(%rbx)
pxor %xmm2,%xmm2
mov %r12,%rdi
movups %xmm2,(%rbx)
callq 11e0 <_Znwm@plt>
lea (%rax,%r12,1),%rcx
mov %rax,(%rbx)
mov %rax,%rdi
mov %r12,%rdx
mov %rcx,0x10(%rbx)
mov %r15,%rsi
add $0x18,%rbx
mov %rcx,(%rsp)
callq 11b0 <memcpy@plt>
mov (%rsp),%rcx
mov %rcx,-0x10(%rbx)
sub $0x1,%r13
jne 19d0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x90>
mov %r15,%rdi
callq 11d0 <_ZdlPv@plt>
mov 0x8(%rsp),%rax
mov 0x0(%rbp),%r8
mov (%rax),%r11
mov (%r11),%r9
mov (%r9),%eax
mov %eax,(%r8)
cmp $0x1,%r14d
jle 1aff <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1bf>
mov 0x18(%r11),%rcx
mov 0x18(%rbp),%rdx
add (%rcx),%eax
mov %eax,(%rdx)
cmp $0x2,%r14d
je 1a85 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x145>
lea -0x3(%r14),%eax
lea (%rax,%rax,2),%rax
lea 0x48(,%rax,8),%rdi
mov $0x30,%eax
nopl 0x0(%rax)
mov (%r11,%rax,1),%rsi
mov -0x18(%rbp,%rax,1),%rdx
mov 0x0(%rbp,%rax,1),%rcx
add $0x18,%rax
mov (%rdx),%edx
add (%rsi),%edx
mov %edx,(%rcx)
cmp %rax,%rdi
jne 1a68 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x128>
lea -0x2(%r14),%ecx
mov (%r8),%edx
mov $0x1,%eax
lea 0x2(%rcx),%rdi
nopl (%rax)
add (%r9,%rax,4),%edx
mov %edx,(%r8,%rax,4)
add $0x1,%rax
cmp %rdi,%rax
jne 1a98 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x158>
lea (%rcx,%rcx,2),%rax
mov $0x18,%r10d
lea 0x30(,%rax,8),%r12
nopl 0x0(%rax,%rax,1)
mov 0x0(%rbp,%r10,1),%rsi
mov -0x18(%rbp,%r10,1),%r9
mov $0x1,%eax
mov (%r11,%r10,1),%r8
mov (%rsi),%edx
nopl (%rax)
mov (%r9,%rax,4),%ecx
cmp %edx,%ecx
jl 1b70 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x230>
add (%r8,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
add $0x1,%rax
mov %ecx,%edx
cmp %rdi,%rax
jne 1ad8 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x198>
add $0x18,%r10
cmp %r12,%r10
jne 1ac0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x180>
lea -0x1(%r14),%eax
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
cltq
lea (%rax,%rax,2),%rdx
mov 0x0(%rbp,%rdx,8),%rdx
cvtsi2sdl (%rdx,%rax,4),%xmm1
lea -0x1(%r14,%r14,1),%eax
cvtsi2sd %eax,%xmm0
divsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
cmp %rbx,%rbp
je 1b4f <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x20f>
mov %rbp,%r12
nopl (%rax)
mov (%r12),%rdi
test %rdi,%rdi
je 1ba0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x260>
callq 11d0 <_ZdlPv@plt>
add $0x18,%r12
cmp %rbx,%r12
jne 1b38 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1f8>
mov %rbp,%rdi
callq 11d0 <_ZdlPv@plt>
movsd (%rsp),%xmm0
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax,%rax,1)
add (%r8,%rax,4),%edx
mov %edx,(%rsi,%rax,4)
add $0x1,%rax
cmp %rax,%rdi
jne 1ad8 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x198>
add $0x18,%r10
cmp %r12,%r10
jne 1ac0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x180>
jmpq 1aff <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1bf>
nopw %cs:0x0(%rax,%rax,1)
add $0x18,%r12
cmp %r12,%rbx
jne 1b38 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x1f8>
jmp 1b4f <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x20f>
add %rbp,%rbx
mov %rbp,%r13
test %r12,%r12
je 1bf4 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x2b4>
nopw %cs:0x0(%rax,%rax,1)
pxor %xmm3,%xmm3
mov %r12,0x10(%r13)
mov %r12,%rdx
mov %r15,%rsi
movups %xmm3,0x0(%r13)
xor %edi,%edi
add $0x18,%r13
movq $0x0,-0x18(%r13)
callq 11b0 <memcpy@plt>
mov %r12,-0x10(%r13)
cmp %r13,%rbx
jne 1bc0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x280>
jmpq 1a16 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0xd6>
mov %rbp,%rax
nopw 0x0(%rax,%rax,1)
movq $0x0,(%rax)
add $0x18,%rax
movq $0x0,-0x8(%rax)
movq $0x0,-0x10(%rax)
cmp %rax,%rbx
jne 1c00 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x2c0>
jmpq 1a16 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0xd6>
mov (%rdi),%rax
pxor %xmm1,%xmm1
pxor %xmm0,%xmm0
xor %ebp,%ebp
mov (%rax),%rax
mov (%rax),%edx
mov 0x0,%rax
mov %edx,(%rax)
lea -0x1(%r13),%eax
cltq
lea (%rax,%rax,2),%rdx
shl $0x3,%rdx
mov (%rdx),%rdx
cvtsi2sdl (%rdx,%rax,4),%xmm1
lea -0x1(%r13,%r13,1),%eax
cvtsi2sd %eax,%xmm0
divsd %xmm0,%xmm1
movsd %xmm1,(%rsp)
jmpq 1b4f <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi+0x20f>
lea 0x393(%rip),%rdi
callq 1180 <_ZSt20__throw_length_errorPKc@plt>
movq $0x0,0x10(%rbp)
pxor %xmm0,%xmm0
movups %xmm0,0x0(%rbp)
callq 1150 <_ZSt17__throw_bad_allocv@plt>
endbr64
mov %rax,%rbp
jmpq 128d <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi.cold+0x18>
endbr64
mov %rax,%rdi
jmpq 12a0 <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi.cold+0x2b>
endbr64
mov %rax,%rdi
jmpq 129d <_Z5func0St6vectorIS_IiSaIiEESaIS1_EEi.cold+0x28>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi:
endbr64
push r15
push r14
push r13
push r12
movsxd r12, esi
push rbp
push rbx
sub rsp, 48h
mov [rsp+78h+var_60], rdi
mov [rsp+78h+var_6C], esi
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov rax, r12
shr rax, 3Dh
jnz loc_1CF9
test r12, r12
jz loc_1CB3
lea r13, ds:0[r12*4]
mov rdi, r13; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, r13; n
xor esi, esi; c
lea rbx, [rax+r13]
mov rdi, rax; s
mov [rsp+78h+var_58], rax
mov r14, rax
mov [rsp+78h+var_48], rbx
call _memset
lea rax, [r12+r12*2]
mov [rsp+78h+var_50], rbx
shl rax, 3
mov rdi, rax; unsigned __int64
mov [rsp+78h+var_68], rax
call __Znwm; operator new(ulong)
mov rbp, rax
mov rbx, rax
cmp r13, 4
jz loc_1CBD
nop dword ptr [rax+00h]
loc_1AF0:
mov qword ptr [rbx+10h], 0
pxor xmm2, xmm2
mov rdi, r13; unsigned __int64
movups xmmword ptr [rbx], xmm2
call __Znwm; operator new(ulong)
lea r15, [rax+r13]
mov [rbx], rax
mov rdi, rax; dest
mov rdx, r13; n
mov [rbx+10h], r15
mov rsi, r14; src
add rbx, 18h
call _memcpy
mov [rbx-10h], r15
sub r12, 1
jnz short loc_1AF0
loc_1B2E:
mov rsi, r13; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+78h+var_60]
mov rdi, [rbp+0]
mov esi, [rsp+78h+var_6C]
mov r10, [rax]
mov r8, [r10]
mov eax, [r8]
mov [rdi], eax
cmp esi, 1
jz loc_1C13
mov rcx, [r10+18h]
mov rdx, [rbp+18h]
add eax, [rcx]
mov [rdx], eax
cmp esi, 2
jz short loc_1B9D
lea eax, [rsi-3]
lea rax, [rax+rax*2]
lea r9, ds:48h[rax*8]
mov eax, 30h ; '0'
nop
loc_1B80:
mov rsi, [r10+rax]
mov rdx, [rbp+rax-18h]
mov rcx, [rbp+rax+0]
add rax, 18h
mov edx, [rdx]
add edx, [rsi]
mov [rcx], edx
cmp rax, r9
jnz short loc_1B80
loc_1B9D:
mov esi, [rsp+78h+var_6C]
mov edx, [rdi]
mov eax, 1
lea ecx, [rsi-2]
nop dword ptr [rax+rax+00h]
loc_1BB0:
add edx, [r8+rax*4]
mov [rdi+rax*4], edx
add rax, 1
cmp rsi, rax
jnz short loc_1BB0
lea rax, [rcx+rcx*2]
mov r9d, 18h
lea r11, ds:30h[rax*8]
nop word ptr [rax+rax+00h]
loc_1BD8:
mov rcx, [rbp+r9+0]
mov r8, [rbp+r9-18h]
mov eax, 1
mov rdi, [r10+r9]
mov edx, [rcx]
nop dword ptr [rax]
loc_1BF0:
mov r12d, [r8+rax*4]
cmp edx, r12d
cmovl edx, r12d
add edx, [rdi+rax*4]
mov [rcx+rax*4], edx
add rax, 1
cmp rsi, rax
jnz short loc_1BF0
add r9, 18h
cmp r9, r11
jnz short loc_1BD8
loc_1C13:
mov rax, [rsp+78h+var_68]
pxor xmm1, xmm1
pxor xmm0, xmm0
mov rax, [rbp+rax-18h]
cvtsi2sd xmm1, dword ptr [rax+r13-4]
mov eax, [rsp+78h+var_6C]
lea eax, [rax+rax-1]
cvtsi2sd xmm0, eax
divsd xmm1, xmm0
movq r13, xmm1
cmp rbp, rbx
jz short loc_1C6F
mov r12, rbp
nop dword ptr [rax+00000000h]
loc_1C50:
mov rdi, [r12]; void *
test rdi, rdi
jz short loc_1CA8
mov rsi, [r12+10h]
add r12, 18h
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
cmp r12, rbx
jnz short loc_1C50
loc_1C6F:
mov rsi, [rsp+78h+var_68]; unsigned __int64
mov rdi, rbp; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz loc_1D15
add rsp, 48h
movq xmm0, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1CA8:
add r12, 18h
cmp rbx, r12
jnz short loc_1C50
jmp short loc_1C6F
loc_1CB3:
mov rax, qword ptr ds:dword_0
ud2
loc_1CBD:
mov qword ptr [rbx+10h], 0
pxor xmm3, xmm3
mov edi, 4; unsigned __int64
movups xmmword ptr [rbx], xmm3
call __Znwm; operator new(ulong)
mov ecx, [r14]
lea rdx, [rax+4]
mov [rbx], rax
add rbx, 18h
mov [rbx-8], rdx
mov [rbx-10h], rdx
mov [rax], ecx
sub r12, 1
jnz short loc_1CBD
jmp loc_1B2E
loc_1CF9:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_1D15
lea rdi, aCannotCreateSt; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_1D15:
call ___stack_chk_fail
endbr64
mov rdi, rax
jmp _Z5func0St6vectorIS_IiSaIiEESaIS1_EEi_cold; func0(std::vector<std::vector<int>>,int) [clone]
endbr64
mov rbx, rax
jmp loc_12D4 | double func0(int ***a1, int a2)
{
long long v2; // r12
unsigned long long v3; // r13
int *v4; // r14
void **v5; // rbp
void **v6; // rbx
char *v7; // rax
char *v8; // r15
int *v9; // rdi
int **v10; // r10
int *v11; // r8
int v12; // eax
long long v13; // rax
int *v14; // rsi
_DWORD *v15; // rdx
_DWORD *v16; // rcx
int v17; // edx
long long v18; // rax
long long v19; // r9
int *v20; // rcx
_DWORD *v21; // r8
long long v22; // rax
int *v23; // rdi
int v24; // edx
double v25; // r13
void **v26; // r12
void *v27; // rdi
char *v28; // rsi
_DWORD *v30; // rax
int v31; // ecx
long long v33; // [rsp+10h] [rbp-68h]
v2 = a2;
if ( (unsigned long long)a2 >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
if ( !a2 )
BUG();
v3 = 4LL * a2;
v4 = (int *)operator new(v3);
memset(v4, 0, v3);
v33 = 24LL * a2;
v5 = (void **)operator new(v33);
v6 = v5;
if ( v3 == 4 )
{
do
{
v6[2] = 0LL;
*(_OWORD *)v6 = 0LL;
v30 = (_DWORD *)operator new(4uLL);
v31 = *v4;
*v6 = v30;
v6 += 3;
*(v6 - 1) = v30 + 1;
*(v6 - 2) = v30 + 1;
*v30 = v31;
--v2;
}
while ( v2 );
}
else
{
do
{
v6[2] = 0LL;
*(_OWORD *)v6 = 0LL;
v7 = (char *)operator new(v3);
v8 = &v7[v3];
*v6 = v7;
v6[2] = &v7[v3];
v6 += 3;
memcpy(v7, v4, v3);
*(v6 - 2) = v8;
--v2;
}
while ( v2 );
}
operator delete(v4, v3);
v9 = (int *)*v5;
v10 = *a1;
v11 = **a1;
v12 = *v11;
*(_DWORD *)*v5 = *v11;
if ( a2 != 1 )
{
*(_DWORD *)v5[3] = *v10[3] + v12;
if ( a2 != 2 )
{
v13 = 48LL;
do
{
v14 = v10[(unsigned long long)v13 / 8];
v15 = v5[(unsigned long long)v13 / 8 - 3];
v16 = v5[(unsigned long long)v13 / 8];
v13 += 24LL;
*v16 = *v14 + *v15;
}
while ( v13 != 24LL * (unsigned int)(a2 - 3) + 72 );
}
v17 = *v9;
v18 = 1LL;
do
{
v17 += v11[v18];
v9[v18++] = v17;
}
while ( a2 != v18 );
v19 = 24LL;
do
{
v20 = (int *)v5[(unsigned long long)v19 / 8];
v21 = v5[(unsigned long long)v19 / 8 - 3];
v22 = 1LL;
v23 = v10[(unsigned long long)v19 / 8];
v24 = *v20;
do
{
if ( v24 < v21[v22] )
v24 = v21[v22];
v24 += v23[v22];
v20[v22++] = v24;
}
while ( a2 != v22 );
v19 += 24LL;
}
while ( v19 != 24LL * (unsigned int)(a2 - 2) + 48 );
}
v25 = (double)*(int *)((char *)v5[(unsigned long long)v33 / 8 - 3] + v3 - 4) / (double)(2 * a2 - 1);
if ( v5 != v6 )
{
v26 = v5;
do
{
while ( 1 )
{
v27 = *v26;
if ( !*v26 )
break;
v28 = (char *)v26[2];
v26 += 3;
operator delete(v27, v28 - (_BYTE *)v27);
if ( v26 == v6 )
goto LABEL_21;
}
v26 += 3;
}
while ( v6 != v26 );
}
LABEL_21:
operator delete(v5, v33);
return v25;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOVSXD R12,ESI
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0xc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RAX,R12
SHR RAX,0x3d
JNZ 0x00101cf9
TEST R12,R12
JZ 0x00101cb3
LEA R13,[R12*0x4]
MOV RDI,R13
LAB_00101a9f:
CALL 0x00101200
MOV RDX,R13
XOR ESI,ESI
LEA RBX,[RAX + R13*0x1]
MOV RDI,RAX
MOV qword ptr [RSP + 0x20],RAX
MOV R14,RAX
MOV qword ptr [RSP + 0x30],RBX
CALL 0x001011b0
LEA RAX,[R12 + R12*0x2]
MOV qword ptr [RSP + 0x28],RBX
SHL RAX,0x3
MOV RDI,RAX
MOV qword ptr [RSP + 0x10],RAX
LAB_00101ad7:
CALL 0x00101200
MOV RBP,RAX
MOV RBX,RAX
CMP R13,0x4
JZ 0x00101cbd
NOP dword ptr [RAX]
LAB_00101af0:
MOV qword ptr [RBX + 0x10],0x0
PXOR XMM2,XMM2
MOV RDI,R13
MOVUPS xmmword ptr [RBX],XMM2
LAB_00101b02:
CALL 0x00101200
LEA R15,[RAX + R13*0x1]
MOV qword ptr [RBX],RAX
MOV RDI,RAX
MOV RDX,R13
MOV qword ptr [RBX + 0x10],R15
MOV RSI,R14
ADD RBX,0x18
CALL 0x001011f0
MOV qword ptr [RBX + -0x10],R15
SUB R12,0x1
JNZ 0x00101af0
LAB_00101b2e:
MOV RSI,R13
MOV RDI,R14
CALL 0x00101210
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RBP]
MOV ESI,dword ptr [RSP + 0xc]
MOV R10,qword ptr [RAX]
MOV R8,qword ptr [R10]
MOV EAX,dword ptr [R8]
MOV dword ptr [RDI],EAX
CMP ESI,0x1
JZ 0x00101c13
MOV RCX,qword ptr [R10 + 0x18]
MOV RDX,qword ptr [RBP + 0x18]
ADD EAX,dword ptr [RCX]
MOV dword ptr [RDX],EAX
CMP ESI,0x2
JZ 0x00101b9d
LEA EAX,[RSI + -0x3]
LEA RAX,[RAX + RAX*0x2]
LEA R9,[0x48 + RAX*0x8]
MOV EAX,0x30
NOP
LAB_00101b80:
MOV RSI,qword ptr [R10 + RAX*0x1]
MOV RDX,qword ptr [RBP + RAX*0x1 + -0x18]
MOV RCX,qword ptr [RBP + RAX*0x1]
ADD RAX,0x18
MOV EDX,dword ptr [RDX]
ADD EDX,dword ptr [RSI]
MOV dword ptr [RCX],EDX
CMP RAX,R9
JNZ 0x00101b80
LAB_00101b9d:
MOV ESI,dword ptr [RSP + 0xc]
MOV EDX,dword ptr [RDI]
MOV EAX,0x1
LEA ECX,[RSI + -0x2]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101bb0:
ADD EDX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101bb0
LEA RAX,[RCX + RCX*0x2]
MOV R9D,0x18
LEA R11,[0x30 + RAX*0x8]
NOP word ptr [RAX + RAX*0x1]
LAB_00101bd8:
MOV RCX,qword ptr [RBP + R9*0x1]
MOV R8,qword ptr [RBP + R9*0x1 + -0x18]
MOV EAX,0x1
MOV RDI,qword ptr [R10 + R9*0x1]
MOV EDX,dword ptr [RCX]
NOP dword ptr [RAX]
LAB_00101bf0:
MOV R12D,dword ptr [R8 + RAX*0x4]
CMP EDX,R12D
CMOVL EDX,R12D
ADD EDX,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RCX + RAX*0x4],EDX
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101bf0
ADD R9,0x18
CMP R9,R11
JNZ 0x00101bd8
LAB_00101c13:
MOV RAX,qword ptr [RSP + 0x10]
PXOR XMM1,XMM1
PXOR XMM0,XMM0
MOV RAX,qword ptr [RBP + RAX*0x1 + -0x18]
CVTSI2SD XMM1,dword ptr [RAX + R13*0x1 + -0x4]
MOV EAX,dword ptr [RSP + 0xc]
LEA EAX,[RAX + RAX*0x1 + -0x1]
CVTSI2SD XMM0,EAX
DIVSD XMM1,XMM0
MOVQ R13,XMM1
CMP RBP,RBX
JZ 0x00101c6f
MOV R12,RBP
NOP dword ptr [RAX]
LAB_00101c50:
MOV RDI,qword ptr [R12]
TEST RDI,RDI
JZ 0x00101ca8
MOV RSI,qword ptr [R12 + 0x10]
ADD R12,0x18
SUB RSI,RDI
CALL 0x00101210
CMP R12,RBX
JNZ 0x00101c50
LAB_00101c6f:
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,RBP
CALL 0x00101210
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101d15
ADD RSP,0x48
MOVQ XMM0,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101ca8:
ADD R12,0x18
CMP RBX,R12
JNZ 0x00101c50
JMP 0x00101c6f
LAB_00101cb3:
MOV RAX,qword ptr [0x00000000]
UD2
LAB_00101cbd:
MOV qword ptr [RBX + 0x10],0x0
PXOR XMM3,XMM3
MOV EDI,0x4
MOVUPS xmmword ptr [RBX],XMM3
CALL 0x00101200
MOV ECX,dword ptr [R14]
LEA RDX,[RAX + 0x4]
MOV qword ptr [RBX],RAX
ADD RBX,0x18
MOV qword ptr [RBX + -0x8],RDX
MOV qword ptr [RBX + -0x10],RDX
MOV dword ptr [RAX],ECX
SUB R12,0x1
JNZ 0x00101cbd
JMP 0x00101b2e
LAB_00101cf9:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101d15
LEA RDI,[0x103008]
LAB_00101d10:
CALL 0x001011a0
LAB_00101d15:
CALL 0x00101220 | /* func0(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > >, int) */
double func0(vector param_1,int param_2)
{
int8 *puVar1;
ulong __n;
int8 *puVar2;
int iVar3;
int4 uVar4;
long lVar5;
int *piVar6;
int8 *puVar7;
int *piVar8;
long lVar9;
long lVar10;
code *pcVar11;
int4 *__s;
ulong uVar12;
int (*pauVar13) [16];
void *pvVar14;
long lVar15;
int4 *puVar16;
int iVar17;
int (*pauVar18) [16];
int (*pauVar19) [16];
int4 in_register_0000003c;
ulong uVar20;
long in_FS_OFFSET;
uVar20 = (ulong)param_2;
lVar5 = *(long *)(in_FS_OFFSET + 0x28);
if (uVar20 >> 0x3d == 0) {
if (uVar20 == 0) {
/* WARNING: Does not return */
pcVar11 = (code *)invalidInstructionException();
(*pcVar11)();
}
__n = uVar20 * 4;
__s = (int4 *)operator_new(__n);
memset(__s,0,__n);
uVar12 = uVar20 * 0x18;
/* try { // try from 00101ad7 to 00101adb has its CatchHandler @ 00101d26 */
pauVar13 = (int (*) [16])operator_new(uVar12);
pauVar19 = pauVar13;
if (__n == 4) {
do {
*(int8 *)pauVar19[1] = 0;
*pauVar19 = (int [16])0x0;
puVar16 = (int4 *)operator_new(4);
uVar4 = *__s;
*(int4 **)*pauVar19 = puVar16;
pauVar18 = (int (*) [16])(pauVar19[1] + 8);
*(int4 **)pauVar19[1] = puVar16 + 1;
*(int4 **)(*pauVar19 + 8) = puVar16 + 1;
*puVar16 = uVar4;
uVar20 = uVar20 - 1;
pauVar19 = pauVar18;
} while (uVar20 != 0);
}
else {
do {
*(int8 *)pauVar19[1] = 0;
*pauVar19 = (int [16])0x0;
/* try { // try from 00101b02 to 00101cd5 has its CatchHandler @ 00101d1a */
pvVar14 = operator_new(__n);
*(void **)*pauVar19 = pvVar14;
*(void **)pauVar19[1] = (void *)((long)pvVar14 + __n);
pauVar18 = (int (*) [16])(pauVar19[1] + 8);
memcpy(pvVar14,__s,__n);
*(void **)(*pauVar19 + 8) = (void *)((long)pvVar14 + __n);
uVar20 = uVar20 - 1;
pauVar19 = pauVar18;
} while (uVar20 != 0);
}
operator_delete(__s,__n);
piVar6 = *(int **)*pauVar13;
puVar7 = *(int8 **)CONCAT44(in_register_0000003c,param_1);
piVar8 = (int *)*puVar7;
iVar17 = *piVar8;
*piVar6 = iVar17;
if (param_2 != 1) {
**(int **)(pauVar13[1] + 8) = iVar17 + *(int *)puVar7[3];
if (param_2 != 2) {
lVar15 = 0x30;
do {
puVar1 = (int8 *)((long)puVar7 + lVar15);
lVar9 = lVar15 + 8;
puVar2 = (int8 *)(*pauVar13 + lVar15);
lVar15 = lVar15 + 0x18;
*(int *)*puVar2 = **(int **)(pauVar13[-2] + lVar9) + *(int *)*puVar1;
} while (lVar15 != (ulong)(param_2 - 3) * 0x18 + 0x48);
}
iVar17 = *piVar6;
uVar20 = 1;
do {
iVar17 = iVar17 + piVar8[uVar20];
piVar6[uVar20] = iVar17;
uVar20 = uVar20 + 1;
} while ((uint)param_2 != uVar20);
lVar15 = 0x18;
do {
piVar6 = *(int **)(*pauVar13 + lVar15);
lVar9 = *(long *)(pauVar13[-2] + lVar15 + 8);
uVar20 = 1;
lVar10 = *(long *)((long)puVar7 + lVar15);
iVar17 = *piVar6;
do {
iVar3 = *(int *)(lVar9 + uVar20 * 4);
if (iVar17 < iVar3) {
iVar17 = iVar3;
}
iVar17 = iVar17 + *(int *)(lVar10 + uVar20 * 4);
piVar6[uVar20] = iVar17;
uVar20 = uVar20 + 1;
} while ((uint)param_2 != uVar20);
lVar15 = lVar15 + 0x18;
} while (lVar15 != (ulong)(param_2 - 2) * 0x18 + 0x30);
}
iVar17 = *(int *)(*(long *)((long)pauVar13 + (uVar12 - 0x18)) + -4 + __n);
for (pauVar19 = pauVar13; pauVar19 != pauVar18; pauVar19 = (int (*) [16])(pauVar19[1] + 8)
) {
while (pvVar14 = *(void **)*pauVar19, pvVar14 == (void *)0x0) {
pauVar19 = (int (*) [16])(pauVar19[1] + 8);
if (pauVar18 == pauVar19) goto LAB_00101c6f;
}
operator_delete(pvVar14,*(long *)pauVar19[1] - (long)pvVar14);
}
LAB_00101c6f:
operator_delete(pauVar13,uVar12);
if (lVar5 == *(long *)(in_FS_OFFSET + 0x28)) {
return (double)iVar17 / (double)(param_2 * 2 + -1);
}
}
else if (lVar5 == *(long *)(in_FS_OFFSET + 0x28)) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,884 | func0 |
#include <cassert>
#include <map>
#include <string>
#include <utility>
| std::map<std::string, std::pair<double, int>> func0(const std::map<std::string, std::pair<double, int>>& students, double h, int w) {
std::map<std::string, std::pair<double, int>> result;
for (const auto& [k, s] : students) {
if (s.first >= h && s.second >= w) {
result[k] = s;
}
}
return result;
}
| int main() {
std::map<std::string, std::pair<double, int>> students = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
std::map<std::string, std::pair<double, int>> expected1 = {
{"Cierra Vega", {6.2, 70}}
};
assert(func0(students, 6.0, 70) == expected1);
std::map<std::string, std::pair<double, int>> expected2 = {
{"Cierra Vega", {6.2, 70}},
{"Kierra Gentry", {6.0, 68}}
};
assert(func0(students, 5.9, 67) == expected2);
std::map<std::string, std::pair<double, int>> expected3 = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
assert(func0(students, 5.7, 64) == expected3);
return 0;
}
| O0 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<double, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<double, int> > > > const&, double, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
movsd %xmm0,-0x68(%rbp)
mov %edx,-0x6c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 32b4 <_ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEC1Ev>
mov -0x60(%rbp),%rax
mov %rax,-0x38(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 37c6 <_ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEE5beginEv>
mov %rax,-0x48(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 37e4 <_ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEE3endEv>
mov %rax,-0x40(%rbp)
lea -0x40(%rbp),%rdx
lea -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 3802 <_ZStneRKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEESC_>
test %al,%al
je 2643 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x11a>
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 3854 <_ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEEdeEv>
mov %rax,-0x30(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 32f3 <_ZSt3getILm0EKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiEERKNSt13tuple_elementIXT_ES7_IT0_T1_EE4typeERKSC_>
mov %rax,-0x28(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 3311 <_ZSt3getILm1EKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiEERKNSt13tuple_elementIXT_ES7_IT0_T1_EE4typeERKSC_>
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
movsd (%rax),%xmm0
comisd -0x68(%rbp),%xmm0
jb 2614 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xeb>
mov -0x20(%rbp),%rax
mov 0x8(%rax),%eax
cmp %eax,-0x6c(%rbp)
jg 2614 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xeb>
mov -0x28(%rbp),%rdx
mov -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 389e <_ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEixERSA_>
mov %rax,%rdx
mov -0x20(%rbp),%rax
mov %rax,%rsi
mov %rdx,%rdi
callq 39c0 <_ZNSt4pairIdiEaSERKS0_>
lea -0x48(%rbp),%rax
mov %rax,%rdi
callq 3828 <_ZNSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEEppEv>
jmpq 2589 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x60>
endbr64
mov %rax,%rbx
mov -0x58(%rbp),%rax
mov %rax,%rdi
callq 32d4 <_ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 2400 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 2658 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12f>
callq 23a0 <__stack_chk_fail@plt>
mov -0x58(%rbp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
movsd [rbp+var_68], xmm0
mov [rbp+var_6C], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEC2Ev; std::map<std::string,std::pair<double,int>>::map(void)
mov rax, [rbp+var_60]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEE5beginEv; std::map<std::string,std::pair<double,int>>::begin(void)
mov [rbp+var_48], rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEE3endEv; std::map<std::string,std::pair<double,int>>::end(void)
mov [rbp+var_40], rax
jmp short loc_25E7
loc_256B:
lea rax, [rbp+var_48]
mov rdi, rax
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEEdeEv; std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>::operator*(void)
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZSt3getILm0EKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiEERKNSt13tuple_elementIXT_ES7_IT0_T1_EE4typeERKSC_; std::get<0ul,std::string const,std::pair<double,int>>(std::pair<std::string const,std::pair<double,int>> const&)
mov [rbp+var_28], rax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZSt3getILm1EKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiEERKNSt13tuple_elementIXT_ES7_IT0_T1_EE4typeERKSC_; std::get<1ul,std::string const,std::pair<double,int>>(std::pair<std::string const,std::pair<double,int>> const&)
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
movsd xmm0, qword ptr [rax]
comisd xmm0, [rbp+var_68]
jb short loc_25DB
mov rax, [rbp+var_20]
mov eax, [rax+8]
cmp [rbp+var_6C], eax
jg short loc_25DB
mov rdx, [rbp+var_28]
mov rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEixERSA_; std::map<std::string,std::pair<double,int>>::operator[](std::string const&)
mov rdx, rax
mov rax, [rbp+var_20]
mov rsi, rax
mov rdi, rdx
call _ZNSt4pairIdiEaSERKS0_; std::pair<double,int>::operator=(std::pair<double,int> const&)
loc_25DB:
lea rax, [rbp+var_48]
mov rdi, rax
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEEppEv; std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>::operator++(void)
loc_25E7:
lea rdx, [rbp+var_40]
lea rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZStneRKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES0_IdiEEESC_; std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>> const&,std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>> const&)
test al, al
jnz loc_256B
jmp short loc_2636
endbr64
mov rbx, rax
mov rax, [rbp+var_58]
mov rdi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEED2Ev; std::map<std::string,std::pair<double,int>>::~map()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_262E
call ___stack_chk_fail
loc_262E:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_2636:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_264A
call ___stack_chk_fail
loc_264A:
mov rax, [rbp+var_58]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, int a3, double a4)
{
long long v4; // rax
long long v7; // [rsp+28h] [rbp-48h] BYREF
_QWORD v8[2]; // [rsp+30h] [rbp-40h] BYREF
long long v9; // [rsp+40h] [rbp-30h]
long long v10; // [rsp+48h] [rbp-28h]
long long v11; // [rsp+50h] [rbp-20h]
unsigned long long v12; // [rsp+58h] [rbp-18h]
v12 = __readfsqword(0x28u);
std::map<std::string,std::pair<double,int>>::map(a1);
v8[1] = a2;
v7 = std::map<std::string,std::pair<double,int>>::begin(a2);
v8[0] = std::map<std::string,std::pair<double,int>>::end(a2);
while ( (unsigned __int8)std::operator!=(&v7, v8) )
{
v9 = std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>::operator*(&v7);
v10 = std::get<0ul,std::string const,std::pair<double,int>>(v9);
v11 = std::get<1ul,std::string const,std::pair<double,int>>(v9);
if ( *(double *)v11 >= a4 && a3 <= *(_DWORD *)(v11 + 8) )
{
v4 = std::map<std::string,std::pair<double,int>>::operator[](a1, v10);
std::pair<double,int>::operator=(v4, v11);
}
std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>::operator++(&v7);
}
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
MOVSD qword ptr [RBP + -0x68],XMM0
MOV dword ptr [RBP + -0x6c],EDX
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 0x001037b6
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00103968
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00103986
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001025e7
LAB_0010256b:
LEA RAX,[RBP + -0x48]
MOV RDI,RAX
CALL 0x001039f6
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001037f5
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00103813
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSD XMM0,qword ptr [RAX]
COMISD XMM0,qword ptr [RBP + -0x68]
JC 0x001025db
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x8]
CMP dword ptr [RBP + -0x6c],EAX
JG 0x001025db
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
LAB_001025c4:
CALL 0x00103a40
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x00103b60
LAB_001025db:
LEA RAX,[RBP + -0x48]
MOV RDI,RAX
CALL 0x001039ca
LAB_001025e7:
LEA RDX,[RBP + -0x40]
LEA RAX,[RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001039a4
TEST AL,AL
JNZ 0x0010256b
JMP 0x00102636
LAB_00102636:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010264a
CALL 0x00102390
LAB_0010264a:
MOV RAX,qword ptr [RBP + -0x58]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::map<std::string, std::pair<double, int>, std::less<std::string >,
std::allocator<std::pair<std::string const, std::pair<double, int> > > > const&, double, int) */
map * func0(map *param_1,double param_2,int param_3)
{
char cVar1;
pair<double,int> *this;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
int8 local_50;
int8 local_48;
map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*local_40;
pair *local_38;
string *local_30;
pair *local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::
map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::map((map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)param_1);
local_40 = (map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)CONCAT44(in_register_00000034,param_3);
local_50 = std::
map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::begin((map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)CONCAT44(in_register_00000034,param_3));
local_48 = std::
map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::end(local_40);
while( true ) {
cVar1 = std::operator!=((_Rb_tree_const_iterator *)&local_50,
(_Rb_tree_const_iterator *)&local_48);
if (cVar1 == '\0') break;
local_38 = (pair *)std::
_Rb_tree_const_iterator<std::pair<std::string_const,std::pair<double,int>>>::
operator*((_Rb_tree_const_iterator<std::pair<std::string_const,std::pair<double,int>>>
*)&local_50);
local_30 = (string *)std::get<0ul,std::string_const,std::pair<double,int>>(local_38);
local_28 = (pair *)std::get<1ul,std::string_const,std::pair<double,int>>(local_38);
if ((param_2 <= *(double *)local_28) && (in_EDX <= *(int *)((type *)local_28 + 8))) {
/* try { // try from 001025c4 to 001025c8 has its CatchHandler @ 00102604 */
this = (pair<double,int> *)
std::
map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::operator[]((map<std::string,std::pair<double,int>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)param_1,local_30);
std::pair<double,int>::operator=(this,local_28);
}
std::_Rb_tree_const_iterator<std::pair<std::string_const,std::pair<double,int>>>::operator++
((_Rb_tree_const_iterator<std::pair<std::string_const,std::pair<double,int>>> *)
&local_50);
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,885 | func0 |
#include <cassert>
#include <map>
#include <string>
#include <utility>
| std::map<std::string, std::pair<double, int>> func0(const std::map<std::string, std::pair<double, int>>& students, double h, int w) {
std::map<std::string, std::pair<double, int>> result;
for (const auto& [k, s] : students) {
if (s.first >= h && s.second >= w) {
result[k] = s;
}
}
return result;
}
| int main() {
std::map<std::string, std::pair<double, int>> students = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
std::map<std::string, std::pair<double, int>> expected1 = {
{"Cierra Vega", {6.2, 70}}
};
assert(func0(students, 6.0, 70) == expected1);
std::map<std::string, std::pair<double, int>> expected2 = {
{"Cierra Vega", {6.2, 70}},
{"Kierra Gentry", {6.0, 68}}
};
assert(func0(students, 5.9, 67) == expected2);
std::map<std::string, std::pair<double, int>> expected3 = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
assert(func0(students, 5.7, 64) == expected3);
return 0;
}
| O1 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<double, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<double, int> > > > const&, double, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%r14
movsd %xmm0,0x10(%rsp)
mov %edx,0x1c(%rsp)
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movl $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
lea 0x8(%rdi),%rax
mov %rax,0x20(%rsp)
mov %rax,0x18(%rdi)
mov %rax,0x20(%rdi)
movq $0x0,0x28(%rdi)
mov 0x18(%rsi),%rbx
lea 0x8(%rsi),%rax
mov %rax,0x8(%rsp)
cmp %rax,%rbx
je 1505 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1dc>
mov %rdi,0x28(%rsp)
jmpq 14b5 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x18c>
sub %r13,%rbp
mov $0x80000000,%eax
cmp %rax,%rbp
jge 13c2 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x99>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%rbp
jle 13f9 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xd0>
mov %ebp,%edx
test %edx,%edx
js 13f9 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xd0>
mov %r12,(%rsp)
mov 0x10(%r12),%r12
test %r12,%r12
je 1400 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xd7>
mov 0x28(%r12),%rbp
cmp %r13,%rbp
mov %r13,%rdx
cmovbe %rbp,%rdx
test %rdx,%rdx
je 13a0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x77>
mov 0x20(%r12),%rdi
mov %r15,%rsi
callq 1160 <memcmp@plt>
mov %eax,%edx
test %eax,%eax
jne 13be <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x95>
jmp 13a0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x77>
mov 0x18(%r12),%r12
jmp 13cb <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xa2>
mov (%rsp),%rax
cmp %rax,0x20(%rsp)
je 1453 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12a>
mov 0x28(%rax),%rbp
cmp %rbp,%r13
mov %rbp,%rdx
cmovbe %r13,%rdx
test %rdx,%rdx
je 1430 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x107>
mov 0x20(%rax),%rsi
mov %r15,%rdi
callq 1160 <memcmp@plt>
mov %eax,%edx
test %eax,%eax
jne 144f <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x126>
sub %rbp,%r13
mov $0x80000000,%eax
cmp %rax,%r13
jge 148f <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x166>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%r13
jle 1453 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12a>
mov %r13d,%edx
test %edx,%edx
jns 148f <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x166>
mov 0x28(%rsp),%rdi
mov %rdi,%rbp
lea 0x20(%rbx),%rax
mov %rax,0x40(%rsp)
lea 0x40(%rsp),%rcx
lea 0x3f(%rsp),%r8
lea 0x1cc1(%rip),%rdx
mov (%rsp),%rsi
callq 2214 <_ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS7_EESK_IJEEEEESt17_Rb_tree_iteratorIS9_ESt23_Rb_tree_const_iteratorIS9_EDpOT_>
jmp 148b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x162>
mov 0x20(%rsp),%rax
mov %rax,(%rsp)
jmp 1453 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12a>
mov %rax,(%rsp)
movsd 0x40(%rbx),%xmm0
mov (%rsp),%rcx
movsd %xmm0,0x40(%rcx)
mov 0x48(%rbx),%eax
mov %eax,0x48(%rcx)
mov %rbx,%rdi
callq 11f0 <_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base@plt>
mov %rax,%rbx
cmp %rax,0x8(%rsp)
je 1505 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1dc>
movsd 0x40(%rbx),%xmm0
comisd 0x10(%rsp),%xmm0
jb 14a3 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x17a>
mov 0x1c(%rsp),%eax
cmp %eax,0x48(%rbx)
jl 14a3 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x17a>
mov 0x10(%r14),%r12
test %r12,%r12
je 1480 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x157>
mov 0x28(%rbx),%r13
mov 0x20(%rbx),%r15
mov 0x20(%rsp),%rax
mov %rax,(%rsp)
jmpq 13d0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xa7>
endbr64
mov %rax,%rbx
mov 0x10(%r14),%rsi
mov %rbp,%rdi
callq 1c9c <_ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE8_M_eraseEPSt13_Rb_tree_nodeIS9_E>
mov %rbx,%rdi
callq 1220 <_Unwind_Resume@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 1527 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1fe>
mov %r14,%rax
add $0x58,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 11e0 <__stack_chk_fail@plt>
| _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov r14, rdi
movsd [rsp+88h+var_70], xmm0
mov [rsp+88h+var_64], edx
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea rax, [rdi+8]
mov [rsp+88h+var_60], rax
mov [rdi+18h], rax
mov [rdi+20h], rax
mov qword ptr [rdi+28h], 0
mov r12, [rsi+18h]
lea rax, [rsi+8]
mov [rsp+88h+var_78], rax
cmp rax, r12
jnz loc_1530
loc_13F6:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_159C
mov rax, r14
add rsp, 58h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_141C:
sub rbx, r13
mov eax, 80000000h
cmp rbx, rax
jge short loc_143E
mov rax, 0FFFFFFFF7FFFFFFFh
cmp rbx, rax
jle short loc_1473
mov edx, ebx
loc_143A:
test edx, edx
js short loc_1473
loc_143E:
mov [rsp+88h+var_80], rbp
mov rbp, [rbp+10h]
loc_1447:
test rbp, rbp
jz short loc_1479
loc_144C:
mov rbx, [rbp+28h]
cmp rbx, r13
mov rdx, r13
cmovbe rdx, rbx; n
mov rdi, [rbp+20h]; s1
test rdx, rdx
jz short loc_141C
mov rsi, r15; s2
call _memcmp
mov edx, eax
test eax, eax
jnz short loc_143A
jmp short loc_141C
loc_1473:
mov rbp, [rbp+18h]
jmp short loc_1447
loc_1479:
mov rax, [rsp+88h+var_80]
cmp [rsp+88h+var_60], rax
jz short loc_14C6
mov rbx, [rax+28h]
cmp r13, rbx
mov rdx, rbx
cmovbe rdx, r13; n
mov rsi, [rax+20h]; s2
test rdx, rdx
jz short loc_14AA
mov rdi, r15; s1
call _memcmp
mov edx, eax
test eax, eax
jnz short loc_14C2
loc_14AA:
sub r13, rbx
cmp r13, 7FFFFFFFh
jg short loc_1501
cmp r13, 0FFFFFFFF80000000h
jl short loc_14C6
mov edx, r13d
loc_14C2:
test edx, edx
jns short loc_1501
loc_14C6:
lea rax, [r12+20h]
mov [rsp+88h+var_48], rax
lea rcx, [rsp+88h+var_48]
lea r8, [rsp+88h+var_49]
lea rdx, _ZSt19piecewise_construct; std::piecewise_construct
mov rsi, [rsp+88h+var_80]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS7_EESK_IJEEEEESt17_Rb_tree_iteratorIS9_ESt23_Rb_tree_const_iteratorIS9_EDpOT_; std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_emplace_hint_unique<std::piecewise_construct_t const&,std::tuple<std::string const&>,std::tuple<>>(std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>)
jmp short loc_14FC
loc_14F0:
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_80], rax
jmp short loc_14C6
loc_14FC:
mov [rsp+88h+var_80], rax
loc_1501:
movsd xmm0, qword ptr [r12+40h]
mov rcx, [rsp+88h+var_80]
movsd qword ptr [rcx+40h], xmm0
mov eax, [r12+48h]
mov [rcx+48h], eax
loc_151A:
mov rdi, r12
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov r12, rax
cmp [rsp+88h+var_78], rax
jz loc_13F6
loc_1530:
movsd xmm0, qword ptr [r12+40h]
comisd xmm0, [rsp+88h+var_70]
jb short loc_151A
mov eax, [rsp+88h+var_64]
cmp [r12+48h], eax
jl short loc_151A
mov rbp, [r14+10h]
test rbp, rbp
jz short loc_14F0
mov r13, [r12+28h]
mov r15, [r12+20h]
mov rax, [rsp+88h+var_60]
mov [rsp+88h+var_80], rax
jmp loc_144C
endbr64
mov rbx, rax
mov rsi, [r14+10h]
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE8_M_eraseEPSt13_Rb_tree_nodeIS9_E; std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_erase(std::_Rb_tree_node<std::pair<std::string const,std::pair<double,int>>> *)
mov rax, [rsp+arg_40]
sub rax, fs:28h
jz short loc_1594
call ___stack_chk_fail
loc_1594:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_159C:
call ___stack_chk_fail | long long func0(long long a1, _QWORD *a2, size_t a3, double a4)
{
long long v4; // r12
long long v6; // rbx
int v7; // edx
long long v8; // rbp
size_t v9; // rbx
size_t v10; // rdx
size_t v11; // rbx
unsigned int v12; // eax
long long v13; // r13
size_t v14; // r13
const void *v15; // r15
long long v16; // [rsp+8h] [rbp-80h]
_QWORD *v17; // [rsp+10h] [rbp-78h]
int v18; // [rsp+24h] [rbp-64h]
char v19; // [rsp+3Fh] [rbp-49h] BYREF
_QWORD v20[9]; // [rsp+40h] [rbp-48h] BYREF
v18 = a3;
v20[1] = __readfsqword(0x28u);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v4 = a2[3];
v17 = a2 + 1;
if ( a2 + 1 == (_QWORD *)v4 )
return a1;
while ( 2 )
{
if ( *(double *)(v4 + 64) < a4 || *(_DWORD *)(v4 + 72) < v18 )
goto LABEL_27;
v8 = *(_QWORD *)(a1 + 16);
if ( !v8 )
{
v16 = a1 + 8;
goto LABEL_24;
}
v14 = *(_QWORD *)(v4 + 40);
v15 = *(const void **)(v4 + 32);
v16 = a1 + 8;
do
{
v9 = *(_QWORD *)(v8 + 40);
v10 = v14;
if ( v9 <= v14 )
v10 = *(_QWORD *)(v8 + 40);
if ( v10 )
{
v7 = memcmp(*(const void **)(v8 + 32), v15, v10);
if ( v7 )
goto LABEL_6;
}
v6 = v9 - v14;
if ( v6 >= 0x80000000LL )
goto LABEL_7;
if ( v6 > (long long)0xFFFFFFFF7FFFFFFFLL )
{
v7 = v6;
LABEL_6:
if ( v7 >= 0 )
{
LABEL_7:
v16 = v8;
v8 = *(_QWORD *)(v8 + 16);
continue;
}
}
v8 = *(_QWORD *)(v8 + 24);
}
while ( v8 );
if ( a1 + 8 == v16 )
goto LABEL_24;
v11 = *(_QWORD *)(v16 + 40);
a3 = v11;
if ( v14 <= v11 )
a3 = v14;
a2 = *(_QWORD **)(v16 + 32);
if ( a3 && (v12 = memcmp(v15, a2, a3), (a3 = v12) != 0) )
{
LABEL_23:
if ( (a3 & 0x80000000) != 0LL )
goto LABEL_24;
}
else
{
v13 = v14 - v11;
if ( v13 <= 0x7FFFFFFF )
{
if ( v13 >= (long long)0xFFFFFFFF80000000LL )
{
a3 = (unsigned int)v13;
goto LABEL_23;
}
LABEL_24:
v20[0] = v4 + 32;
a2 = (_QWORD *)v16;
v16 = std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_emplace_hint_unique<std::piecewise_construct_t const&,std::tuple<std::string const&>,std::tuple<>>(
a1,
v16,
&std::piecewise_construct,
v20,
&v19);
}
}
*(_QWORD *)(v16 + 64) = *(_QWORD *)(v4 + 64);
*(_DWORD *)(v16 + 72) = *(_DWORD *)(v4 + 72);
LABEL_27:
v4 = std::_Rb_tree_increment(v4, a2, a3);
if ( v17 != (_QWORD *)v4 )
continue;
return a1;
}
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV R14,RDI
MOVSD qword ptr [RSP + 0x18],XMM0
MOV dword ptr [RSP + 0x24],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA RAX,[RDI + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RDI + 0x18],RAX
MOV qword ptr [RDI + 0x20],RAX
MOV qword ptr [RDI + 0x28],0x0
MOV R12,qword ptr [RSI + 0x18]
LEA RAX,[RSI + 0x8]
MOV qword ptr [RSP + 0x10],RAX
CMP RAX,R12
JNZ 0x00101530
LAB_001013f6:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010159c
MOV RAX,R14
ADD RSP,0x58
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010141c:
SUB RBX,R13
MOV EAX,0x80000000
CMP RBX,RAX
JGE 0x0010143e
MOV RAX,-0x80000001
CMP RBX,RAX
JLE 0x00101473
MOV EDX,EBX
LAB_0010143a:
TEST EDX,EDX
JS 0x00101473
LAB_0010143e:
MOV qword ptr [RSP + 0x8],RBP
MOV RBP,qword ptr [RBP + 0x10]
LAB_00101447:
TEST RBP,RBP
JZ 0x00101479
LAB_0010144c:
MOV RBX,qword ptr [RBP + 0x28]
CMP RBX,R13
MOV RDX,R13
CMOVBE RDX,RBX
MOV RDI,qword ptr [RBP + 0x20]
TEST RDX,RDX
JZ 0x0010141c
MOV RSI,R15
CALL 0x001011b0
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x0010143a
JMP 0x0010141c
LAB_00101473:
MOV RBP,qword ptr [RBP + 0x18]
JMP 0x00101447
LAB_00101479:
MOV RAX,qword ptr [RSP + 0x8]
CMP qword ptr [RSP + 0x28],RAX
JZ 0x001014c6
MOV RBX,qword ptr [RAX + 0x28]
CMP R13,RBX
MOV RDX,RBX
CMOVBE RDX,R13
MOV RSI,qword ptr [RAX + 0x20]
TEST RDX,RDX
JZ 0x001014aa
MOV RDI,R15
CALL 0x001011b0
MOV EDX,EAX
TEST EAX,EAX
JNZ 0x001014c2
LAB_001014aa:
SUB R13,RBX
CMP R13,0x7fffffff
JG 0x00101501
CMP R13,-0x80000000
JL 0x001014c6
MOV EDX,R13D
LAB_001014c2:
TEST EDX,EDX
JNS 0x00101501
LAB_001014c6:
LEA RAX,[R12 + 0x20]
MOV qword ptr [RSP + 0x40],RAX
LEA RCX,[RSP + 0x40]
LEA R8,[RSP + 0x3f]
LEA RDX,[0x103115]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R14
LAB_001014e9:
CALL 0x00102670
JMP 0x001014fc
LAB_001014f0:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001014c6
LAB_001014fc:
MOV qword ptr [RSP + 0x8],RAX
LAB_00101501:
MOVSD XMM0,qword ptr [R12 + 0x40]
MOV RCX,qword ptr [RSP + 0x8]
MOVSD qword ptr [RCX + 0x40],XMM0
MOV EAX,dword ptr [R12 + 0x48]
MOV dword ptr [RCX + 0x48],EAX
LAB_0010151a:
MOV RDI,R12
CALL 0x00101240
MOV R12,RAX
CMP qword ptr [RSP + 0x10],RAX
JZ 0x001013f6
LAB_00101530:
MOVSD XMM0,qword ptr [R12 + 0x40]
COMISD XMM0,qword ptr [RSP + 0x18]
JC 0x0010151a
MOV EAX,dword ptr [RSP + 0x24]
CMP dword ptr [R12 + 0x48],EAX
JL 0x0010151a
MOV RBP,qword ptr [R14 + 0x10]
TEST RBP,RBP
JZ 0x001014f0
MOV R13,qword ptr [R12 + 0x28]
MOV R15,qword ptr [R12 + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0010144c
LAB_0010159c:
CALL 0x00101230 | /* func0(std::map<std::string, std::pair<double, int>, std::less<std::string >,
std::allocator<std::pair<std::string const, std::pair<double, int> > > > const&, double, int) */
map * func0(map *param_1,double param_2,int param_3)
{
map *pmVar1;
ulong uVar2;
ulong uVar3;
void *__s2;
int iVar4;
_Rb_tree_iterator _Var5;
int4 extraout_var;
_Rb_tree_node_base *p_Var6;
int in_EDX;
ulong uVar7;
long lVar8;
map *pmVar9;
map *pmVar10;
int4 in_register_00000034;
long in_FS_OFFSET;
map *local_80;
_Rb_tree_node_base *local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int4 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
pmVar1 = param_1 + 8;
*(map **)(param_1 + 0x18) = pmVar1;
*(map **)(param_1 + 0x20) = pmVar1;
*(int8 *)(param_1 + 0x28) = 0;
p_Var6 = *(_Rb_tree_node_base **)(CONCAT44(in_register_00000034,param_3) + 0x18);
do {
if ((_Rb_tree_node_base *)(CONCAT44(in_register_00000034,param_3) + 8) == p_Var6) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
if ((param_2 <= *(double *)(p_Var6 + 0x40)) && (in_EDX <= *(int *)(p_Var6 + 0x48))) {
local_80 = pmVar1;
if (*(map **)(param_1 + 0x10) == (map *)0x0) {
LAB_001014c6:
local_48 = p_Var6 + 0x20;
/* try { // try from 001014e9 to 001014ed has its CatchHandler @ 0010156c */
_Var5 = std::
_Rb_tree<std::string,std::pair<std::string_const,std::pair<double,int>>,std::_Select1st<std::pair<std::string_const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::
_M_emplace_hint_unique<std::piecewise_construct_t_const&,std::tuple<std::string_const&>,std::tuple<>>
((_Rb_tree_const_iterator)param_1,(piecewise_construct_t *)local_80,
(tuple *)&std::piecewise_construct,(tuple *)&local_48);
local_80 = (map *)CONCAT44(extraout_var,_Var5);
}
else {
uVar3 = *(ulong *)(p_Var6 + 0x28);
__s2 = *(void **)(p_Var6 + 0x20);
pmVar10 = *(map **)(param_1 + 0x10);
do {
uVar2 = *(ulong *)(pmVar10 + 0x28);
uVar7 = uVar3;
if (uVar2 <= uVar3) {
uVar7 = uVar2;
}
if ((uVar7 == 0) || (iVar4 = memcmp(*(void **)(pmVar10 + 0x20),__s2,uVar7), iVar4 == 0)) {
lVar8 = uVar2 - uVar3;
if (lVar8 < 0x80000000) {
if (-0x80000001 < lVar8) {
iVar4 = (int)lVar8;
goto LAB_0010143a;
}
goto LAB_00101473;
}
LAB_0010143e:
pmVar9 = *(map **)(pmVar10 + 0x10);
local_80 = pmVar10;
}
else {
LAB_0010143a:
if (-1 < iVar4) goto LAB_0010143e;
LAB_00101473:
pmVar9 = *(map **)(pmVar10 + 0x18);
}
pmVar10 = pmVar9;
} while (pmVar9 != (map *)0x0);
if (pmVar1 == local_80) goto LAB_001014c6;
uVar2 = *(ulong *)(local_80 + 0x28);
uVar7 = uVar2;
if (uVar3 <= uVar2) {
uVar7 = uVar3;
}
if ((uVar7 == 0) || (iVar4 = memcmp(__s2,*(void **)(local_80 + 0x20),uVar7), iVar4 == 0)) {
lVar8 = uVar3 - uVar2;
if (lVar8 < 0x80000000) {
if (lVar8 < -0x80000000) goto LAB_001014c6;
iVar4 = (int)lVar8;
goto LAB_001014c2;
}
}
else {
LAB_001014c2:
if (iVar4 < 0) goto LAB_001014c6;
}
}
*(int8 *)(local_80 + 0x40) = *(int8 *)(p_Var6 + 0x40);
*(int4 *)(local_80 + 0x48) = *(int4 *)(p_Var6 + 0x48);
}
p_Var6 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var6);
} while( true );
} |
2,886 | func0 |
#include <cassert>
#include <map>
#include <string>
#include <utility>
| std::map<std::string, std::pair<double, int>> func0(const std::map<std::string, std::pair<double, int>>& students, double h, int w) {
std::map<std::string, std::pair<double, int>> result;
for (const auto& [k, s] : students) {
if (s.first >= h && s.second >= w) {
result[k] = s;
}
}
return result;
}
| int main() {
std::map<std::string, std::pair<double, int>> students = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
std::map<std::string, std::pair<double, int>> expected1 = {
{"Cierra Vega", {6.2, 70}}
};
assert(func0(students, 6.0, 70) == expected1);
std::map<std::string, std::pair<double, int>> expected2 = {
{"Cierra Vega", {6.2, 70}},
{"Kierra Gentry", {6.0, 68}}
};
assert(func0(students, 5.9, 67) == expected2);
std::map<std::string, std::pair<double, int>> expected3 = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
assert(func0(students, 5.7, 64) == expected3);
return 0;
}
| O2 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<double, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<double, int> > > > const&, double, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,0x18(%rsp)
lea 0x4f(%rsp),%rbx
mov %edx,0x14(%rsp)
movsd %xmm0,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x8(%rdi),%rax
mov %rbx,0x30(%rsp)
mov %rax,0x18(%rdi)
mov %rax,0x20(%rdi)
movq $0x0,0x10(%rdi)
mov 0x18(%rsi),%rbp
mov %rax,0x20(%rsp)
lea 0x8(%rsi),%rax
movl $0x0,0x8(%rdi)
movq $0x0,0x28(%rdi)
mov %rax,(%rsp)
cmp %rax,%rbp
jne 1ae5 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x95>
jmpq 1c60 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x210>
nopl 0x0(%rax)
mov %rbp,%rdi
callq 1210 <_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,(%rsp)
je 1c60 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x210>
movsd 0x40(%rbp),%xmm0
comisd 0x8(%rsp),%xmm0
jb 1ad0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
mov 0x48(%rbp),%eax
mov %eax,0x10(%rsp)
cmp 0x14(%rsp),%eax
jl 1ad0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
mov 0x18(%rsp),%rax
mov 0x10(%rax),%r13
test %r13,%r13
je 1c08 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1b8>
mov 0x28(%rbp),%r14
mov 0x20(%rbp),%rbx
movsd %xmm0,0x28(%rsp)
mov 0x20(%rsp),%r15
jmp 1b39 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe9>
nopw %cs:0x0(%rax,%rax,1)
mov 0x18(%r13),%r13
test %r13,%r13
je 1b8b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x13b>
mov 0x28(%r13),%r12
mov %r14,%rdx
cmp %r14,%r12
cmovbe %r12,%rdx
test %rdx,%rdx
je 1b5c <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x10c>
mov 0x20(%r13),%rdi
mov %rbx,%rsi
callq 1180 <memcmp@plt>
test %eax,%eax
jne 1b7b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12b>
sub %r14,%r12
mov $0x80000000,%eax
cmp %rax,%r12
jge 1b7f <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12f>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%r12
jle 1b30 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe0>
mov %r12d,%eax
test %eax,%eax
js 1b30 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe0>
mov %r13,%r15
mov 0x10(%r13),%r13
test %r13,%r13
jne 1b39 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe9>
movsd 0x28(%rsp),%xmm0
cmp %r15,0x20(%rsp)
je 1c0d <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov 0x28(%r15),%rcx
cmp %rcx,%r14
mov %rcx,%rdx
cmovbe %r14,%rdx
test %rdx,%rdx
je 1bcb <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x17b>
mov 0x20(%r15),%rsi
mov %rbx,%rdi
mov %rcx,0x38(%rsp)
callq 1180 <memcmp@plt>
movsd 0x28(%rsp),%xmm0
mov 0x38(%rsp),%rcx
test %eax,%eax
jne 1bed <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x19d>
mov %r14,%r10
mov $0x80000000,%eax
sub %rcx,%r10
cmp %rax,%r10
jge 1bf1 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1a1>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%r10
jle 1c0d <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov %r10d,%eax
test %eax,%eax
js 1c0d <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov 0x10(%rsp),%eax
movsd %xmm0,0x40(%r15)
mov %eax,0x48(%r15)
jmpq 1ad0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
nopl 0x0(%rax)
mov 0x20(%rsp),%r15
mov 0x30(%rsp),%r8
mov 0x18(%rsp),%rdi
lea 0x20(%rbp),%rax
lea 0x50(%rsp),%rcx
lea 0x150f(%rip),%rdx
mov %r15,%rsi
mov %rax,0x50(%rsp)
callq 22c0 <_ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS7_EESK_IJEEEEESt17_Rb_tree_iteratorIS9_ESt23_Rb_tree_const_iteratorIS9_EDpOT_>
mov %rax,%r15
mov 0x48(%rbp),%eax
movsd 0x40(%rbp),%xmm0
mov %eax,0x10(%rsp)
mov 0x10(%rsp),%eax
movsd %xmm0,0x40(%r15)
mov %eax,0x48(%r15)
jmpq 1ad0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
nopw %cs:0x0(%rax,%rax,1)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1c84 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x234>
mov 0x18(%rsp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1200 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1260 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi:
endbr64
push r15
lea rax, [rdi+8]
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 48h
mov [rdi+18h], rax
mov rbx, [rsi+18h]
mov [rsp+78h+var_60], rax
mov [rdi+20h], rax
lea rax, [rsi+8]
mov [rsp+78h+var_64], edx
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov qword ptr [rdi+28h], 0
mov [rsp+78h+var_70], rax
movsd [rsp+78h+var_78], xmm0
cmp rax, rbx
jnz short loc_1F06
jmp loc_20F8
loc_1EF0:
mov rdi, rbx
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov rbx, rax
cmp [rsp+78h+var_70], rax
jz loc_20F8
loc_1F06:
movsd xmm0, qword ptr [rbx+40h]
comisd xmm0, [rsp+78h+var_78]
jb short loc_1EF0
mov r14d, [rbx+48h]
mov eax, [rsp+78h+var_64]
cmp r14d, eax
jl short loc_1EF0
mov r15, [r12+10h]
test r15, r15
jz loc_2038
mov rax, [rbx+20h]
mov r13, [rbx+28h]
mov [rsp+78h+var_50], rbx
mov [rsp+78h+var_48], r12
mov rbp, [rsp+78h+var_60]
mov r12, r15
mov [rsp+78h+s1], rax
mov rbx, r13
mov r15, rax
movsd [rsp+78h+var_58], xmm0
jmp short loc_1F6A
loc_1F60:
mov r12, [r12+18h]
test r12, r12
jz short loc_1FC1
loc_1F6A:
mov r13, [r12+28h]
mov rdx, rbx
mov rdi, [r12+20h]; s1
cmp r13, rbx
cmovbe rdx, r13; n
test rdx, rdx
jz short loc_1F8F
mov rsi, r15; s2
call _memcmp
test eax, eax
jnz short loc_1FB0
loc_1F8F:
mov rcx, r13
mov eax, 80000000h
sub rcx, rbx
cmp rcx, rax
jge short loc_1FB4
mov rax, 0FFFFFFFF7FFFFFFFh
cmp rcx, rax
jle short loc_1F60
mov eax, ecx
loc_1FB0:
test eax, eax
js short loc_1F60
loc_1FB4:
mov rbp, r12
mov r12, [r12+10h]
test r12, r12
jnz short loc_1F6A
loc_1FC1:
mov r13, rbx
movsd xmm0, [rsp+78h+var_58]
mov rbx, [rsp+78h+var_50]
mov r12, [rsp+78h+var_48]
cmp [rsp+78h+var_60], rbp
jz short loc_203D
mov r15, [rbp+28h]
mov rdx, r13
mov rsi, [rbp+20h]; s2
cmp r15, r13
cmovbe rdx, r15; n
test rdx, rdx
jz short loc_2006
mov rdi, [rsp+78h+s1]; s1
call _memcmp
movsd xmm0, [rsp+78h+var_58]
test eax, eax
jnz short loc_2020
loc_2006:
mov rcx, r13
sub rcx, r15
cmp rcx, 7FFFFFFFh
jg short loc_2024
cmp rcx, 0FFFFFFFF80000000h
jl short loc_203D
mov eax, ecx
loc_2020:
test eax, eax
js short loc_203D
loc_2024:
mov [rbp+48h], r14d
movsd qword ptr [rbp+40h], xmm0
jmp loc_1EF0
loc_2038:
mov rbp, [rsp+78h+var_60]
loc_203D:
mov edi, 50h ; 'P'; unsigned __int64
mov r15, rbp
call __Znwm; operator new(ulong)
lea r14, [rax+30h]
mov rdx, [rbx+28h]
lea r13, [rax+20h]
mov rbp, rax
mov [rax+20h], r14
mov rsi, [rbx+20h]
mov rdi, r13
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 dword ptr [rbp+48h], 0
mov rdx, r13
mov rsi, r15
mov rdi, r12
mov qword ptr [rbp+40h], 0
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS9_ERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>,std::string const&)
mov r15, rax
mov r13, rdx
test rdx, rdx
jz short loc_2110
test rax, rax
jnz loc_2150
cmp [rsp+78h+var_60], rdx
jz loc_2150
mov r14, [rbp+28h]
mov r15, [rdx+28h]
cmp r14, r15
mov rdx, r15
cmovbe rdx, r14; n
test rdx, rdx
jz short loc_20D2
mov rdi, [rbp+20h]; s1
mov rsi, [r13+20h]; s2
call _memcmp
mov edi, eax
test eax, eax
jnz short loc_20EC
loc_20D2:
sub r14, r15
xor edi, edi
cmp r14, 7FFFFFFFh
jg short loc_2155
cmp r14, 0FFFFFFFF80000000h
jl short loc_2150
mov edi, r14d
loc_20EC:
shr edi, 1Fh
jmp short loc_2155
loc_20F8:
add rsp, 48h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2110:
mov rdi, [rbp+20h]; void *
cmp r14, rdi
jz short loc_2126
mov rax, [rbp+30h]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2126:
mov rdi, rbp; void *
mov esi, 50h ; 'P'; unsigned __int64
mov rbp, r15
call __ZdlPvm; operator delete(void *,ulong)
loc_2136:
movsd xmm0, qword ptr [rbx+40h]
mov r14d, [rbx+48h]
movsd qword ptr [rbp+40h], xmm0
mov [rbp+48h], r14d
jmp loc_1EF0
loc_2150:
mov edi, 1
loc_2155:
mov rcx, [rsp+78h+var_60]
mov rdx, r13
mov rsi, 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
jmp short loc_2136
endbr64
mov rdi, rax
jmp _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi_cold; func0(std::map<std::string,std::pair<double,int>> const&,double,int) [clone]
endbr64
mov rbx, rax
jmp loc_12C3 | long long func0(long long a1, long long a2, int a3, double a4)
{
long long v4; // r12
long long v5; // rbx
double v6; // xmm0_8
int v7; // r14d
long long v8; // rbp
long long v9; // r12
size_t v10; // rbx
size_t v11; // r13
size_t v12; // rdx
int v13; // eax
size_t v14; // r13
size_t v15; // r15
size_t v16; // rdx
int v17; // eax
long long v18; // r15
long long v19; // rax
void *v20; // r14
long long v21; // rdx
long long v22; // r13
long long v23; // rbp
long long insert_hint_unique_pos; // rax
long long v25; // rdx
long long v26; // r15
long long v27; // r13
size_t v28; // r14
size_t v29; // r15
size_t v30; // rdx
unsigned int v31; // edi
long long v32; // r14
long long v33; // rdi
void *v35; // rdi
void *v36; // rdi
int v37; // r14d
long long v40; // [rsp+18h] [rbp-60h]
long long v41; // [rsp+28h] [rbp-50h]
long long v42; // [rsp+30h] [rbp-48h]
void *s1; // [rsp+38h] [rbp-40h]
v4 = a1;
*(_QWORD *)(a1 + 24) = a1 + 8;
v5 = *(_QWORD *)(a2 + 24);
v40 = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
if ( a2 + 8 == v5 )
return v4;
while ( 2 )
{
v6 = *(double *)(v5 + 64);
if ( v6 < a4 )
goto LABEL_3;
v7 = *(_DWORD *)(v5 + 72);
if ( v7 < a3 )
goto LABEL_3;
if ( !*(_QWORD *)(v4 + 16) )
{
v8 = v40;
goto LABEL_29;
}
v41 = v5;
v42 = v4;
v8 = v40;
v9 = *(_QWORD *)(v4 + 16);
s1 = *(void **)(v5 + 32);
v10 = *(_QWORD *)(v5 + 40);
do
{
while ( 1 )
{
v11 = *(_QWORD *)(v9 + 40);
v12 = v10;
if ( v11 <= v10 )
v12 = *(_QWORD *)(v9 + 40);
if ( v12 )
{
v13 = memcmp(*(const void **)(v9 + 32), s1, v12);
if ( v13 )
break;
}
if ( (long long)(v11 - v10) >= 0x80000000LL )
goto LABEL_17;
if ( (long long)(v11 - v10) > (long long)0xFFFFFFFF7FFFFFFFLL )
{
v13 = v11 - v10;
break;
}
LABEL_8:
v9 = *(_QWORD *)(v9 + 24);
if ( !v9 )
goto LABEL_18;
}
if ( v13 < 0 )
goto LABEL_8;
LABEL_17:
v8 = v9;
v9 = *(_QWORD *)(v9 + 16);
}
while ( v9 );
LABEL_18:
v14 = v10;
v5 = v41;
v4 = v42;
if ( v40 == v8 )
goto LABEL_29;
v15 = *(_QWORD *)(v8 + 40);
v16 = v14;
if ( v15 <= v14 )
v16 = *(_QWORD *)(v8 + 40);
if ( v16 )
{
v17 = memcmp(s1, *(const void **)(v8 + 32), v16);
if ( v17 )
{
LABEL_26:
if ( v17 < 0 )
goto LABEL_29;
goto LABEL_27;
}
}
if ( (long long)(v14 - v15) > 0x7FFFFFFF )
{
LABEL_27:
*(_DWORD *)(v8 + 72) = v7;
*(double *)(v8 + 64) = v6;
goto LABEL_3;
}
if ( (long long)(v14 - v15) >= (long long)0xFFFFFFFF80000000LL )
{
v17 = v14 - v15;
goto LABEL_26;
}
LABEL_29:
v18 = v8;
v19 = operator new(0x50uLL);
v20 = (void *)(v19 + 48);
v21 = *(_QWORD *)(v5 + 40);
v22 = v19 + 32;
v23 = v19;
*(_QWORD *)(v19 + 32) = v19 + 48;
std::string::_M_construct<char *>(v19 + 32, *(_QWORD *)(v5 + 32), *(_QWORD *)(v5 + 32) + v21, v6);
*(_DWORD *)(v23 + 72) = 0;
*(_QWORD *)(v23 + 64) = 0LL;
insert_hint_unique_pos = std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_get_insert_hint_unique_pos(
v4,
v18,
v22);
v26 = insert_hint_unique_pos;
v27 = v25;
if ( v25 )
{
if ( insert_hint_unique_pos || v40 == v25 )
goto LABEL_45;
v28 = *(_QWORD *)(v23 + 40);
v30 = *(_QWORD *)(v25 + 40);
v29 = v30;
if ( v28 <= v30 )
v30 = *(_QWORD *)(v23 + 40);
if ( v30 && (v31 = memcmp(*(const void **)(v23 + 32), *(const void **)(v27 + 32), v30)) != 0 )
{
LABEL_39:
v33 = v31 >> 31;
}
else
{
v32 = v28 - v29;
v33 = 0LL;
if ( v32 <= 0x7FFFFFFF )
{
if ( v32 >= (long long)0xFFFFFFFF80000000LL )
{
v31 = v32;
goto LABEL_39;
}
LABEL_45:
v33 = 1LL;
}
}
std::_Rb_tree_insert_and_rebalance(v33, v23, v27, v40);
++*(_QWORD *)(v4 + 40);
}
else
{
v35 = *(void **)(v23 + 32);
if ( v20 != v35 )
operator delete(v35, *(_QWORD *)(v23 + 48) + 1LL);
v36 = (void *)v23;
v23 = v26;
operator delete(v36, 0x50uLL);
}
v37 = *(_DWORD *)(v5 + 72);
*(_QWORD *)(v23 + 64) = *(_QWORD *)(v5 + 64);
*(_DWORD *)(v23 + 72) = v37;
LABEL_3:
v5 = std::_Rb_tree_increment(v5);
if ( a2 + 8 != v5 )
continue;
return v4;
}
} | func0:
ENDBR64
PUSH R15
LEA RAX,[RDI + 0x8]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RDI + 0x18],RAX
MOV RBX,qword ptr [RSI + 0x18]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI + 0x20],RAX
LEA RAX,[RSI + 0x8]
MOV dword ptr [RSP + 0x14],EDX
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x28],0x0
MOV qword ptr [RSP + 0x8],RAX
MOVSD qword ptr [RSP],XMM0
CMP RAX,RBX
JNZ 0x00101f06
JMP 0x001020f8
LAB_00101ef0:
MOV RDI,RBX
CALL 0x00101240
MOV RBX,RAX
CMP qword ptr [RSP + 0x8],RAX
JZ 0x001020f8
LAB_00101f06:
MOVSD XMM0,qword ptr [RBX + 0x40]
COMISD XMM0,qword ptr [RSP]
JC 0x00101ef0
MOV R14D,dword ptr [RBX + 0x48]
MOV EAX,dword ptr [RSP + 0x14]
CMP R14D,EAX
JL 0x00101ef0
MOV R15,qword ptr [R12 + 0x10]
TEST R15,R15
JZ 0x00102038
MOV RAX,qword ptr [RBX + 0x20]
MOV R13,qword ptr [RBX + 0x28]
MOV qword ptr [RSP + 0x28],RBX
MOV qword ptr [RSP + 0x30],R12
MOV RBP,qword ptr [RSP + 0x18]
MOV R12,R15
MOV qword ptr [RSP + 0x38],RAX
MOV RBX,R13
MOV R15,RAX
MOVSD qword ptr [RSP + 0x20],XMM0
JMP 0x00101f6a
LAB_00101f60:
MOV R12,qword ptr [R12 + 0x18]
TEST R12,R12
JZ 0x00101fc1
LAB_00101f6a:
MOV R13,qword ptr [R12 + 0x28]
MOV RDX,RBX
MOV RDI,qword ptr [R12 + 0x20]
CMP R13,RBX
CMOVBE RDX,R13
TEST RDX,RDX
JZ 0x00101f8f
MOV RSI,R15
CALL 0x001011b0
TEST EAX,EAX
JNZ 0x00101fb0
LAB_00101f8f:
MOV RCX,R13
MOV EAX,0x80000000
SUB RCX,RBX
CMP RCX,RAX
JGE 0x00101fb4
MOV RAX,-0x80000001
CMP RCX,RAX
JLE 0x00101f60
MOV EAX,ECX
LAB_00101fb0:
TEST EAX,EAX
JS 0x00101f60
LAB_00101fb4:
MOV RBP,R12
MOV R12,qword ptr [R12 + 0x10]
TEST R12,R12
JNZ 0x00101f6a
LAB_00101fc1:
MOV R13,RBX
MOVSD XMM0,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
MOV R12,qword ptr [RSP + 0x30]
CMP qword ptr [RSP + 0x18],RBP
JZ 0x0010203d
MOV R15,qword ptr [RBP + 0x28]
MOV RDX,R13
MOV RSI,qword ptr [RBP + 0x20]
CMP R15,R13
CMOVBE RDX,R15
TEST RDX,RDX
JZ 0x00102006
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001011b0
MOVSD XMM0,qword ptr [RSP + 0x20]
TEST EAX,EAX
JNZ 0x00102020
LAB_00102006:
MOV RCX,R13
SUB RCX,R15
CMP RCX,0x7fffffff
JG 0x00102024
CMP RCX,-0x80000000
JL 0x0010203d
MOV EAX,ECX
LAB_00102020:
TEST EAX,EAX
JS 0x0010203d
LAB_00102024:
MOV dword ptr [RBP + 0x48],R14D
MOVSD qword ptr [RBP + 0x40],XMM0
JMP 0x00101ef0
LAB_00102038:
MOV RBP,qword ptr [RSP + 0x18]
LAB_0010203d:
MOV EDI,0x50
MOV R15,RBP
LAB_00102045:
CALL 0x00101200
LEA R14,[RAX + 0x30]
MOV RDX,qword ptr [RBX + 0x28]
LEA R13,[RAX + 0x20]
MOV RBP,RAX
MOV qword ptr [RAX + 0x20],R14
MOV RSI,qword ptr [RBX + 0x20]
MOV RDI,R13
ADD RDX,RSI
LAB_00102067:
CALL 0x00101d80
MOV dword ptr [RBP + 0x48],0x0
MOV RDX,R13
MOV RSI,R15
MOV RDI,R12
MOV qword ptr [RBP + 0x40],0x0
CALL 0x001024a0
MOV R15,RAX
MOV R13,RDX
TEST RDX,RDX
JZ 0x00102110
TEST RAX,RAX
JNZ 0x00102150
CMP qword ptr [RSP + 0x18],RDX
JZ 0x00102150
MOV R14,qword ptr [RBP + 0x28]
MOV R15,qword ptr [RDX + 0x28]
CMP R14,R15
MOV RDX,R15
CMOVBE RDX,R14
TEST RDX,RDX
JZ 0x001020d2
MOV RDI,qword ptr [RBP + 0x20]
MOV RSI,qword ptr [R13 + 0x20]
CALL 0x001011b0
MOV EDI,EAX
TEST EAX,EAX
JNZ 0x001020ec
LAB_001020d2:
SUB R14,R15
XOR EDI,EDI
CMP R14,0x7fffffff
JG 0x00102155
CMP R14,-0x80000000
JL 0x00102150
MOV EDI,R14D
LAB_001020ec:
SHR EDI,0x1f
JMP 0x00102155
LAB_001020f8:
ADD RSP,0x48
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102110:
MOV RDI,qword ptr [RBP + 0x20]
CMP R14,RDI
JZ 0x00102126
MOV RAX,qword ptr [RBP + 0x30]
LEA RSI,[RAX + 0x1]
CALL 0x00101210
LAB_00102126:
MOV RDI,RBP
MOV ESI,0x50
MOV RBP,R15
CALL 0x00101210
LAB_00102136:
MOVSD XMM0,qword ptr [RBX + 0x40]
MOV R14D,dword ptr [RBX + 0x48]
MOVSD qword ptr [RBP + 0x40],XMM0
MOV dword ptr [RBP + 0x48],R14D
JMP 0x00101ef0
LAB_00102150:
MOV EDI,0x1
LAB_00102155:
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,R13
MOV RSI,RBP
CALL 0x00101170
ADD qword ptr [R12 + 0x28],0x1
JMP 0x00102136 | /* func0(std::map<std::string, std::pair<double, int>, std::less<std::string >,
std::allocator<std::pair<std::string const, std::pair<double, int> > > > const&, double, int) */
map * func0(map *param_1,double param_2,int param_3)
{
_Rb_tree_node_base *p_Var1;
double dVar2;
int4 uVar3;
void *__s2;
ulong uVar4;
ulong uVar5;
int8 uVar6;
int iVar7;
int iVar8;
_Rb_tree_node_base *p_Var9;
_Rb_tree_node_base *p_Var10;
long lVar11;
int in_EDX;
ulong uVar12;
_Rb_tree_node_base *p_Var13;
_Rb_tree_node_base *p_Var14;
int4 in_register_00000034;
bool bVar15;
int auVar16 [16];
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
*(_Rb_tree_node_base **)(param_1 + 0x18) = p_Var1;
p_Var9 = *(_Rb_tree_node_base **)(CONCAT44(in_register_00000034,param_3) + 0x18);
*(_Rb_tree_node_base **)(param_1 + 0x20) = p_Var1;
*(int4 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = 0;
do {
if ((_Rb_tree_node_base *)(CONCAT44(in_register_00000034,param_3) + 8) == p_Var9) {
return param_1;
}
dVar2 = *(double *)(p_Var9 + 0x40);
if ((param_2 <= dVar2) && (iVar8 = *(int *)(p_Var9 + 0x48), in_EDX <= iVar8)) {
p_Var14 = p_Var1;
if (*(_Rb_tree_node_base **)(param_1 + 0x10) != (_Rb_tree_node_base *)0x0) {
__s2 = *(void **)(p_Var9 + 0x20);
uVar4 = *(ulong *)(p_Var9 + 0x28);
p_Var10 = *(_Rb_tree_node_base **)(param_1 + 0x10);
do {
while( true ) {
uVar5 = *(ulong *)(p_Var10 + 0x28);
uVar12 = uVar4;
if (uVar5 <= uVar4) {
uVar12 = uVar5;
}
if ((uVar12 != 0) &&
(iVar7 = memcmp(*(void **)(p_Var10 + 0x20),__s2,uVar12), iVar7 != 0)) break;
lVar11 = uVar5 - uVar4;
if (lVar11 < 0x80000000) {
if (-0x80000001 < lVar11) {
iVar7 = (int)lVar11;
break;
}
goto LAB_00101f60;
}
LAB_00101fb4:
p_Var13 = p_Var10 + 0x10;
p_Var14 = p_Var10;
p_Var10 = *(_Rb_tree_node_base **)p_Var13;
if (*(_Rb_tree_node_base **)p_Var13 == (_Rb_tree_node_base *)0x0) goto LAB_00101fc1;
}
if (-1 < iVar7) goto LAB_00101fb4;
LAB_00101f60:
p_Var10 = *(_Rb_tree_node_base **)(p_Var10 + 0x18);
} while (p_Var10 != (_Rb_tree_node_base *)0x0);
LAB_00101fc1:
if (p_Var1 != p_Var14) {
uVar5 = *(ulong *)(p_Var14 + 0x28);
uVar12 = uVar4;
if (uVar5 <= uVar4) {
uVar12 = uVar5;
}
if ((uVar12 == 0) || (iVar7 = memcmp(__s2,*(void **)(p_Var14 + 0x20),uVar12), iVar7 == 0))
{
lVar11 = uVar4 - uVar5;
if (lVar11 < 0x80000000) {
if (lVar11 < -0x80000000) goto LAB_0010203d;
iVar7 = (int)lVar11;
goto LAB_00102020;
}
}
else {
LAB_00102020:
if (iVar7 < 0) goto LAB_0010203d;
}
*(int *)(p_Var14 + 0x48) = iVar8;
*(double *)(p_Var14 + 0x40) = dVar2;
goto LAB_00101ef0;
}
}
LAB_0010203d:
/* try { // try from 00102045 to 00102049 has its CatchHandler @ 00102179 */
p_Var10 = (_Rb_tree_node_base *)operator_new(0x50);
uVar6 = *(int8 *)(p_Var9 + 0x28);
*(_Rb_tree_node_base **)(p_Var10 + 0x20) = p_Var10 + 0x30;
/* try { // try from 00102067 to 0010206b has its CatchHandler @ 0010216d */
std::string::_M_construct<char*>
((char *)(p_Var10 + 0x20),*(char **)(p_Var9 + 0x20),
(int)uVar6 + (int)*(char **)(p_Var9 + 0x20));
*(int4 *)(p_Var10 + 0x48) = 0;
*(int8 *)(p_Var10 + 0x40) = 0;
auVar16 = std::
_Rb_tree<std::string,std::pair<std::string_const,std::pair<double,int>>,std::_Select1st<std::pair<std::string_const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::_M_get_insert_hint_unique_pos
((_Rb_tree<std::string,std::pair<std::string_const,std::pair<double,int>>,std::_Select1st<std::pair<std::string_const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)param_1,(_Rb_tree_const_iterator)p_Var14,(string *)(p_Var10 + 0x20));
p_Var13 = auVar16._8_8_;
p_Var14 = auVar16._0_8_;
if (p_Var13 == (_Rb_tree_node_base *)0x0) {
if (p_Var10 + 0x30 != *(_Rb_tree_node_base **)(p_Var10 + 0x20)) {
operator_delete(*(_Rb_tree_node_base **)(p_Var10 + 0x20),*(long *)(p_Var10 + 0x30) + 1);
}
operator_delete(p_Var10,0x50);
}
else {
if ((p_Var14 == (_Rb_tree_node_base *)0x0) && (p_Var1 != p_Var13)) {
uVar4 = *(ulong *)(p_Var10 + 0x28);
uVar5 = *(ulong *)(p_Var13 + 0x28);
uVar12 = uVar5;
if (uVar4 <= uVar5) {
uVar12 = uVar4;
}
if ((uVar12 == 0) ||
(iVar8 = memcmp(*(void **)(p_Var10 + 0x20),*(void **)(p_Var13 + 0x20),uVar12),
iVar8 == 0)) {
lVar11 = uVar4 - uVar5;
bVar15 = false;
if (0x7fffffff < lVar11) goto LAB_00102155;
if (lVar11 < -0x80000000) goto LAB_00102150;
iVar8 = (int)lVar11;
}
bVar15 = SUB41((uint)iVar8 >> 0x1f,0);
}
else {
LAB_00102150:
bVar15 = true;
}
LAB_00102155:
std::_Rb_tree_insert_and_rebalance(bVar15,p_Var10,p_Var13,p_Var1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
p_Var14 = p_Var10;
}
uVar3 = *(int4 *)(p_Var9 + 0x48);
*(int8 *)(p_Var14 + 0x40) = *(int8 *)(p_Var9 + 0x40);
*(int4 *)(p_Var14 + 0x48) = uVar3;
}
LAB_00101ef0:
p_Var9 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var9);
} while( true );
} |
2,887 | func0 |
#include <cassert>
#include <map>
#include <string>
#include <utility>
| std::map<std::string, std::pair<double, int>> func0(const std::map<std::string, std::pair<double, int>>& students, double h, int w) {
std::map<std::string, std::pair<double, int>> result;
for (const auto& [k, s] : students) {
if (s.first >= h && s.second >= w) {
result[k] = s;
}
}
return result;
}
| int main() {
std::map<std::string, std::pair<double, int>> students = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
std::map<std::string, std::pair<double, int>> expected1 = {
{"Cierra Vega", {6.2, 70}}
};
assert(func0(students, 6.0, 70) == expected1);
std::map<std::string, std::pair<double, int>> expected2 = {
{"Cierra Vega", {6.2, 70}},
{"Kierra Gentry", {6.0, 68}}
};
assert(func0(students, 5.9, 67) == expected2);
std::map<std::string, std::pair<double, int>> expected3 = {
{"Cierra Vega", {6.2, 70}},
{"Alden Cantrell", {5.9, 65}},
{"Kierra Gentry", {6.0, 68}},
{"Pierre Cox", {5.8, 66}}
};
assert(func0(students, 5.7, 64) == expected3);
return 0;
}
| O3 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::pair<double, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const, std::pair<double, int> > > > const&, double, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,0x18(%rsp)
lea 0x4f(%rsp),%rbx
mov %edx,0x14(%rsp)
movsd %xmm0,0x8(%rsp)
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x8(%rdi),%rax
mov %rbx,0x30(%rsp)
mov %rax,0x18(%rdi)
mov %rax,0x20(%rdi)
movq $0x0,0x10(%rdi)
mov 0x18(%rsi),%rbp
mov %rax,0x20(%rsp)
lea 0x8(%rsi),%rax
movl $0x0,0x8(%rdi)
movq $0x0,0x28(%rdi)
mov %rax,(%rsp)
cmp %rax,%rbp
jne 1ba5 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x95>
jmpq 1d20 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x210>
nopl 0x0(%rax)
mov %rbp,%rdi
callq 1210 <_ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base@plt>
mov %rax,%rbp
cmp %rax,(%rsp)
je 1d20 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x210>
movsd 0x40(%rbp),%xmm0
comisd 0x8(%rsp),%xmm0
jb 1b90 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
mov 0x48(%rbp),%eax
mov %eax,0x10(%rsp)
cmp 0x14(%rsp),%eax
jl 1b90 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
mov 0x18(%rsp),%rax
mov 0x10(%rax),%r13
test %r13,%r13
je 1cc8 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1b8>
mov 0x28(%rbp),%r14
mov 0x20(%rbp),%rbx
movsd %xmm0,0x28(%rsp)
mov 0x20(%rsp),%r15
jmp 1bf9 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe9>
nopw %cs:0x0(%rax,%rax,1)
mov 0x18(%r13),%r13
test %r13,%r13
je 1c4b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x13b>
mov 0x28(%r13),%r12
mov %r14,%rdx
cmp %r14,%r12
cmovbe %r12,%rdx
test %rdx,%rdx
je 1c1c <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x10c>
mov 0x20(%r13),%rdi
mov %rbx,%rsi
callq 1180 <memcmp@plt>
test %eax,%eax
jne 1c3b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12b>
sub %r14,%r12
mov $0x80000000,%eax
cmp %rax,%r12
jge 1c3f <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x12f>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%r12
jle 1bf0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe0>
mov %r12d,%eax
test %eax,%eax
js 1bf0 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe0>
mov %r13,%r15
mov 0x10(%r13),%r13
test %r13,%r13
jne 1bf9 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0xe9>
movsd 0x28(%rsp),%xmm0
cmp %r15,0x20(%rsp)
je 1ccd <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov 0x28(%r15),%rcx
cmp %rcx,%r14
mov %rcx,%rdx
cmovbe %r14,%rdx
test %rdx,%rdx
je 1c8b <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x17b>
mov 0x20(%r15),%rsi
mov %rbx,%rdi
mov %rcx,0x38(%rsp)
callq 1180 <memcmp@plt>
movsd 0x28(%rsp),%xmm0
mov 0x38(%rsp),%rcx
test %eax,%eax
jne 1cad <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x19d>
mov %r14,%r10
mov $0x80000000,%eax
sub %rcx,%r10
cmp %rax,%r10
jge 1cb1 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1a1>
movabs $0xffffffff7fffffff,%rax
cmp %rax,%r10
jle 1ccd <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov %r10d,%eax
test %eax,%eax
js 1ccd <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x1bd>
mov 0x10(%rsp),%eax
movsd %xmm0,0x40(%r15)
mov %eax,0x48(%r15)
jmpq 1b90 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
nopl 0x0(%rax)
mov 0x20(%rsp),%r15
mov 0x30(%rsp),%r8
mov 0x18(%rsp),%rdi
lea 0x20(%rbp),%rax
lea 0x50(%rsp),%rcx
lea 0x144e(%rip),%rdx
mov %r15,%rsi
mov %rax,0x50(%rsp)
callq 21e0 <_ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS7_EESK_IJEEEEESt17_Rb_tree_iteratorIS9_ESt23_Rb_tree_const_iteratorIS9_EDpOT_>
mov %rax,%r15
mov 0x48(%rbp),%eax
movsd 0x40(%rbp),%xmm0
mov %eax,0x10(%rsp)
mov 0x10(%rsp),%eax
movsd %xmm0,0x40(%r15)
mov %eax,0x48(%r15)
jmpq 1b90 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x80>
nopw %cs:0x0(%rax,%rax,1)
mov 0x58(%rsp),%rax
xor %fs:0x28,%rax
jne 1d44 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi+0x234>
mov 0x18(%rsp),%rax
add $0x68,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
callq 1200 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1260 <_Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 58h
mov [rsp+88h+var_74], edx
movsd [rsp+88h+var_88], xmm0
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea rax, [rdi+8]
mov dword ptr [rdi+8], 0
mov [rdi+18h], rax
mov rbx, [rsi+18h]
mov [rsp+88h+var_70], rax
mov [rdi+20h], rax
lea rax, [rsi+8]
mov qword ptr [rdi+10h], 0
mov qword ptr [rdi+28h], 0
mov [rsp+88h+var_80], rax
cmp rax, rbx
jnz short loc_2426
jmp loc_2658
loc_2410:
mov rdi, rbx
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov rbx, rax
cmp [rsp+88h+var_80], rax
jz loc_2658
loc_2426:
movsd xmm0, qword ptr [rbx+40h]
comisd xmm0, [rsp+88h+var_88]
jb short loc_2410
mov r15d, [rbx+48h]
mov eax, [rsp+88h+var_74]
cmp r15d, eax
jl short loc_2410
mov rax, [rbx+20h]
mov r14, [r13+10h]
mov r12, [rbx+28h]
mov rbp, [rsp+88h+var_70]
mov [rsp+88h+s1], rax
test r14, r14
jz loc_2560
mov [rsp+88h+src], rbx
mov rbx, r12
mov r12, r14
mov r14, rax
mov [rsp+88h+var_58], r13
movsd [rsp+88h+var_68], xmm0
jmp short loc_248A
loc_2480:
mov r12, [r12+18h]
test r12, r12
jz short loc_24E1
loc_248A:
mov r13, [r12+28h]
mov rdi, [r12+20h]; s1
cmp rbx, r13
mov rdx, r13
cmovbe rdx, rbx; n
test rdx, rdx
jz short loc_24AF
mov rsi, r14; s2
call _memcmp
test eax, eax
jnz short loc_24D0
loc_24AF:
mov rcx, r13
mov eax, 80000000h
sub rcx, rbx
cmp rcx, rax
jge short loc_24D4
mov rax, 0FFFFFFFF7FFFFFFFh
cmp rcx, rax
jle short loc_2480
mov eax, ecx
loc_24D0:
test eax, eax
js short loc_2480
loc_24D4:
mov rbp, r12
mov r12, [r12+10h]
test r12, r12
jnz short loc_248A
loc_24E1:
mov r12, rbx
movsd xmm0, [rsp+88h+var_68]
mov rbx, [rsp+88h+src]
mov r13, [rsp+88h+var_58]
cmp [rsp+88h+var_70], rbp
jz short loc_2560
mov rcx, [rbp+28h]
mov rsi, [rbp+20h]; s2
cmp r12, rcx
mov rdx, rcx
cmovbe rdx, r12; n
test rdx, rdx
jz short loc_2530
mov rdi, [rsp+88h+s1]; s1
mov [rsp+88h+src], rcx
call _memcmp
movsd xmm0, [rsp+88h+var_68]
mov rcx, [rsp+88h+src]
test eax, eax
jnz short loc_254B
loc_2530:
mov r8, r12
sub r8, rcx
cmp r8, 7FFFFFFFh
jg short loc_254F
cmp r8, 0FFFFFFFF80000000h
jl short loc_2560
mov eax, r8d
loc_254B:
test eax, eax
js short loc_2560
loc_254F:
mov [rbp+48h], r15d
movsd qword ptr [rbp+40h], xmm0
jmp loc_2410
loc_2560:
mov edi, 50h ; 'P'; unsigned __int64
mov [rsp+88h+var_68], rbp
call __Znwm; operator new(ulong)
mov rbp, rax
lea rax, [rax+20h]
mov r14, [rbx+28h]
lea r15, [rbp+30h]
mov r12, rax
mov [rbp+20h], r15
mov rax, [rbx+20h]
mov [rsp+88h+var_48], r14
mov [rsp+88h+src], rax
cmp r14, 0Fh
ja loc_26E0
cmp r14, 1
jz loc_2720
test r14, r14
jnz loc_272B
loc_25B0:
mov rax, r15
loc_25B3:
mov [rbp+28h], r14
mov rsi, [rsp+88h+var_68]
mov rdx, r12
mov rdi, r13
mov byte ptr [rax+r14], 0
mov qword ptr [rbp+40h], 0
mov dword ptr [rbp+48h], 0
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S6_IdiEESt10_Select1stIS9_ESt4lessIS5_ESaIS9_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS9_ERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<std::string const,std::pair<double,int>>>,std::string const&)
mov r14, rax
mov r8, rdx
test rdx, rdx
jz loc_26B8
cmp [rsp+88h+var_70], rdx
jz loc_2680
test rax, rax
jnz loc_2680
mov r14, [rbp+28h]
mov r15, [rdx+28h]
cmp r14, r15
mov rdx, r15
cmovbe rdx, r14; n
test rdx, rdx
jz short loc_2632
mov rsi, [r8+20h]; s2
mov rdi, [rbp+20h]; s1
mov [rsp+88h+var_68], r8
call _memcmp
mov r8, [rsp+88h+var_68]
test eax, eax
mov edi, eax
jnz short loc_264C
loc_2632:
sub r14, r15
xor edi, edi
cmp r14, 7FFFFFFFh
jg short loc_2685
cmp r14, 0FFFFFFFF80000000h
jl short loc_2680
mov edi, r14d
loc_264C:
shr edi, 1Fh
jmp short loc_2685
loc_2658:
mov rax, [rsp+88h+var_40]
sub rax, fs:28h
jnz loc_2730
add rsp, 58h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_2680:
mov edi, 1
loc_2685:
mov rcx, [rsp+88h+var_70]
mov rdx, r8
mov rsi, 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 [r13+28h], 1
loc_269A:
movsd xmm0, qword ptr [rbx+40h]
mov r15d, [rbx+48h]
movsd qword ptr [rbp+40h], xmm0
mov [rbp+48h], r15d
jmp loc_2410
loc_26B8:
mov rdi, [rbp+20h]; void *
cmp r15, rdi
jz short loc_26CE
mov rax, [rbp+30h]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_26CE:
mov rdi, rbp; void *
mov esi, 50h ; 'P'; unsigned __int64
mov rbp, r14
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_269A
loc_26E0:
lea rsi, [rsp+88h+var_48]
xor edx, edx
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+20h], rax
mov rdi, rax; dest
mov rax, [rsp+88h+var_48]
mov [rbp+30h], rax
loc_26FF:
mov rsi, [rsp+88h+src]; src
mov rdx, r14; n
call _memcpy
mov r14, [rsp+88h+var_48]
mov rax, [rbp+20h]
jmp loc_25B3
loc_2720:
movzx eax, byte ptr [rax]
mov [rbp+30h], al
jmp loc_25B0
loc_272B:
mov rdi, r15
jmp short loc_26FF
loc_2730:
call ___stack_chk_fail
endbr64
mov rdi, rax
jmp _Z5func0RKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIdiESt4lessIS5_ESaIS6_IKS5_S7_EEEdi_cold; func0(std::map<std::string,std::pair<double,int>> const&,double,int) [clone]
endbr64
mov rbx, rax
jmp loc_12B3 | long long func0(long long a1, long long a2, int a3, double a4)
{
long long v4; // r13
long long v5; // rbx
double v6; // xmm0_8
int v7; // r15d
void *v8; // rax
long long v9; // rbp
size_t v10; // rbx
long long v11; // r12
const void *v12; // r14
size_t v13; // r13
size_t v14; // rdx
int v15; // eax
size_t v16; // r12
size_t v17; // rcx
size_t v18; // rdx
int v19; // eax
long long v20; // rbp
size_t v21; // r14
long long v22; // r12
_BYTE *v23; // rax
long long v24; // rax
long long insert_hint_unique_pos; // rax
long long v26; // rdx
long long v27; // r14
long long v28; // r8
size_t v29; // r14
size_t v30; // r15
size_t v31; // rdx
int v32; // eax
unsigned int v33; // edi
long long v34; // r14
long long v35; // rdi
int v37; // r15d
void *v38; // rdi
void *v39; // rdi
long long v40; // rax
void *v41; // rdi
long long v44; // [rsp+18h] [rbp-70h]
long long v45; // [rsp+20h] [rbp-68h]
long long v46; // [rsp+20h] [rbp-68h]
void *src; // [rsp+28h] [rbp-60h]
void *srcb; // [rsp+28h] [rbp-60h]
void *srca; // [rsp+28h] [rbp-60h]
long long v50; // [rsp+30h] [rbp-58h]
void *s1; // [rsp+38h] [rbp-50h]
_QWORD v52[9]; // [rsp+40h] [rbp-48h] BYREF
v4 = a1;
v52[1] = __readfsqword(0x28u);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 24) = a1 + 8;
v5 = *(_QWORD *)(a2 + 24);
v44 = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 40) = 0LL;
if ( a2 + 8 == v5 )
return v4;
while ( 2 )
{
v6 = *(double *)(v5 + 64);
if ( v6 < a4 )
goto LABEL_3;
v7 = *(_DWORD *)(v5 + 72);
if ( v7 < a3 )
goto LABEL_3;
v8 = *(void **)(v5 + 32);
v9 = v44;
s1 = v8;
if ( !*(_QWORD *)(v4 + 16) )
goto LABEL_28;
src = (void *)v5;
v10 = *(_QWORD *)(v5 + 40);
v11 = *(_QWORD *)(v4 + 16);
v12 = v8;
v50 = v4;
do
{
while ( 1 )
{
v13 = *(_QWORD *)(v11 + 40);
v14 = v13;
if ( v10 <= v13 )
v14 = v10;
if ( v14 )
{
v15 = memcmp(*(const void **)(v11 + 32), v12, v14);
if ( v15 )
break;
}
if ( (long long)(v13 - v10) >= 0x80000000LL )
goto LABEL_17;
if ( (long long)(v13 - v10) > (long long)0xFFFFFFFF7FFFFFFFLL )
{
v15 = v13 - v10;
break;
}
LABEL_8:
v11 = *(_QWORD *)(v11 + 24);
if ( !v11 )
goto LABEL_18;
}
if ( v15 < 0 )
goto LABEL_8;
LABEL_17:
v9 = v11;
v11 = *(_QWORD *)(v11 + 16);
}
while ( v11 );
LABEL_18:
v16 = v10;
v5 = (long long)src;
v4 = v50;
if ( v44 == v9 )
goto LABEL_28;
v17 = *(_QWORD *)(v9 + 40);
v18 = v17;
if ( v16 <= v17 )
v18 = v16;
if ( v18 )
{
srcb = *(void **)(v9 + 40);
v19 = memcmp(s1, *(const void **)(v9 + 32), v18);
v17 = (size_t)srcb;
if ( v19 )
{
LABEL_26:
if ( v19 < 0 )
goto LABEL_28;
goto LABEL_27;
}
}
if ( (long long)(v16 - v17) > 0x7FFFFFFF )
{
LABEL_27:
*(_DWORD *)(v9 + 72) = v7;
*(double *)(v9 + 64) = v6;
goto LABEL_3;
}
if ( (long long)(v16 - v17) >= (long long)0xFFFFFFFF80000000LL )
{
v19 = v16 - v17;
goto LABEL_26;
}
LABEL_28:
v45 = v9;
v20 = operator new(0x50uLL);
v21 = *(_QWORD *)(v5 + 40);
v22 = v20 + 32;
*(_QWORD *)(v20 + 32) = v20 + 48;
v23 = *(_BYTE **)(v5 + 32);
v52[0] = v21;
srca = v23;
if ( v21 > 0xF )
{
v40 = std::string::_M_create(v22, v52, 0LL, v6);
*(_QWORD *)(v20 + 32) = v40;
v41 = (void *)v40;
*(_QWORD *)(v20 + 48) = v52[0];
goto LABEL_51;
}
if ( v21 == 1 )
{
*(_BYTE *)(v20 + 48) = *v23;
LABEL_31:
v24 = v20 + 48;
}
else
{
if ( !v21 )
goto LABEL_31;
v41 = (void *)(v20 + 48);
LABEL_51:
memcpy(v41, srca, v21);
v21 = v52[0];
v24 = *(_QWORD *)(v20 + 32);
}
*(_QWORD *)(v20 + 40) = v21;
*(_BYTE *)(v24 + v21) = 0;
*(_QWORD *)(v20 + 64) = 0LL;
*(_DWORD *)(v20 + 72) = 0;
insert_hint_unique_pos = std::_Rb_tree<std::string,std::pair<std::string const,std::pair<double,int>>,std::_Select1st<std::pair<std::string const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string const,std::pair<double,int>>>>::_M_get_insert_hint_unique_pos(
v4,
v45,
v22,
v6);
v27 = insert_hint_unique_pos;
v28 = v26;
if ( v26 )
{
if ( v44 == v26 || insert_hint_unique_pos )
goto LABEL_44;
v29 = *(_QWORD *)(v20 + 40);
v31 = *(_QWORD *)(v26 + 40);
v30 = v31;
if ( v29 <= v31 )
v31 = *(_QWORD *)(v20 + 40);
if ( v31
&& (v46 = v28,
v32 = memcmp(*(const void **)(v20 + 32), *(const void **)(v28 + 32), v31),
v28 = v46,
(v33 = v32) != 0) )
{
LABEL_42:
v35 = v33 >> 31;
}
else
{
v34 = v29 - v30;
v35 = 0LL;
if ( v34 <= 0x7FFFFFFF )
{
if ( v34 >= (long long)0xFFFFFFFF80000000LL )
{
v33 = v34;
goto LABEL_42;
}
LABEL_44:
v35 = 1LL;
}
}
std::_Rb_tree_insert_and_rebalance(v35, v20, v28, v44);
++*(_QWORD *)(v4 + 40);
}
else
{
v38 = *(void **)(v20 + 32);
if ( (void *)(v20 + 48) != v38 )
operator delete(v38, *(_QWORD *)(v20 + 48) + 1LL);
v39 = (void *)v20;
v20 = v27;
operator delete(v39, 0x50uLL);
}
v37 = *(_DWORD *)(v5 + 72);
*(_QWORD *)(v20 + 64) = *(_QWORD *)(v5 + 64);
*(_DWORD *)(v20 + 72) = v37;
LABEL_3:
v5 = std::_Rb_tree_increment(v5);
if ( a2 + 8 != v5 )
continue;
return v4;
}
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RSP + 0x14],EDX
MOVSD qword ptr [RSP],XMM0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x8]
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x18],RAX
MOV RBX,qword ptr [RSI + 0x18]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI + 0x20],RAX
LEA RAX,[RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x28],0x0
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,RBX
JNZ 0x00102426
JMP 0x00102658
LAB_00102410:
MOV RDI,RBX
CALL 0x00101220
MOV RBX,RAX
CMP qword ptr [RSP + 0x8],RAX
JZ 0x00102658
LAB_00102426:
MOVSD XMM0,qword ptr [RBX + 0x40]
COMISD XMM0,qword ptr [RSP]
JC 0x00102410
MOV R15D,dword ptr [RBX + 0x48]
MOV EAX,dword ptr [RSP + 0x14]
CMP R15D,EAX
JL 0x00102410
MOV RAX,qword ptr [RBX + 0x20]
MOV R14,qword ptr [R13 + 0x10]
MOV R12,qword ptr [RBX + 0x28]
MOV RBP,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x38],RAX
TEST R14,R14
JZ 0x00102560
MOV qword ptr [RSP + 0x28],RBX
MOV RBX,R12
MOV R12,R14
MOV R14,RAX
MOV qword ptr [RSP + 0x30],R13
MOVSD qword ptr [RSP + 0x20],XMM0
JMP 0x0010248a
LAB_00102480:
MOV R12,qword ptr [R12 + 0x18]
TEST R12,R12
JZ 0x001024e1
LAB_0010248a:
MOV R13,qword ptr [R12 + 0x28]
MOV RDI,qword ptr [R12 + 0x20]
CMP RBX,R13
MOV RDX,R13
CMOVBE RDX,RBX
TEST RDX,RDX
JZ 0x001024af
MOV RSI,R14
CALL 0x00101190
TEST EAX,EAX
JNZ 0x001024d0
LAB_001024af:
MOV RCX,R13
MOV EAX,0x80000000
SUB RCX,RBX
CMP RCX,RAX
JGE 0x001024d4
MOV RAX,-0x80000001
CMP RCX,RAX
JLE 0x00102480
MOV EAX,ECX
LAB_001024d0:
TEST EAX,EAX
JS 0x00102480
LAB_001024d4:
MOV RBP,R12
MOV R12,qword ptr [R12 + 0x10]
TEST R12,R12
JNZ 0x0010248a
LAB_001024e1:
MOV R12,RBX
MOVSD XMM0,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
MOV R13,qword ptr [RSP + 0x30]
CMP qword ptr [RSP + 0x18],RBP
JZ 0x00102560
MOV RCX,qword ptr [RBP + 0x28]
MOV RSI,qword ptr [RBP + 0x20]
CMP R12,RCX
MOV RDX,RCX
CMOVBE RDX,R12
TEST RDX,RDX
JZ 0x00102530
MOV RDI,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x28],RCX
CALL 0x00101190
MOVSD XMM0,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
TEST EAX,EAX
JNZ 0x0010254b
LAB_00102530:
MOV R8,R12
SUB R8,RCX
CMP R8,0x7fffffff
JG 0x0010254f
CMP R8,-0x80000000
JL 0x00102560
MOV EAX,R8D
LAB_0010254b:
TEST EAX,EAX
JS 0x00102560
LAB_0010254f:
MOV dword ptr [RBP + 0x48],R15D
MOVSD qword ptr [RBP + 0x40],XMM0
JMP 0x00102410
LAB_00102560:
MOV EDI,0x50
MOV qword ptr [RSP + 0x20],RBP
LAB_0010256a:
CALL 0x001011e0
MOV RBP,RAX
LEA RAX,[RAX + 0x20]
MOV R14,qword ptr [RBX + 0x28]
LEA R15,[RBP + 0x30]
MOV R12,RAX
MOV qword ptr [RBP + 0x20],R15
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RSP + 0x40],R14
MOV qword ptr [RSP + 0x28],RAX
CMP R14,0xf
JA 0x001026e0
CMP R14,0x1
JZ 0x00102720
TEST R14,R14
JNZ 0x0010272b
LAB_001025b0:
MOV RAX,R15
LAB_001025b3:
MOV qword ptr [RBP + 0x28],R14
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,R12
MOV RDI,R13
MOV byte ptr [RAX + R14*0x1],0x0
MOV qword ptr [RBP + 0x40],0x0
MOV dword ptr [RBP + 0x48],0x0
CALL 0x00102970
MOV R14,RAX
MOV R8,RDX
TEST RDX,RDX
JZ 0x001026b8
CMP qword ptr [RSP + 0x18],RDX
JZ 0x00102680
TEST RAX,RAX
JNZ 0x00102680
MOV R14,qword ptr [RBP + 0x28]
MOV R15,qword ptr [RDX + 0x28]
CMP R14,R15
MOV RDX,R15
CMOVBE RDX,R14
TEST RDX,RDX
JZ 0x00102632
MOV RSI,qword ptr [R8 + 0x20]
MOV RDI,qword ptr [RBP + 0x20]
MOV qword ptr [RSP + 0x20],R8
CALL 0x00101190
MOV R8,qword ptr [RSP + 0x20]
TEST EAX,EAX
MOV EDI,EAX
JNZ 0x0010264c
LAB_00102632:
SUB R14,R15
XOR EDI,EDI
CMP R14,0x7fffffff
JG 0x00102685
CMP R14,-0x80000000
JL 0x00102680
MOV EDI,R14D
LAB_0010264c:
SHR EDI,0x1f
JMP 0x00102685
LAB_00102658:
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00102730
ADD RSP,0x58
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00102680:
MOV EDI,0x1
LAB_00102685:
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,R8
MOV RSI,RBP
CALL 0x00101160
ADD qword ptr [R13 + 0x28],0x1
LAB_0010269a:
MOVSD XMM0,qword ptr [RBX + 0x40]
MOV R15D,dword ptr [RBX + 0x48]
MOVSD qword ptr [RBP + 0x40],XMM0
MOV dword ptr [RBP + 0x48],R15D
JMP 0x00102410
LAB_001026b8:
MOV RDI,qword ptr [RBP + 0x20]
CMP R15,RDI
JZ 0x001026ce
MOV RAX,qword ptr [RBP + 0x30]
LEA RSI,[RAX + 0x1]
CALL 0x001011f0
LAB_001026ce:
MOV RDI,RBP
MOV ESI,0x50
MOV RBP,R14
CALL 0x001011f0
JMP 0x0010269a
LAB_001026e0:
LEA RSI,[RSP + 0x40]
XOR EDX,EDX
MOV RDI,R12
LAB_001026ea:
CALL 0x00101270
MOV qword ptr [RBP + 0x20],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RBP + 0x30],RAX
LAB_001026ff:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,R14
CALL 0x001011d0
MOV R14,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RBP + 0x20]
JMP 0x001025b3
LAB_00102720:
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + 0x30],AL
JMP 0x001025b0
LAB_0010272b:
MOV RDI,R15
JMP 0x001026ff
LAB_00102730:
CALL 0x00101210 | /* func0(std::map<std::string, std::pair<double, int>, std::less<std::string >,
std::allocator<std::pair<std::string const, std::pair<double, int> > > > const&, double, int) */
map * func0(map *param_1,double param_2,int param_3)
{
_Rb_tree_node_base *p_Var1;
double dVar2;
int4 uVar3;
void *__s2;
ulong uVar4;
ulong uVar5;
int iVar6;
int iVar7;
_Rb_tree_node_base *p_Var8;
_Rb_tree_node_base *p_Var9;
_Rb_tree_node_base *p_Var10;
long lVar11;
int in_EDX;
_Rb_tree_node_base *p_Var12;
ulong uVar13;
_Rb_tree_node_base *p_Var14;
int4 in_register_00000034;
bool bVar15;
_Rb_tree_node_base *p_Var16;
long in_FS_OFFSET;
int auVar17 [16];
ulong local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
*(int4 *)(param_1 + 8) = 0;
*(_Rb_tree_node_base **)(param_1 + 0x18) = p_Var1;
p_Var8 = *(_Rb_tree_node_base **)(CONCAT44(in_register_00000034,param_3) + 0x18);
*(_Rb_tree_node_base **)(param_1 + 0x20) = p_Var1;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x28) = 0;
do {
if ((_Rb_tree_node_base *)(CONCAT44(in_register_00000034,param_3) + 8) == p_Var8) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
dVar2 = *(double *)(p_Var8 + 0x40);
if ((param_2 <= dVar2) && (iVar7 = *(int *)(p_Var8 + 0x48), in_EDX <= iVar7)) {
__s2 = *(void **)(p_Var8 + 0x20);
p_Var16 = *(_Rb_tree_node_base **)(param_1 + 0x10);
uVar4 = *(ulong *)(p_Var8 + 0x28);
p_Var14 = p_Var1;
if (p_Var16 != (_Rb_tree_node_base *)0x0) {
do {
while( true ) {
uVar5 = *(ulong *)(p_Var16 + 0x28);
uVar13 = uVar5;
if (uVar4 <= uVar5) {
uVar13 = uVar4;
}
if ((uVar13 != 0) &&
(iVar6 = memcmp(*(void **)(p_Var16 + 0x20),__s2,uVar13), iVar6 != 0)) break;
lVar11 = uVar5 - uVar4;
if (lVar11 < 0x80000000) {
if (-0x80000001 < lVar11) {
iVar6 = (int)lVar11;
break;
}
goto LAB_00102480;
}
LAB_001024d4:
p_Var12 = p_Var16 + 0x10;
p_Var14 = p_Var16;
p_Var16 = *(_Rb_tree_node_base **)p_Var12;
if (*(_Rb_tree_node_base **)p_Var12 == (_Rb_tree_node_base *)0x0) goto LAB_001024e1;
}
if (-1 < iVar6) goto LAB_001024d4;
LAB_00102480:
p_Var16 = *(_Rb_tree_node_base **)(p_Var16 + 0x18);
} while (p_Var16 != (_Rb_tree_node_base *)0x0);
LAB_001024e1:
if (p_Var1 != p_Var14) {
uVar5 = *(ulong *)(p_Var14 + 0x28);
uVar13 = uVar5;
if (uVar4 <= uVar5) {
uVar13 = uVar4;
}
if ((uVar13 == 0) || (iVar6 = memcmp(__s2,*(void **)(p_Var14 + 0x20),uVar13), iVar6 == 0))
{
lVar11 = uVar4 - uVar5;
if (lVar11 < 0x80000000) {
if (lVar11 < -0x80000000) goto LAB_00102560;
iVar6 = (int)lVar11;
goto LAB_0010254b;
}
}
else {
LAB_0010254b:
if (iVar6 < 0) goto LAB_00102560;
}
*(int *)(p_Var14 + 0x48) = iVar7;
*(double *)(p_Var14 + 0x40) = dVar2;
goto LAB_00102410;
}
}
LAB_00102560:
/* try { // try from 0010256a to 0010256e has its CatchHandler @ 00102741 */
p_Var9 = (_Rb_tree_node_base *)operator_new(0x50);
uVar4 = *(ulong *)(p_Var8 + 0x28);
p_Var16 = p_Var9 + 0x30;
*(_Rb_tree_node_base **)(p_Var9 + 0x20) = p_Var16;
p_Var12 = *(_Rb_tree_node_base **)(p_Var8 + 0x20);
local_48 = uVar4;
if (uVar4 < 0x10) {
p_Var10 = p_Var16;
if (uVar4 == 1) {
p_Var9[0x30] = *p_Var12;
}
else if (uVar4 != 0) goto LAB_001026ff;
}
else {
/* try { // try from 001026ea to 001026ee has its CatchHandler @ 00102735 */
p_Var10 = (_Rb_tree_node_base *)
std::string::_M_create((ulong *)(p_Var9 + 0x20),(ulong)&local_48);
*(_Rb_tree_node_base **)(p_Var9 + 0x20) = p_Var10;
*(ulong *)(p_Var9 + 0x30) = local_48;
LAB_001026ff:
memcpy(p_Var10,p_Var12,uVar4);
p_Var10 = *(_Rb_tree_node_base **)(p_Var9 + 0x20);
}
*(ulong *)(p_Var9 + 0x28) = local_48;
p_Var10[local_48] = (_Rb_tree_node_base)0x0;
*(int8 *)(p_Var9 + 0x40) = 0;
*(int4 *)(p_Var9 + 0x48) = 0;
auVar17 = std::
_Rb_tree<std::string,std::pair<std::string_const,std::pair<double,int>>,std::_Select1st<std::pair<std::string_const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
::_M_get_insert_hint_unique_pos
((_Rb_tree<std::string,std::pair<std::string_const,std::pair<double,int>>,std::_Select1st<std::pair<std::string_const,std::pair<double,int>>>,std::less<std::string>,std::allocator<std::pair<std::string_const,std::pair<double,int>>>>
*)param_1,(_Rb_tree_const_iterator)p_Var14,(string *)(p_Var9 + 0x20));
p_Var12 = auVar17._8_8_;
p_Var14 = auVar17._0_8_;
if (p_Var12 == (_Rb_tree_node_base *)0x0) {
if (p_Var16 != *(_Rb_tree_node_base **)(p_Var9 + 0x20)) {
operator_delete(*(_Rb_tree_node_base **)(p_Var9 + 0x20),*(long *)(p_Var9 + 0x30) + 1);
}
operator_delete(p_Var9,0x50);
}
else {
if ((p_Var1 == p_Var12) || (p_Var14 != (_Rb_tree_node_base *)0x0)) {
LAB_00102680:
bVar15 = true;
}
else {
uVar4 = *(ulong *)(p_Var9 + 0x28);
uVar5 = *(ulong *)(p_Var12 + 0x28);
uVar13 = uVar5;
if (uVar4 <= uVar5) {
uVar13 = uVar4;
}
if ((uVar13 == 0) ||
(iVar7 = memcmp(*(void **)(p_Var9 + 0x20),*(void **)(p_Var12 + 0x20),uVar13),
iVar7 == 0)) {
lVar11 = uVar4 - uVar5;
bVar15 = false;
if (0x7fffffff < lVar11) goto LAB_00102685;
if (lVar11 < -0x80000000) goto LAB_00102680;
iVar7 = (int)lVar11;
}
bVar15 = SUB41((uint)iVar7 >> 0x1f,0);
}
LAB_00102685:
std::_Rb_tree_insert_and_rebalance(bVar15,p_Var9,p_Var12,p_Var1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
p_Var14 = p_Var9;
}
uVar3 = *(int4 *)(p_Var8 + 0x48);
*(int8 *)(p_Var14 + 0x40) = *(int8 *)(p_Var8 + 0x40);
*(int4 *)(p_Var14 + 0x48) = uVar3;
}
LAB_00102410:
p_Var8 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var8);
} while( true );
} |
2,888 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
int result = 0;
for (size_t i = 0; i < nums1.size() && i < nums2.size(); i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 6, 7, 8}, {2, 2, 3, 1, 2, 6, 7, 9}) == 4);
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}, {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 11);
assert(func0({2, 4, -6, -9, 11, -12, 14, 17}, {2, 1, 2, -1, -5, 6, 4, -3}) == 1);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x1c(%rbp)
movq $0x0,-0x18(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1948 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x18(%rbp)
jae 1278 <_Z5func0RKSt6vectorIiSaIiEES3_+0x4f>
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1948 <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x18(%rbp)
jae 1278 <_Z5func0RKSt6vectorIiSaIiEES3_+0x4f>
mov $0x1,%eax
jmp 127d <_Z5func0RKSt6vectorIiSaIiEES3_+0x54>
mov $0x0,%eax
test %al,%al
je 12bf <_Z5func0RKSt6vectorIiSaIiEES3_+0x96>
mov -0x18(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1970 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x18(%rbp),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1970 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,%ebx
sete %al
test %al,%al
je 12b8 <_Z5func0RKSt6vectorIiSaIiEES3_+0x8f>
addl $0x1,-0x1c(%rbp)
addq $0x1,-0x18(%rbp)
jmp 124d <_Z5func0RKSt6vectorIiSaIiEES3_+0x24>
mov -0x1c(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
jmp short loc_12AB
loc_126F:
mov rdx, [rbp+var_18]
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp ebx, eax
setz al
test al, al
jz short loc_12A6
add [rbp+var_1C], 1
loc_12A6:
add [rbp+var_18], 1
loc_12AB:
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_18], rax
jnb short loc_12D6
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_18], rax
jnb short loc_12D6
mov eax, 1
jmp short loc_12DB
loc_12D6:
mov eax, 0
loc_12DB:
test al, al
jnz short loc_126F
mov eax, [rbp+var_1C]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
unsigned long long i; // rax
int v3; // ebx
unsigned int v6; // [rsp+14h] [rbp-1Ch]
unsigned long long v7; // [rsp+18h] [rbp-18h]
v6 = 0;
v7 = 0LL;
for ( i = std::vector<int>::size(a1); v7 < i && v7 < std::vector<int>::size(a2); i = std::vector<int>::size(a1) )
{
v3 = *(_DWORD *)std::vector<int>::operator[](a1, v7);
if ( v3 == *(_DWORD *)std::vector<int>::operator[](a2, v7) )
++v6;
++v7;
}
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x1c],0x0
MOV qword ptr [RBP + -0x18],0x0
JMP 0x001012ab
LAB_0010126f:
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019d8
MOV EBX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001019d8
MOV EAX,dword ptr [RAX]
CMP EBX,EAX
SETZ AL
TEST AL,AL
JZ 0x001012a6
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012a6:
ADD qword ptr [RBP + -0x18],0x1
LAB_001012ab:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001019b0
CMP qword ptr [RBP + -0x18],RAX
JNC 0x001012d6
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001019b0
CMP qword ptr [RBP + -0x18],RAX
JNC 0x001012d6
MOV EAX,0x1
JMP 0x001012db
LAB_001012d6:
MOV EAX,0x0
LAB_001012db:
TEST AL,AL
JNZ 0x0010126f
MOV EAX,dword ptr [RBP + -0x1c]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int func0(vector *param_1,vector *param_2)
{
int iVar1;
bool bVar2;
int *piVar3;
ulong uVar4;
int4 local_24;
int8 local_20;
local_24 = 0;
local_20 = 0;
do {
uVar4 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_1);
if (local_20 < uVar4) {
uVar4 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_2)
;
if (uVar4 <= local_20) goto LAB_001012d6;
bVar2 = true;
}
else {
LAB_001012d6:
bVar2 = false;
}
if (!bVar2) {
return local_24;
}
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,local_20);
iVar1 = *piVar3;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,local_20);
if (iVar1 == *piVar3) {
local_24 = local_24 + 1;
}
local_20 = local_20 + 1;
} while( true );
} |
2,889 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
int result = 0;
for (size_t i = 0; i < nums1.size() && i < nums2.size(); i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 6, 7, 8}, {2, 2, 3, 1, 2, 6, 7, 9}) == 4);
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}, {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 11);
assert(func0({2, 4, -6, -9, 11, -12, 14, 17}, {2, 1, 2, -1, -5, 6, 4, -3}) == 1);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rax
sub %rcx,%rax
sar $0x2,%rax
mov %rax,%r8
je 123a <_Z5func0RKSt6vectorIiSaIiEES3_+0x31>
mov (%rsi),%rdi
mov 0x8(%rsi),%rdx
sub %rdi,%rdx
sar $0x2,%rdx
mov $0x0,%eax
mov $0x0,%esi
jmp 124b <_Z5func0RKSt6vectorIiSaIiEES3_+0x42>
mov $0x0,%esi
mov %esi,%eax
retq
add $0x1,%rax
cmp %r8,%rax
je 123f <_Z5func0RKSt6vectorIiSaIiEES3_+0x36>
cmp %rax,%rdx
je 123f <_Z5func0RKSt6vectorIiSaIiEES3_+0x36>
mov (%rdi,%rax,4),%r9d
cmp %r9d,(%rcx,%rax,4)
jne 1242 <_Z5func0RKSt6vectorIiSaIiEES3_+0x39>
add $0x1,%esi
jmp 1242 <_Z5func0RKSt6vectorIiSaIiEES3_+0x39>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rdi, rax
sub rdi, rcx
sar rdi, 2
cmp rax, rcx
jz short loc_125A
mov r8, [rsi]
mov rdx, [rsi+8]
sub rdx, r8
sar rdx, 2
mov eax, 0
mov esi, 0
jmp short loc_1249
loc_123D:
add esi, 1
loc_1240:
add rax, 1
cmp rax, rdi
jnb short loc_125F
loc_1249:
cmp rdx, rax
jz short loc_125F
mov r9d, [r8+rax*4]
cmp [rcx+rax*4], r9d
jnz short loc_1240
jmp short loc_123D
loc_125A:
mov esi, 0
loc_125F:
mov eax, esi
retn | long long func0(long long *a1, long long *a2)
{
long long v2; // rax
long long v3; // rcx
unsigned long long v4; // rdi
long long v5; // r8
long long v6; // rdx
unsigned long long v7; // rax
unsigned int v8; // esi
v2 = a1[1];
v3 = *a1;
v4 = (v2 - *a1) >> 2;
if ( v2 == v3 )
{
return 0;
}
else
{
v5 = *a2;
v6 = (a2[1] - *a2) >> 2;
v7 = 0LL;
v8 = 0;
do
{
if ( v6 == v7 )
break;
if ( *(_DWORD *)(v3 + 4 * v7) == *(_DWORD *)(v5 + 4 * v7) )
++v8;
++v7;
}
while ( v7 < v4 );
}
return v8;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RDI,RAX
SUB RDI,RCX
SAR RDI,0x2
CMP RAX,RCX
JZ 0x0010125a
MOV R8,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
SUB RDX,R8
SAR RDX,0x2
MOV EAX,0x0
MOV ESI,0x0
JMP 0x00101249
LAB_0010123d:
ADD ESI,0x1
LAB_00101240:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x0010125f
LAB_00101249:
CMP RDX,RAX
JZ 0x0010125f
MOV R9D,dword ptr [R8 + RAX*0x4]
CMP dword ptr [RCX + RAX*0x4],R9D
JNZ 0x00101240
JMP 0x0010123d
LAB_0010125a:
MOV ESI,0x0
LAB_0010125f:
MOV EAX,ESI
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int func0(vector *param_1,vector *param_2)
{
long lVar1;
ulong uVar2;
int iVar3;
lVar1 = *(long *)param_1;
if (*(long *)(param_1 + 8) == lVar1) {
iVar3 = 0;
}
else {
uVar2 = 0;
iVar3 = 0;
do {
if (*(long *)(param_2 + 8) - *(long *)param_2 >> 2 == uVar2) {
return iVar3;
}
if (*(int *)(lVar1 + uVar2 * 4) == *(int *)(*(long *)param_2 + uVar2 * 4)) {
iVar3 = iVar3 + 1;
}
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)(*(long *)(param_1 + 8) - lVar1 >> 2));
}
return iVar3;
} |
2,890 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
int result = 0;
for (size_t i = 0; i < nums1.size() && i < nums2.size(); i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 6, 7, 8}, {2, 2, 3, 1, 2, 6, 7, 9}) == 4);
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}, {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 11);
assert(func0({2, 4, -6, -9, 11, -12, 14, 17}, {2, 1, 2, -1, -5, 6, 4, -3}) == 1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
sar $0x2,%rdx
je 165f <_Z5func0RKSt6vectorIiSaIiEES3_+0x4f>
mov (%rsi),%rdi
mov 0x8(%rsi),%rcx
xor %eax,%eax
xor %r9d,%r9d
sub %rdi,%rcx
sar $0x2,%rcx
jmp 1656 <_Z5func0RKSt6vectorIiSaIiEES3_+0x46>
nopl 0x0(%rax)
mov (%rdi,%rax,4),%esi
cmp %esi,(%r8,%rax,4)
jne 164d <_Z5func0RKSt6vectorIiSaIiEES3_+0x3d>
add $0x1,%r9d
add $0x1,%rax
cmp %rdx,%rax
je 165b <_Z5func0RKSt6vectorIiSaIiEES3_+0x4b>
cmp %rax,%rcx
jne 1640 <_Z5func0RKSt6vectorIiSaIiEES3_+0x30>
mov %r9d,%eax
retq
xor %r9d,%r9d
jmp 165b <_Z5func0RKSt6vectorIiSaIiEES3_+0x4b>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rdi, rax
sub rdi, rcx
sar rdi, 2
cmp rax, rcx
jz short loc_154E
mov r8, [rsi]
mov rdx, [rsi+8]
xor eax, eax
xor esi, esi
sub rdx, r8
sar rdx, 2
jmp short loc_1546
loc_1530:
mov r9d, [r8+rax*4]
cmp [rcx+rax*4], r9d
jnz short loc_153D
add esi, 1
loc_153D:
add rax, 1
cmp rax, rdi
jnb short loc_154B
loc_1546:
cmp rdx, rax
jnz short loc_1530
loc_154B:
mov eax, esi
retn
loc_154E:
xor esi, esi
jmp short loc_154B | long long func0(long long *a1, long long *a2)
{
long long v2; // rax
long long v3; // rcx
unsigned long long v4; // rdi
long long v5; // r8
long long v6; // rdx
unsigned long long v7; // rax
unsigned int v8; // esi
long long v9; // rdx
v2 = a1[1];
v3 = *a1;
v4 = (v2 - *a1) >> 2;
if ( v2 == v3 )
{
return 0;
}
else
{
v5 = *a2;
v6 = a2[1];
v7 = 0LL;
v8 = 0;
v9 = (v6 - v5) >> 2;
do
{
if ( v9 == v7 )
break;
if ( *(_DWORD *)(v3 + 4 * v7) == *(_DWORD *)(v5 + 4 * v7) )
++v8;
++v7;
}
while ( v7 < v4 );
}
return v8;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RDI,RAX
SUB RDI,RCX
SAR RDI,0x2
CMP RAX,RCX
JZ 0x0010154e
MOV R8,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
XOR EAX,EAX
XOR ESI,ESI
SUB RDX,R8
SAR RDX,0x2
JMP 0x00101546
LAB_00101530:
MOV R9D,dword ptr [R8 + RAX*0x4]
CMP dword ptr [RCX + RAX*0x4],R9D
JNZ 0x0010153d
ADD ESI,0x1
LAB_0010153d:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x0010154b
LAB_00101546:
CMP RDX,RAX
JNZ 0x00101530
LAB_0010154b:
MOV EAX,ESI
RET
LAB_0010154e:
XOR ESI,ESI
JMP 0x0010154b | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int func0(vector *param_1,vector *param_2)
{
long lVar1;
ulong uVar2;
int iVar3;
lVar1 = *(long *)param_1;
if (*(long *)(param_1 + 8) == lVar1) {
iVar3 = 0;
}
else {
uVar2 = 0;
iVar3 = 0;
do {
if (*(long *)(param_2 + 8) - *(long *)param_2 >> 2 == uVar2) {
return iVar3;
}
if (*(int *)(lVar1 + uVar2 * 4) == *(int *)(*(long *)param_2 + uVar2 * 4)) {
iVar3 = iVar3 + 1;
}
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)(*(long *)(param_1 + 8) - lVar1 >> 2));
}
return iVar3;
} |
2,891 | func0 |
#include <cassert>
#include <vector>
| int func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
int result = 0;
for (size_t i = 0; i < nums1.size() && i < nums2.size(); i++) {
if (nums1[i] == nums2[i]) {
result++;
}
}
return result;
}
| int main() {
assert(func0({1, 2, 3, 4, 5, 6, 7, 8}, {2, 2, 3, 1, 2, 6, 7, 9}) == 4);
assert(func0({0, 1, 2, -1, -5, 6, 0, -3, -2, 3, 4, 6, 8}, {2, 1, 2, -1, -5, 6, 4, -3, -2, 3, 4, 6, 8}) == 11);
assert(func0({2, 4, -6, -9, 11, -12, 14, 17}, {2, 1, 2, -1, -5, 6, 4, -3}) == 1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
sar $0x2,%rdx
je 155f <_Z5func0RKSt6vectorIiSaIiEES3_+0x4f>
mov (%rsi),%rdi
mov 0x8(%rsi),%rcx
xor %eax,%eax
xor %r9d,%r9d
sub %rdi,%rcx
sar $0x2,%rcx
jmp 1556 <_Z5func0RKSt6vectorIiSaIiEES3_+0x46>
nopl 0x0(%rax)
mov (%rdi,%rax,4),%esi
cmp %esi,(%r8,%rax,4)
jne 154d <_Z5func0RKSt6vectorIiSaIiEES3_+0x3d>
add $0x1,%r9d
add $0x1,%rax
cmp %rdx,%rax
je 155b <_Z5func0RKSt6vectorIiSaIiEES3_+0x4b>
cmp %rax,%rcx
jne 1540 <_Z5func0RKSt6vectorIiSaIiEES3_+0x30>
mov %r9d,%eax
retq
xor %r9d,%r9d
jmp 155b <_Z5func0RKSt6vectorIiSaIiEES3_+0x4b>
nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, [rdi+8]
mov rcx, [rdi]
mov rdi, rax
sub rdi, rcx
sar rdi, 2
cmp rax, rcx
jz short loc_154E
mov r8, [rsi]
mov rdx, [rsi+8]
xor eax, eax
xor esi, esi
sub rdx, r8
sar rdx, 2
jmp short loc_1546
loc_1530:
mov r9d, [r8+rax*4]
cmp [rcx+rax*4], r9d
jnz short loc_153D
add esi, 1
loc_153D:
add rax, 1
cmp rax, rdi
jnb short loc_154B
loc_1546:
cmp rdx, rax
jnz short loc_1530
loc_154B:
mov eax, esi
retn
loc_154E:
xor esi, esi
jmp short loc_154B | long long func0(long long *a1, long long *a2)
{
long long v2; // rax
long long v3; // rcx
unsigned long long v4; // rdi
long long v5; // r8
long long v6; // rdx
unsigned long long v7; // rax
unsigned int v8; // esi
long long v9; // rdx
v2 = a1[1];
v3 = *a1;
v4 = (v2 - *a1) >> 2;
if ( v2 == v3 )
{
return 0;
}
else
{
v5 = *a2;
v6 = a2[1];
v7 = 0LL;
v8 = 0;
v9 = (v6 - v5) >> 2;
do
{
if ( v9 == v7 )
break;
if ( *(_DWORD *)(v3 + 4 * v7) == *(_DWORD *)(v5 + 4 * v7) )
++v8;
++v7;
}
while ( v7 < v4 );
}
return v8;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
MOV RDI,RAX
SUB RDI,RCX
SAR RDI,0x2
CMP RAX,RCX
JZ 0x0010154e
MOV R8,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
XOR EAX,EAX
XOR ESI,ESI
SUB RDX,R8
SAR RDX,0x2
JMP 0x00101546
LAB_00101530:
MOV R9D,dword ptr [R8 + RAX*0x4]
CMP dword ptr [RCX + RAX*0x4],R9D
JNZ 0x0010153d
ADD ESI,0x1
LAB_0010153d:
ADD RAX,0x1
CMP RAX,RDI
JNC 0x0010154b
LAB_00101546:
CMP RDX,RAX
JNZ 0x00101530
LAB_0010154b:
MOV EAX,ESI
RET
LAB_0010154e:
XOR ESI,ESI
JMP 0x0010154b | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int func0(vector *param_1,vector *param_2)
{
long lVar1;
ulong uVar2;
int iVar3;
lVar1 = *(long *)param_1;
if (*(long *)(param_1 + 8) == lVar1) {
iVar3 = 0;
}
else {
uVar2 = 0;
iVar3 = 0;
do {
if (*(long *)(param_2 + 8) - *(long *)param_2 >> 2 == uVar2) {
return iVar3;
}
if (*(int *)(lVar1 + uVar2 * 4) == *(int *)(*(long *)param_2 + uVar2 * 4)) {
iVar3 = iVar3 + 1;
}
uVar2 = uVar2 + 1;
} while (uVar2 < (ulong)(*(long *)(param_1 + 8) - lVar1 >> 2));
}
return iVar3;
} |
2,892 | func0 |
#include <cassert>
#include <string>
| int func0(int base, int power) {
std::string result = "1";
for(int i = 0; i < power; ++i) {
int carry = 0;
for(int j = result.size() - 1; j >= 0; --j) {
int digit = (result[j] - '0') * base + carry;
result[j] = (digit % 10) + '0';
carry = digit / 10;
}
while(carry > 0) {
result.insert(result.begin(), (carry % 10) + '0');
carry /= 10;
}
}
int sum = 0;
for(char c : result) {
sum += c - '0';
}
return sum;
}
| int main(){
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %edi,-0x74(%rbp)
mov %esi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2310 <_ZNSaIcEC1Ev@plt>
lea -0x50(%rbp),%rdx
lea -0x40(%rbp),%rax
lea 0xb82(%rip),%rsi
mov %rax,%rdi
callq 2894 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_>
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2290 <_ZNSaIcED1Ev@plt>
movl $0x0,-0x6c(%rbp)
mov -0x6c(%rbp),%eax
cmp -0x78(%rbp),%eax
jge 260b <_Z5func0ii+0x1c2>
movl $0x0,-0x68(%rbp)
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2230 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv@plt>
sub $0x1,%eax
mov %eax,-0x64(%rbp)
cmpl $0x0,-0x64(%rbp)
js 256b <_Z5func0ii+0x122>
mov -0x64(%rbp),%eax
movslq %eax,%rdx
lea -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2350 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x30,%eax
imul -0x74(%rbp),%eax
mov %eax,%edx
mov -0x68(%rbp),%eax
add %edx,%eax
mov %eax,-0x5c(%rbp)
mov -0x5c(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
mov %edx,%eax
add $0x30,%eax
mov %eax,%ebx
mov -0x64(%rbp),%eax
movslq %eax,%rdx
lea -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2350 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
mov %bl,(%rax)
mov -0x5c(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x68(%rbp)
subl $0x1,-0x64(%rbp)
jmpq 24c6 <_Z5func0ii+0x7d>
cmpl $0x0,-0x68(%rbp)
jle 2602 <_Z5func0ii+0x1b9>
mov -0x68(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar $0x2,%edx
mov %ecx,%eax
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
shl $0x2,%eax
add %edx,%eax
add %eax,%eax
sub %eax,%ecx
mov %ecx,%edx
mov %edx,%eax
add $0x30,%eax
movsbl %al,%ebx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2270 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x58(%rbp)
lea -0x58(%rbp),%rdx
lea -0x50(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2930 <_ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC1IPcEERKNS0_IT_NS_11__enable_ifIXsrSt10__are_sameISC_SB_E7__valueES8_E6__typeEEE>
mov -0x50(%rbp),%rcx
lea -0x40(%rbp),%rax
mov %ebx,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 2330 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6insertEN9__gnu_cxx17__normal_iteratorIPKcS4_EEc@plt>
mov -0x68(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x68(%rbp)
jmpq 256b <_Z5func0ii+0x122>
addl $0x1,-0x6c(%rbp)
jmpq 24a1 <_Z5func0ii+0x58>
movl $0x0,-0x60(%rbp)
lea -0x40(%rbp),%rax
mov %rax,-0x48(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2270 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x58(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 21f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,-0x50(%rbp)
lea -0x50(%rbp),%rdx
lea -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 295d <_ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 267b <_Z5func0ii+0x232>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 29c2 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv>
movzbl (%rax),%eax
mov %al,-0x6d(%rbp)
movsbl -0x6d(%rbp),%eax
sub $0x30,%eax
add %eax,-0x60(%rbp)
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 299e <_ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv>
jmp 263a <_Z5func0ii+0x1f1>
mov -0x60(%rbp),%ebx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2200 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %ebx,%eax
mov -0x18(%rbp),%rsi
xor %fs:0x28,%rsi
je 26de <_Z5func0ii+0x295>
jmp 26d9 <_Z5func0ii+0x290>
endbr64
mov %rax,%rbx
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 2290 <_ZNSaIcED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 2300 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2200 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %rbx,%rax
mov %rax,%rdi
callq 2300 <_Unwind_Resume@plt>
callq 22c0 <__stack_chk_fail@plt>
add $0x78,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_84], edi
mov [rbp+var_88], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_58]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_58]
lea rax, [rbp+var_40]
lea rcx, unk_2008
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbp+var_58]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
mov [rbp+var_74], 0
jmp loc_156D
loc_1411:
mov [rbp+var_70], 0
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4sizeEv; std::string::size(void)
sub eax, 1
mov [rbp+var_6C], eax
jmp loc_14C8
loc_142F:
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
movsx eax, al
sub eax, 30h ; '0'
imul eax, [rbp+var_84]
mov edx, eax
mov eax, [rbp+var_70]
add eax, edx
mov [rbp+var_64], eax
mov edx, [rbp+var_64]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
mov ecx, edx
sub ecx, eax
mov eax, ecx
add eax, 30h ; '0'
mov ebx, eax
mov eax, [rbp+var_6C]
movsxd rdx, eax
lea rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
mov [rax], bl
mov eax, [rbp+var_64]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_70], eax
sub [rbp+var_6C], 1
loc_14C8:
cmp [rbp+var_6C], 0
jns loc_142F
jmp loc_155F
loc_14D7:
mov edx, [rbp+var_70]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
mov ecx, edx
sub ecx, eax
mov eax, ecx
add eax, 30h ; '0'
movsx ebx, al
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_60], rax
lea rdx, [rbp+var_60]
lea rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2IPcvEERKNS0_IT_S8_EE; __gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *,void>(__gnu_cxx::__normal_iterator<char *,std::string> const&)
mov rcx, [rbp+var_58]
lea rax, [rbp+var_40]
mov edx, ebx
mov rsi, rcx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6insertEN9__gnu_cxx17__normal_iteratorIPKcS4_EEc; std::string::insert(__gnu_cxx::__normal_iterator<char const*,std::string>,char)
mov eax, [rbp+var_70]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_70], eax
loc_155F:
cmp [rbp+var_70], 0
jg loc_14D7
add [rbp+var_74], 1
loc_156D:
mov eax, [rbp+var_74]
cmp eax, [rbp+var_88]
jl loc_1411
mov [rbp+var_68], 0
lea rax, [rbp+var_40]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_60], rax
mov rax, [rbp+var_50]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_58], rax
jmp short loc_15D5
loc_15AD:
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
movzx eax, byte ptr [rax]
mov [rbp+var_75], al
movsx eax, [rbp+var_75]
sub eax, 30h ; '0'
add [rbp+var_68], eax
lea rax, [rbp+var_60]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator++(void)
loc_15D5:
lea rdx, [rbp+var_58]
lea rax, [rbp+var_60]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<char *,std::string>(__gnu_cxx::__normal_iterator<char *,std::string> const&,__gnu_cxx::__normal_iterator<char *,std::string> const&)
test al, al
jnz short loc_15AD
mov ebx, [rbp+var_68]
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov eax, ebx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1678
jmp short loc_1673
endbr64
mov rbx, rax
lea rax, [rbp+var_58]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1639
call ___stack_chk_fail
loc_1639:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_166B
call ___stack_chk_fail
loc_166B:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1673:
call ___stack_chk_fail
loc_1678:
mov rbx, [rbp+var_8]
leave
retn | long long func0(int a1, int a2)
{
int i; // [rsp+1Ch] [rbp-74h]
int v4; // [rsp+20h] [rbp-70h]
int j; // [rsp+24h] [rbp-6Ch]
unsigned int v6; // [rsp+28h] [rbp-68h]
int v7; // [rsp+2Ch] [rbp-64h]
long long v8; // [rsp+30h] [rbp-60h] BYREF
long long v9; // [rsp+38h] [rbp-58h] BYREF
_BYTE *v10; // [rsp+40h] [rbp-50h]
long long *v11; // [rsp+48h] [rbp-48h]
_BYTE v12[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long long v13; // [rsp+78h] [rbp-18h]
v13 = __readfsqword(0x28u);
v11 = &v9;
std::string::basic_string<std::allocator<char>>(v12, &unk_2008, &v9);
std::__new_allocator<char>::~__new_allocator(&v9);
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = std::string::size(v12) - 1; j >= 0; --j )
{
v7 = a1 * (*(char *)std::string::operator[](v12, j) - 48) + v4;
*(_BYTE *)std::string::operator[](v12, j) = v7 % 10 + 48;
v4 = v7 / 10;
}
while ( v4 > 0 )
{
v8 = std::string::begin(v12);
__gnu_cxx::__normal_iterator<char const*,std::string>::__normal_iterator<char *,void>(&v9, &v8);
std::string::insert(v12, v9, (unsigned int)(char)(v4 % 10 + 48));
v4 /= 10;
}
}
v6 = 0;
v10 = v12;
v8 = std::string::begin(v12);
v9 = std::string::end(v10);
while ( (unsigned __int8)__gnu_cxx::operator!=<char *,std::string>(&v8, &v9) )
{
v6 += *(char *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v8) - 48;
__gnu_cxx::__normal_iterator<char *,std::string>::operator++(&v8);
}
std::string::~string(v12);
return v6;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV dword ptr [RBP + -0x84],EDI
MOV dword ptr [RBP + -0x88],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x58]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x58]
LEA RAX,[RBP + -0x40]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
LAB_001013f3:
CALL 0x0010181c
LEA RAX,[RBP + -0x58]
MOV RDI,RAX
CALL 0x0010198e
NOP
MOV dword ptr [RBP + -0x74],0x0
JMP 0x0010156d
LAB_00101411:
MOV dword ptr [RBP + -0x70],0x0
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001011d0
SUB EAX,0x1
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x001014c8
LAB_0010142f:
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010143f:
CALL 0x001012b0
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x30
IMUL EAX,dword ptr [RBP + -0x84]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x70]
ADD EAX,EDX
MOV dword ptr [RBP + -0x64],EAX
MOV EDX,dword ptr [RBP + -0x64]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
MOV ECX,EDX
SUB ECX,EAX
MOV EAX,ECX
ADD EAX,0x30
MOV EBX,EAX
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RDX,EAX
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001012b0
MOV byte ptr [RAX],BL
MOV EAX,dword ptr [RBP + -0x64]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x70],EAX
SUB dword ptr [RBP + -0x6c],0x1
LAB_001014c8:
CMP dword ptr [RBP + -0x6c],0x0
JNS 0x0010142f
JMP 0x0010155f
LAB_001014d7:
MOV EDX,dword ptr [RBP + -0x70]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
MOV ECX,EDX
SUB ECX,EAX
MOV EAX,ECX
ADD EAX,0x30
MOVSX EBX,AL
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101210
MOV qword ptr [RBP + -0x60],RAX
LEA RDX,[RBP + -0x60]
LEA RAX,[RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018c4
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x40]
MOV EDX,EBX
MOV RSI,RCX
MOV RDI,RAX
CALL 0x00101290
MOV EAX,dword ptr [RBP + -0x70]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x70],EAX
LAB_0010155f:
CMP dword ptr [RBP + -0x70],0x0
JG 0x001014d7
ADD dword ptr [RBP + -0x74],0x1
LAB_0010156d:
MOV EAX,dword ptr [RBP + -0x74]
CMP EAX,dword ptr [RBP + -0x88]
JL 0x00101411
MOV dword ptr [RBP + -0x68],0x0
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101210
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV RDI,RAX
CALL 0x00101190
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001015d5
LAB_001015ad:
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101954
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
MOVSX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x30
ADD dword ptr [RBP + -0x68],EAX
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x00101930
LAB_001015d5:
LEA RDX,[RBP + -0x58]
LEA RAX,[RBP + -0x60]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001018f1
TEST AL,AL
JNZ 0x001015ad
MOV EBX,dword ptr [RBP + -0x68]
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001011a0
MOV EAX,EBX
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x00101678
JMP 0x00101673
LAB_00101673:
CALL 0x00101250
LAB_00101678:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
bool bVar1;
char *pcVar2;
long in_FS_OFFSET;
int local_7c;
int local_78;
int local_74;
int local_70;
int8 local_68;
int8 local_60;
string *local_58;
int8 *local_50;
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = &local_60;
/* try { // try from 001013f3 to 001013f7 has its CatchHandler @ 0010160e */
std::string::string<std::allocator<char>>(local_48,"1",(allocator *)&local_60);
std::__new_allocator<char>::~__new_allocator((__new_allocator<char> *)&local_60);
for (local_7c = 0; local_7c < param_2; local_7c = local_7c + 1) {
local_78 = 0;
local_74 = std::string::size();
while (local_74 = local_74 + -1, -1 < local_74) {
/* try { // try from 0010143f to 00101540 has its CatchHandler @ 00101641 */
pcVar2 = (char *)std::string::operator[]((ulong)local_48);
local_78 = local_78 + (*pcVar2 + -0x30) * param_1;
pcVar2 = (char *)std::string::operator[]((ulong)local_48);
*pcVar2 = (char)local_78 + (char)(local_78 / 10) * -10 + '0';
local_78 = local_78 / 10;
}
for (; 0 < local_78; local_78 = local_78 / 10) {
local_68 = std::string::begin();
__normal_iterator<char_const*,std::string>::__normal_iterator<char*,void>
((__normal_iterator<char_const*,std::string> *)&local_60,
(__normal_iterator *)&local_68);
std::string::insert(local_48,local_60,
(int)(char)((char)local_78 + (char)(local_78 / 10) * -10 + '0'));
}
}
local_70 = 0;
local_58 = local_48;
local_68 = std::string::begin();
local_60 = std::string::end();
while (bVar1 = operator!=((__normal_iterator *)&local_68,(__normal_iterator *)&local_60), bVar1) {
pcVar2 = (char *)__normal_iterator<char*,std::string>::operator*
((__normal_iterator<char*,std::string> *)&local_68);
local_70 = local_70 + *pcVar2 + -0x30;
__normal_iterator<char*,std::string>::operator++
((__normal_iterator<char*,std::string> *)&local_68);
}
std::string::~string(local_48);
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_70;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,893 | func0 |
#include <cassert>
#include <string>
| int func0(int base, int power) {
std::string result = "1";
for(int i = 0; i < power; ++i) {
int carry = 0;
for(int j = result.size() - 1; j >= 0; --j) {
int digit = (result[j] - '0') * base + carry;
result[j] = (digit % 10) + '0';
carry = digit / 10;
}
while(carry > 0) {
result.insert(result.begin(), (carry % 10) + '0');
carry /= 10;
}
}
int sum = 0;
for(char c : result) {
sum += c - '0';
}
return sum;
}
| int main(){
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
}
| O1 | cpp | func0(int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
movb $0x31,0x10(%rsp)
movq $0x1,0x8(%rsp)
movb $0x0,0x11(%rsp)
test %esi,%esi
jle 1347 <_Z5func0ii+0x17e>
mov %edi,%ebp
mov %esi,%r13d
mov $0x0,%r12d
mov $0x0,%r14d
jmp 1288 <_Z5func0ii+0xbf>
movslq %ebx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %ebx,%edx
sar $0x1f,%edx
sub %edx,%eax
cmp $0x9,%ebx
jle 127f <_Z5func0ii+0xb6>
mov %eax,%ebx
movslq %ebx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %ebx,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
mov %ebx,%r8d
sub %eax,%r8d
add $0x30,%r8d
movsbl %r8b,%r8d
mov $0x1,%ecx
mov $0x0,%edx
mov $0x0,%esi
mov %r15,%rdi
callq 10d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc@plt>
jmp 1222 <_Z5func0ii+0x59>
add $0x1,%r12d
cmp %r12d,%r13d
je 12ee <_Z5func0ii+0x125>
mov 0x8(%rsp),%esi
sub $0x1,%esi
js 127f <_Z5func0ii+0xb6>
movslq %esi,%rax
mov %rax,%rdx
mov %r14d,%ebx
sub %eax,%esi
mov %rdx,%rcx
add (%rsp),%rcx
movsbl (%rcx),%eax
sub $0x30,%eax
imul %ebp,%eax
add %ebx,%eax
movslq %eax,%rbx
imul $0x66666667,%rbx,%rbx
sar $0x22,%rbx
mov %eax,%edi
sar $0x1f,%edi
sub %edi,%ebx
lea (%rbx,%rbx,4),%edi
add %edi,%edi
mov %eax,%r9d
sub %edi,%r9d
mov %r9d,%edi
add $0x30,%edi
mov %dil,(%rcx)
sub $0x1,%rdx
mov %esi,%ecx
add %edx,%ecx
jns 129c <_Z5func0ii+0xd3>
cmp $0x9,%eax
jle 127f <_Z5func0ii+0xb6>
mov %rsp,%r15
jmpq 123e <_Z5func0ii+0x75>
mov (%rsp),%rdi
mov %rdi,%rcx
add 0x8(%rsp),%rcx
cmp %rdi,%rcx
je 1353 <_Z5func0ii+0x18a>
mov %rdi,%rax
mov $0x0,%ebx
movsbl (%rax),%edx
lea -0x30(%rbx,%rdx,1),%ebx
add $0x1,%rax
cmp %rcx,%rax
jne 1307 <_Z5func0ii+0x13e>
lea 0x10(%rsp),%rax
cmp %rax,%rdi
je 1326 <_Z5func0ii+0x15d>
callq 10a0 <_ZdlPv@plt>
mov 0x28(%rsp),%rax
xor %fs:0x28,%rax
jne 137c <_Z5func0ii+0x1b3>
mov %ebx,%eax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x11(%rsp),%rcx
lea 0x10(%rsp),%rdi
jmp 12ff <_Z5func0ii+0x136>
mov $0x0,%ebx
jmp 1317 <_Z5func0ii+0x14e>
endbr64
mov %rax,%rbx
mov (%rsp),%rdi
lea 0x10(%rsp),%rax
cmp %rax,%rdi
je 1374 <_Z5func0ii+0x1ab>
callq 10a0 <_ZdlPv@plt>
mov %rbx,%rdi
callq 10c0 <_Unwind_Resume@plt>
callq 10b0 <__stack_chk_fail@plt>
| _Z5func0ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
lea rax, [rsp+68h+var_58]
mov [rsp+68h+var_68], rax
mov byte ptr [rsp+68h+var_58], 31h ; '1'
mov [rsp+68h+var_60], 1
mov byte ptr [rsp+68h+var_58+1], 0
test esi, esi
jle loc_13B6
mov ebp, edi
mov r13d, esi
mov r12d, 0
mov r14d, 0
jmp short loc_12A8
loc_1242:
movsxd rax, ebx
imul rax, 66666667h
sar rax, 22h
mov edx, ebx
sar edx, 1Fh
sub eax, edx
cmp ebx, 9
jle short loc_129F
mov ebx, eax
loc_125E:
movsxd rax, ebx
imul rax, 66666667h
sar rax, 22h
mov edx, ebx
sar edx, 1Fh
sub eax, edx
lea eax, [rax+rax*4]
add eax, eax
mov r8d, ebx
sub r8d, eax
add r8d, 30h ; '0'
movsx r8d, r8b
mov ecx, 1
mov edx, 0
mov esi, 0
mov rdi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc; std::string::_M_replace_aux(ulong,ulong,ulong,char)
jmp short loc_1242
loc_129F:
add r12d, 1
cmp r13d, r12d
jz short loc_130C
loc_12A8:
mov esi, dword ptr [rsp+68h+var_60]
sub esi, 1
js short loc_129F
movsxd rax, esi
mov rdx, rax
mov ebx, r14d
sub esi, eax
loc_12BC:
mov rcx, rdx
add rcx, [rsp+68h+var_68]
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
imul eax, ebp
add eax, ebx
movsxd rbx, eax
imul rbx, 66666667h
sar rbx, 22h
mov edi, eax
sar edi, 1Fh
sub ebx, edi
lea r8d, [rbx+rbx*4]
add r8d, r8d
mov edi, eax
sub edi, r8d
add edi, 30h ; '0'
mov [rcx], dil
sub rdx, 1
mov ecx, esi
add ecx, edx
jns short loc_12BC
cmp eax, 9
jle short loc_129F
mov r15, rsp
jmp loc_125E
loc_130C:
mov rdi, [rsp+68h+var_68]; void *
mov rcx, rdi
add rcx, [rsp+68h+var_60]
cmp rcx, rdi
jz loc_13A5
loc_1321:
mov rax, rdi
mov ebx, 0
loc_1329:
movsx edx, byte ptr [rax]
lea ebx, [rbx+rdx-30h]
add rax, 1
cmp rcx, rax
jnz short loc_1329
lea rax, [rsp+68h+var_58]
cmp rdi, rax
jz short loc_1351
loc_1343:
mov rax, [rsp+68h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1351:
mov rax, [rsp+68h+var_40]
sub rax, fs:28h
jnz short loc_13C7
mov eax, ebx
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1372:
mov ebx, 0
jmp short loc_1351
endbr64
mov rbx, rax
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rax, [rsp+arg_20]
sub rax, fs:28h
jz short loc_139D
call ___stack_chk_fail
loc_139D:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_13A5:
lea rax, [rsp+68h+var_58]
cmp rdi, rax
jz short loc_1372
mov ebx, 0
jmp short loc_1343
loc_13B6:
mov rdi, [rsp+68h+var_68]
mov rcx, rdi
add rcx, [rsp+68h+var_60]
jmp loc_1321
loc_13C7:
call ___stack_chk_fail | long long func0(int a1, int a2)
{
int i; // r12d
int v3; // ebx
long long v4; // rdx
int v5; // eax
char *v6; // rdi
char *v7; // rcx
char *v8; // rax
unsigned int v9; // ebx
void *v11; // [rsp+0h] [rbp-68h] BYREF
long long v12; // [rsp+8h] [rbp-60h]
_QWORD v13[11]; // [rsp+10h] [rbp-58h] BYREF
v13[3] = __readfsqword(0x28u);
v11 = v13;
LOWORD(v13[0]) = 49;
v12 = 1LL;
if ( a2 <= 0 )
{
v6 = (char *)v11;
v7 = (char *)v11 + v12;
}
else
{
for ( i = 0; i != a2; ++i )
{
if ( (int)v12 - 1 >= 0 )
{
v4 = (int)v12 - 1;
v3 = 0;
do
{
v5 = v3 + a1 * (*((char *)v11 + v4) - 48);
v3 = v5 / 10;
*((_BYTE *)v11 + v4--) = v5 % 10 + 48;
}
while ( (int)v4 >= 0 );
if ( v5 > 9 )
{
while ( 1 )
{
std::string::_M_replace_aux(&v11, 0LL, 0LL, 1LL, (unsigned int)(char)(v3 % 10 + 48));
if ( v3 <= 9 )
break;
v3 /= 10;
}
}
}
}
v6 = (char *)v11;
v7 = (char *)v11 + v12;
if ( (char *)v11 + v12 == v11 )
{
if ( v11 == v13 )
return 0;
v9 = 0;
goto LABEL_16;
}
}
v8 = v6;
v9 = 0;
do
v9 = v9 + *v8++ - 48;
while ( v7 != v8 );
if ( v6 != (char *)v13 )
LABEL_16:
operator delete(v6, v13[0] + 1LL);
return v9;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV byte ptr [RSP + 0x10],0x31
MOV qword ptr [RSP + 0x8],0x1
MOV byte ptr [RSP + 0x11],0x0
TEST ESI,ESI
JLE 0x001013b6
MOV EBP,EDI
MOV R13D,ESI
MOV R12D,0x0
MOV R14D,0x0
JMP 0x001012a8
LAB_00101242:
MOVSXD RAX,EBX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,EBX
SAR EDX,0x1f
SUB EAX,EDX
CMP EBX,0x9
JLE 0x0010129f
MOV EBX,EAX
LAB_0010125e:
MOVSXD RAX,EBX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV EDX,EBX
SAR EDX,0x1f
SUB EAX,EDX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV R8D,EBX
SUB R8D,EAX
ADD R8D,0x30
MOVSX R8D,R8B
MOV ECX,0x1
MOV EDX,0x0
MOV ESI,0x0
MOV RDI,R15
LAB_00101298:
CALL 0x001010f0
JMP 0x00101242
LAB_0010129f:
ADD R12D,0x1
CMP R13D,R12D
JZ 0x0010130c
LAB_001012a8:
MOV ESI,dword ptr [RSP + 0x8]
SUB ESI,0x1
JS 0x0010129f
MOVSXD RAX,ESI
MOV RDX,RAX
MOV EBX,R14D
SUB ESI,EAX
LAB_001012bc:
MOV RCX,RDX
ADD RCX,qword ptr [RSP]
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
IMUL EAX,EBP
ADD EAX,EBX
MOVSXD RBX,EAX
IMUL RBX,RBX,0x66666667
SAR RBX,0x22
MOV EDI,EAX
SAR EDI,0x1f
SUB EBX,EDI
LEA R8D,[RBX + RBX*0x4]
ADD R8D,R8D
MOV EDI,EAX
SUB EDI,R8D
ADD EDI,0x30
MOV byte ptr [RCX],DIL
SUB RDX,0x1
MOV ECX,ESI
ADD ECX,EDX
JNS 0x001012bc
CMP EAX,0x9
JLE 0x0010129f
MOV R15,RSP
JMP 0x0010125e
LAB_0010130c:
MOV RDI,qword ptr [RSP]
MOV RCX,RDI
ADD RCX,qword ptr [RSP + 0x8]
CMP RCX,RDI
JZ 0x001013a5
LAB_00101321:
MOV RAX,RDI
MOV EBX,0x0
LAB_00101329:
MOVSX EDX,byte ptr [RAX]
LEA EBX,[RBX + RDX*0x1 + -0x30]
ADD RAX,0x1
CMP RCX,RAX
JNZ 0x00101329
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x00101351
LAB_00101343:
MOV RAX,qword ptr [RSP + 0x10]
LEA RSI,[RAX + 0x1]
CALL 0x001010b0
LAB_00101351:
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001013c7
MOV EAX,EBX
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101372:
MOV EBX,0x0
JMP 0x00101351
LAB_001013a5:
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x00101372
MOV EBX,0x0
JMP 0x00101343
LAB_001013b6:
MOV RDI,qword ptr [RSP]
MOV RCX,RDI
ADD RCX,qword ptr [RSP + 0x8]
JMP 0x00101321
LAB_001013c7:
CALL 0x001010c0 | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
char *pcVar4;
char *pcVar5;
int iVar6;
int iVar7;
long in_FS_OFFSET;
char *local_68;
long local_60;
char local_58;
char cStack_57;
int6 uStack_56;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_68 = &local_58;
local_58 = '1';
local_60 = 1;
cStack_57 = '\0';
if (param_2 < 1) {
pcVar5 = &cStack_57;
LAB_00101321:
iVar6 = 0;
pcVar4 = local_68;
do {
iVar6 = iVar6 + -0x30 + (int)*pcVar4;
pcVar4 = pcVar4 + 1;
} while (pcVar5 != pcVar4);
if (local_68 == &local_58) goto LAB_00101351;
}
else {
iVar6 = 0;
do {
if (-1 < (int)local_60 + -1) {
lVar3 = (long)((int)local_60 + -1);
iVar7 = 0;
do {
iVar2 = (local_68[lVar3] + -0x30) * param_1 + iVar7;
iVar7 = iVar2 / 10;
local_68[lVar3] = (char)iVar2 + (char)iVar7 * -10 + '0';
lVar3 = lVar3 + -1;
} while (-1 < (int)lVar3);
while (iVar1 = iVar7, 9 < iVar2) {
/* try { // try from 00101298 to 0010129c has its CatchHandler @ 00101379 */
std::string::_M_replace_aux((ulong)&local_68,0,0,'\x01');
iVar7 = iVar1 / 10;
iVar2 = iVar1;
}
}
iVar6 = iVar6 + 1;
} while (param_2 != iVar6);
pcVar5 = local_68 + local_60;
if (pcVar5 != local_68) goto LAB_00101321;
if (local_68 == &local_58) {
iVar6 = 0;
goto LAB_00101351;
}
iVar6 = 0;
}
operator_delete(local_68,CONCAT62(uStack_56,CONCAT11(cStack_57,local_58)) + 1);
LAB_00101351:
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar6;
} |
2,894 | func0 |
#include <cassert>
#include <string>
| int func0(int base, int power) {
std::string result = "1";
for(int i = 0; i < power; ++i) {
int carry = 0;
for(int j = result.size() - 1; j >= 0; --j) {
int digit = (result[j] - '0') * base + carry;
result[j] = (digit % 10) + '0';
carry = digit / 10;
}
while(carry > 0) {
result.insert(result.begin(), (carry % 10) + '0');
carry /= 10;
}
}
int sum = 0;
for(char c : result) {
sum += c - '0';
}
return sum;
}
| int main(){
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
}
| O2 | cpp | func0(int, int):
endbr64
push %r15
mov $0x31,%edx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %dx,0x20(%rsp)
mov %rax,0x8(%rsp)
mov %rax,0x10(%rsp)
movq $0x1,0x18(%rsp)
test %esi,%esi
jle 1427 <_Z5func0ii+0x187>
mov %edi,%r13d
mov %esi,%r15d
mov %rax,%rdi
xor %r14d,%r14d
mov $0x1,%eax
nopl (%rax)
mov %eax,%edx
sub $0x1,%edx
js 13c4 <_Z5func0ii+0x124>
movslq %edx,%rdx
xor %ebx,%ebx
jmp 131d <_Z5func0ii+0x7d>
nopw 0x0(%rax,%rax,1)
mov 0x10(%rsp),%rdi
add %rdx,%rdi
sub $0x1,%rdx
movsbl (%rdi),%eax
sub $0x30,%eax
imul %r13d,%eax
add %ebx,%eax
movslq %eax,%rbx
mov %eax,%ecx
mov %eax,%esi
imul $0x66666667,%rbx,%rbx
sar $0x1f,%ecx
sar $0x22,%rbx
sub %ecx,%ebx
lea (%rbx,%rbx,4),%ecx
add %ecx,%ecx
sub %ecx,%esi
mov %esi,%ecx
add $0x30,%ecx
mov %cl,(%rdi)
test %edx,%edx
jns 1318 <_Z5func0ii+0x78>
lea 0x10(%rsp),%r12
cmp $0x9,%eax
jg 136a <_Z5func0ii+0xca>
jmp 13ba <_Z5func0ii+0x11a>
nopl (%rax)
mov %ebp,%ebx
movslq %ebx,%rbp
mov %ebx,%edx
mov %ebx,%r8d
mov $0x1,%ecx
imul $0x66666667,%rbp,%rax
sar $0x1f,%edx
xor %esi,%esi
mov %r12,%rdi
sar $0x22,%rax
sub %edx,%eax
xor %edx,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%r8d
add $0x30,%r8d
movzbl %r8b,%r8d
callq 10d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc@plt>
imul $0x66666667,%rbp,%rbp
mov %ebx,%eax
sar $0x1f,%eax
sar $0x22,%rbp
sub %eax,%ebp
cmp $0x9,%ebx
jg 1368 <_Z5func0ii+0xc8>
mov 0x18(%rsp),%rax
mov 0x10(%rsp),%rdi
add $0x1,%r14d
cmp %r14d,%r15d
jne 1300 <_Z5func0ii+0x60>
add %rdi,%rax
cmp %rdi,%rax
je 142f <_Z5func0ii+0x18f>
movsbl (%rdi),%ecx
mov %rdi,%rdx
xor %r12d,%r12d
jmp 13eb <_Z5func0ii+0x14b>
nopl 0x0(%rax)
movsbl (%rdx),%ecx
add $0x1,%rdx
lea -0x30(%r12,%rcx,1),%r12d
cmp %rdx,%rax
jne 13e8 <_Z5func0ii+0x148>
cmp 0x8(%rsp),%rdi
je 1405 <_Z5func0ii+0x165>
callq 10a0 <_ZdlPv@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1434 <_Z5func0ii+0x194>
add $0x48,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x1,%r12d
jmp 1405 <_Z5func0ii+0x165>
xor %r12d,%r12d
jmp 13f9 <_Z5func0ii+0x159>
callq 10b0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 10e0 <_Z5func0ii.cold>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0ii:
endbr64
push r15
mov edx, 31h ; '1'
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
lea rax, [rsp+78h+var_58]
mov word ptr [rsp+78h+var_58], dx
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 1
test esi, esi
jle loc_1499
mov r12d, edi
mov r15d, esi
mov rdi, rax
mov ecx, 1
xor r14d, r14d
lea r13, [rsp+78h+var_68]
nop word ptr [rax+rax+00h]
loc_1338:
mov eax, ecx
sub eax, 1
js loc_142C
mov eax, eax
add rdi, rax
movsx eax, byte ptr [rdi]
sub eax, 30h ; '0'
imul eax, r12d
movsxd rbx, eax
cdq
imul rbx, 66666667h
sar rbx, 22h
sub ebx, edx
mov edx, eax
lea esi, [rbx+rbx*4]
add esi, esi
sub edx, esi
add edx, 30h ; '0'
mov [rdi], dl
lea edx, [rcx-2]
cmp ecx, 1
jz short loc_13C0
nop dword ptr [rax+00000000h]
loc_1380:
mov rcx, [rsp+78h+var_68]
add rcx, rdx
sub rdx, 1
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
imul eax, r12d
add eax, ebx
movsxd rbx, eax
mov esi, eax
imul rbx, 66666667h
sar esi, 1Fh
sar rbx, 22h
sub ebx, esi
mov esi, eax
lea edi, [rbx+rbx*4]
add edi, edi
sub esi, edi
add esi, 30h ; '0'
mov [rcx], sil
test edx, edx
jns short loc_1380
loc_13C0:
cmp eax, 9
jg short loc_13D2
jmp short loc_1422
loc_13D0:
mov ebx, ebp
loc_13D2:
movsxd rbp, ebx
mov edx, ebx
mov r8d, ebx
mov ecx, 1
imul rax, rbp, 66666667h
sar edx, 1Fh
xor esi, esi
mov rdi, r13
sar rax, 22h
sub eax, edx
xor edx, edx
lea eax, [rax+rax*4]
add eax, eax
sub r8d, eax
add r8d, 30h ; '0'
movzx r8d, r8b
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc; std::string::_M_replace_aux(ulong,ulong,ulong,char)
imul rbp, 66666667h
mov eax, ebx
sar eax, 1Fh
sar rbp, 22h
sub ebp, eax
cmp ebx, 9
jg short loc_13D0
loc_1422:
mov rdi, [rsp+78h+var_68]; void *
mov rcx, [rsp+78h+var_60]
loc_142C:
add r14d, 1
cmp r15d, r14d
jnz loc_1338
add rcx, rdi
cmp rdi, rcx
jz short loc_14A5
loc_1441:
mov rax, rdi
xor ebx, ebx
nop word ptr [rax+rax+00000000h]
loc_1450:
movsx edx, byte ptr [rax]
add rax, 1
lea ebx, [rbx+rdx-30h]
cmp rcx, rax
jnz short loc_1450
loc_1460:
mov rax, [rsp+78h+var_70]
cmp rdi, rax
jz short loc_1478
mov rax, [rsp+78h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1478:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_14A9
add rsp, 48h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1499:
mov rdi, [rsp+78h+var_70]
lea rcx, [rsp+78h+var_58+1]
jmp short loc_1441
loc_14A5:
xor ebx, ebx
jmp short loc_1460
loc_14A9:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0ii_cold; func0(int,int) [clone] | long long func0(int a1, int a2)
{
char *v3; // rdi
long long v4; // rcx
int i; // r14d
char *v6; // rdi
int v7; // eax
int v8; // ebx
long long v9; // rdx
_BYTE *v10; // rcx
char *v11; // rcx
char *v12; // rax
unsigned int v13; // ebx
int v14; // edx
void *v16; // [rsp+10h] [rbp-68h] BYREF
long long v17; // [rsp+18h] [rbp-60h]
_QWORD v18[11]; // [rsp+20h] [rbp-58h] BYREF
v18[3] = __readfsqword(0x28u);
LOWORD(v18[0]) = 49;
v16 = v18;
v17 = 1LL;
if ( a2 <= 0 )
{
v3 = (char *)v18;
v11 = (char *)v18 + 1;
}
else
{
v3 = (char *)v18;
v4 = 1LL;
for ( i = 0; i != a2; ++i )
{
if ( (int)v4 - 1 >= 0 )
{
v6 = &v3[(unsigned int)(v4 - 1)];
v7 = a1 * (*v6 - 48);
v8 = v7 / 10;
*v6 = v7 % 10 + 48;
v9 = (unsigned int)(v4 - 2);
if ( (_DWORD)v4 != 1 )
{
do
{
v10 = (char *)v16 + v9--;
v7 = v8 + a1 * ((char)*v10 - 48);
v8 = v7 / 10;
*v10 = v7 % 10 + 48;
}
while ( (int)v9 >= 0 );
}
if ( v7 > 9 )
{
while ( 1 )
{
std::string::_M_replace_aux(&v16, 0LL, 0LL, 1LL, (unsigned __int8)(v8 % 10 + 48));
if ( v8 <= 9 )
break;
v8 /= 10;
}
}
v3 = (char *)v16;
v4 = v17;
}
}
v11 = &v3[v4];
if ( v3 == v11 )
{
v13 = 0;
goto LABEL_15;
}
}
v12 = v3;
v13 = 0;
do
{
v14 = *v12++;
v13 = v13 + v14 - 48;
}
while ( v11 != v12 );
LABEL_15:
if ( v3 != (char *)v18 )
operator delete(v3, v18[0] + 1LL);
return v13;
} | func0:
ENDBR64
PUSH R15
MOV EDX,0x31
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
LEA RAX,[RSP + 0x20]
MOV word ptr [RSP + 0x20],DX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x1
TEST ESI,ESI
JLE 0x00101499
MOV R12D,EDI
MOV R15D,ESI
MOV RDI,RAX
MOV ECX,0x1
XOR R14D,R14D
LEA R13,[RSP + 0x10]
NOP word ptr [RAX + RAX*0x1]
LAB_00101338:
MOV EAX,ECX
SUB EAX,0x1
JS 0x0010142c
MOV EAX,EAX
ADD RDI,RAX
MOVSX EAX,byte ptr [RDI]
SUB EAX,0x30
IMUL EAX,R12D
MOVSXD RBX,EAX
CDQ
IMUL RBX,RBX,0x66666667
SAR RBX,0x22
SUB EBX,EDX
MOV EDX,EAX
LEA ESI,[RBX + RBX*0x4]
ADD ESI,ESI
SUB EDX,ESI
ADD EDX,0x30
MOV byte ptr [RDI],DL
LEA EDX,[RCX + -0x2]
CMP ECX,0x1
JZ 0x001013c0
NOP dword ptr [RAX]
LAB_00101380:
MOV RCX,qword ptr [RSP + 0x10]
ADD RCX,RDX
SUB RDX,0x1
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
IMUL EAX,R12D
ADD EAX,EBX
MOVSXD RBX,EAX
MOV ESI,EAX
IMUL RBX,RBX,0x66666667
SAR ESI,0x1f
SAR RBX,0x22
SUB EBX,ESI
MOV ESI,EAX
LEA EDI,[RBX + RBX*0x4]
ADD EDI,EDI
SUB ESI,EDI
ADD ESI,0x30
MOV byte ptr [RCX],SIL
TEST EDX,EDX
JNS 0x00101380
LAB_001013c0:
CMP EAX,0x9
JG 0x001013d2
JMP 0x00101422
LAB_001013d0:
MOV EBX,EBP
LAB_001013d2:
MOVSXD RBP,EBX
MOV EDX,EBX
MOV R8D,EBX
MOV ECX,0x1
IMUL RAX,RBP,0x66666667
SAR EDX,0x1f
XOR ESI,ESI
MOV RDI,R13
SAR RAX,0x22
SUB EAX,EDX
XOR EDX,EDX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
SUB R8D,EAX
ADD R8D,0x30
MOVZX R8D,R8B
LAB_00101406:
CALL 0x001010f0
IMUL RBP,RBP,0x66666667
MOV EAX,EBX
SAR EAX,0x1f
SAR RBP,0x22
SUB EBP,EAX
CMP EBX,0x9
JG 0x001013d0
LAB_00101422:
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_0010142c:
ADD R14D,0x1
CMP R15D,R14D
JNZ 0x00101338
ADD RCX,RDI
CMP RDI,RCX
JZ 0x001014a5
LAB_00101441:
MOV RAX,RDI
XOR EBX,EBX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101450:
MOVSX EDX,byte ptr [RAX]
ADD RAX,0x1
LEA EBX,[RBX + RDX*0x1 + -0x30]
CMP RCX,RAX
JNZ 0x00101450
LAB_00101460:
MOV RAX,qword ptr [RSP + 0x8]
CMP RDI,RAX
JZ 0x00101478
MOV RAX,qword ptr [RSP + 0x20]
LEA RSI,[RAX + 0x1]
CALL 0x001010b0
LAB_00101478:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001014a9
ADD RSP,0x48
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101499:
MOV RDI,qword ptr [RSP + 0x8]
LEA RCX,[RSP + 0x21]
JMP 0x00101441
LAB_001014a5:
XOR EBX,EBX
JMP 0x00101460
LAB_001014a9:
CALL 0x001010c0 | /* func0(int, int) */
int func0(int param_1,int param_2)
{
char cVar1;
int iVar2;
char *pcVar3;
int iVar4;
long lVar5;
char *pcVar6;
ulong uVar7;
int iVar8;
char *pcVar9;
int iVar10;
long in_FS_OFFSET;
char *local_68;
long local_60;
int2 local_58;
int6 uStack_56;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = 0x31;
local_60 = 1;
pcVar9 = (char *)&local_58;
local_68 = (char *)&local_58;
if (param_2 < 1) {
pcVar6 = (char *)((long)&local_58 + 1);
}
else {
lVar5 = 1;
iVar10 = 0;
do {
iVar4 = (int)lVar5;
if (-1 < (int)(iVar4 - 1U)) {
iVar2 = (pcVar9[iVar4 - 1U] + -0x30) * param_1;
iVar8 = iVar2 / 10;
pcVar9[iVar4 - 1U] = (char)iVar2 + (char)iVar8 * -10 + '0';
uVar7 = (ulong)(iVar4 - 2);
pcVar9 = local_68;
lVar5 = local_60;
if (iVar4 != 1) {
do {
pcVar6 = local_68 + uVar7;
uVar7 = uVar7 - 1;
iVar2 = (*pcVar6 + -0x30) * param_1 + iVar8;
iVar8 = iVar2 / 10;
*pcVar6 = (char)iVar2 + (char)iVar8 * -10 + '0';
} while (-1 < (int)uVar7);
}
while (iVar4 = iVar8, local_68 = pcVar9, local_60 = lVar5, 9 < iVar2) {
/* try { // try from 00101406 to 0010140a has its CatchHandler @ 001014ae */
std::string::_M_replace_aux((ulong)&local_68,0,0,'\x01');
pcVar9 = local_68;
lVar5 = local_60;
iVar8 = iVar4 / 10;
iVar2 = iVar4;
}
}
iVar10 = iVar10 + 1;
} while (param_2 != iVar10);
pcVar6 = pcVar9 + lVar5;
if (pcVar9 == pcVar6) {
iVar10 = 0;
goto LAB_00101460;
}
}
iVar10 = 0;
pcVar3 = pcVar9;
do {
cVar1 = *pcVar3;
pcVar3 = pcVar3 + 1;
iVar10 = iVar10 + -0x30 + (int)cVar1;
} while (pcVar6 != pcVar3);
LAB_00101460:
if (pcVar9 != (char *)&local_58) {
operator_delete(pcVar9,CONCAT62(uStack_56,local_58) + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar10;
} |
2,895 | func0 |
#include <cassert>
#include <string>
| int func0(int base, int power) {
std::string result = "1";
for(int i = 0; i < power; ++i) {
int carry = 0;
for(int j = result.size() - 1; j >= 0; --j) {
int digit = (result[j] - '0') * base + carry;
result[j] = (digit % 10) + '0';
carry = digit / 10;
}
while(carry > 0) {
result.insert(result.begin(), (carry % 10) + '0');
carry /= 10;
}
}
int sum = 0;
for(char c : result) {
sum += c - '0';
}
return sum;
}
| int main(){
assert(func0(2, 100) == 115);
assert(func0(8, 10) == 37);
assert(func0(8, 15) == 62);
}
| O3 | cpp | func0(int, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %edi,%r12d
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
mov $0x31,%eax
movq $0x1,0x18(%rsp)
mov %rdi,0x8(%rsp)
mov %rdi,0x10(%rsp)
mov %ax,0x20(%rsp)
test %esi,%esi
jle 1636 <_Z5func0ii+0x396>
mov %esi,%r15d
mov $0x1,%ecx
lea 0x10(%rsp),%r13
xor %r14d,%r14d
mov %ecx,%eax
mov %ecx,%edx
sub $0x1,%eax
js 13fc <_Z5func0ii+0x15c>
cltq
add %rax,%rdi
movsbl (%rdi),%eax
sub $0x30,%eax
imul %r12d,%eax
movslq %eax,%rbx
mov %eax,%esi
mov %eax,%r9d
imul $0x66666667,%rbx,%rbx
sar $0x1f,%esi
sar $0x22,%rbx
sub %esi,%ebx
lea (%rbx,%rbx,4),%esi
add %esi,%esi
sub %esi,%r9d
mov %r9d,%esi
add $0x30,%esi
mov %sil,(%rdi)
cmp $0x1,%ecx
je 1392 <_Z5func0ii+0xf2>
sub $0x2,%edx
movslq %edx,%rdx
mov 0x10(%rsp),%rcx
add %rdx,%rcx
sub $0x1,%rdx
movsbl (%rcx),%eax
sub $0x30,%eax
imul %r12d,%eax
add %ebx,%eax
movslq %eax,%rbx
mov %eax,%esi
mov %eax,%edi
imul $0x66666667,%rbx,%rbx
sar $0x1f,%esi
sar $0x22,%rbx
sub %esi,%ebx
lea (%rbx,%rbx,4),%esi
add %esi,%esi
sub %esi,%edi
mov %edi,%esi
add $0x30,%esi
mov %sil,(%rcx)
test %edx,%edx
jns 1350 <_Z5func0ii+0xb0>
cmp $0x9,%eax
jg 13a2 <_Z5func0ii+0x102>
jmp 13f2 <_Z5func0ii+0x152>
nopl 0x0(%rax)
mov %ebp,%ebx
movslq %ebx,%rbp
mov %ebx,%edx
mov %ebx,%r8d
mov $0x1,%ecx
imul $0x66666667,%rbp,%rax
sar $0x1f,%edx
xor %esi,%esi
mov %r13,%rdi
sar $0x22,%rax
sub %edx,%eax
xor %edx,%edx
lea (%rax,%rax,4),%eax
add %eax,%eax
sub %eax,%r8d
add $0x30,%r8d
movzbl %r8b,%r8d
callq 10d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc@plt>
imul $0x66666667,%rbp,%rbp
mov %ebx,%eax
sar $0x1f,%eax
sar $0x22,%rbp
sub %eax,%ebp
cmp $0x9,%ebx
jg 13a0 <_Z5func0ii+0x100>
mov 0x18(%rsp),%rcx
mov 0x10(%rsp),%rdi
add $0x1,%r14d
cmp %r14d,%r15d
jne 1300 <_Z5func0ii+0x60>
add %rdi,%rcx
cmp %rdi,%rcx
je 1640 <_Z5func0ii+0x3a0>
lea -0x1(%rcx),%rdx
mov %rcx,%rsi
mov %rdi,%rax
sub %rdi,%rdx
sub %rdi,%rsi
cmp $0xe,%rdx
jbe 1645 <_Z5func0ii+0x3a5>
pxor %xmm1,%xmm1
pxor %xmm6,%xmm6
pxor %xmm4,%xmm4
mov %rsi,%rdx
and $0xfffffffffffffff0,%rdx
movdqa 0xc56(%rip),%xmm5
add %rdi,%rdx
nopl (%rax)
movdqu (%rax),%xmm0
movdqa %xmm6,%xmm3
add $0x10,%rax
pcmpgtb %xmm0,%xmm3
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
punpckhbw %xmm3,%xmm0
movdqa %xmm4,%xmm3
paddw %xmm5,%xmm2
paddw %xmm5,%xmm0
pcmpgtw %xmm2,%xmm3
movdqa %xmm2,%xmm7
punpcklwd %xmm3,%xmm7
punpckhwd %xmm3,%xmm2
movdqa %xmm0,%xmm3
paddd %xmm7,%xmm1
paddd %xmm2,%xmm1
movdqa %xmm4,%xmm2
pcmpgtw %xmm0,%xmm2
punpcklwd %xmm2,%xmm3
punpckhwd %xmm2,%xmm0
paddd %xmm3,%xmm1
paddd %xmm0,%xmm1
cmp %rdx,%rax
jne 1450 <_Z5func0ii+0x1b0>
movdqa %xmm1,%xmm0
mov %rsi,%rdx
psrldq $0x8,%xmm0
and $0xfffffffffffffff0,%rdx
paddd %xmm1,%xmm0
lea (%rdi,%rdx,1),%rax
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%r12d
cmp %rsi,%rdx
je 1608 <_Z5func0ii+0x368>
movsbl (%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x1(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x1(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x2(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x2(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x3(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x3(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x4(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x4(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x5(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x5(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x6(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x6(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x7(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x7(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x8(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x8(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0x9(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0x9(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0xa(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0xa(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0xb(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0xb(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0xc(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0xc(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0xd(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0xd(%rax),%edx
lea -0x30(%r12,%rdx,1),%r12d
lea 0xe(%rax),%rdx
cmp %rdx,%rcx
je 1608 <_Z5func0ii+0x368>
movsbl 0xe(%rax),%eax
lea -0x30(%r12,%rax,1),%r12d
nopl 0x0(%rax)
cmp 0x8(%rsp),%rdi
je 1614 <_Z5func0ii+0x374>
callq 10a0 <_ZdlPv@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 164d <_Z5func0ii+0x3ad>
add $0x48,%rsp
mov %r12d,%eax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
lea 0x21(%rsp),%rcx
jmpq 1415 <_Z5func0ii+0x175>
xor %r12d,%r12d
jmp 1608 <_Z5func0ii+0x368>
xor %r12d,%r12d
jmpq 14e4 <_Z5func0ii+0x244>
callq 10b0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 10e0 <_Z5func0ii.cold>
xchg %ax,%ax
| _Z5func0ii:
endbr64
push r15
mov edx, 31h ; '1'
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
lea rax, [rsp+78h+var_58]
mov word ptr [rsp+78h+var_58], dx
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_68], rax
mov [rsp+78h+var_60], 1
test esi, esi
jle loc_1686
mov r12d, edi
mov r15d, esi
mov rdi, rax
mov ecx, 1
xor r14d, r14d
lea r13, [rsp+78h+var_68]
nop word ptr [rax+rax+00h]
loc_1338:
mov eax, ecx
sub eax, 1
js loc_1668
mov eax, eax
lea rdx, [rdi+rax]
movsx eax, byte ptr [rdx]
sub eax, 30h ; '0'
imul eax, r12d
movsxd rbx, eax
mov esi, eax
imul rbx, 66666667h
sar esi, 1Fh
sar rbx, 22h
sub ebx, esi
mov esi, eax
lea edi, [rbx+rbx*4]
add edi, edi
sub esi, edi
add esi, 30h ; '0'
mov [rdx], sil
lea edx, [rcx-2]
cmp ecx, 1
jz short loc_13C0
nop
loc_1380:
mov rcx, [rsp+78h+var_68]
add rcx, rdx
sub rdx, 1
movsx eax, byte ptr [rcx]
sub eax, 30h ; '0'
imul eax, r12d
add eax, ebx
movsxd rbx, eax
mov esi, eax
imul rbx, 66666667h
sar esi, 1Fh
sar rbx, 22h
sub ebx, esi
mov esi, eax
lea edi, [rbx+rbx*4]
add edi, edi
sub esi, edi
add esi, 30h ; '0'
mov [rcx], sil
test edx, edx
jns short loc_1380
loc_13C0:
cmp eax, 9
jg short loc_13D2
jmp short loc_1422
loc_13D0:
mov ebx, ebp
loc_13D2:
movsxd rbp, ebx
mov edx, ebx
mov r8d, ebx
mov ecx, 1
imul rax, rbp, 66666667h
sar edx, 1Fh
xor esi, esi
mov rdi, r13
sar rax, 22h
sub eax, edx
xor edx, edx
lea eax, [rax+rax*4]
add eax, eax
sub r8d, eax
add r8d, 30h ; '0'
movzx r8d, r8b
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE14_M_replace_auxEmmmc; std::string::_M_replace_aux(ulong,ulong,ulong,char)
imul rbp, 66666667h
mov eax, ebx
sar eax, 1Fh
sar rbp, 22h
sub ebp, eax
cmp ebx, 9
jg short loc_13D0
loc_1422:
add r14d, 1
mov rdi, [rsp+78h+var_68]; void *
mov rcx, [rsp+78h+var_60]
cmp r15d, r14d
jnz loc_1338
loc_1439:
lea rsi, [rdi+rcx]
cmp rsi, rdi
jz loc_1682
lea rax, [rcx-1]
cmp rax, 0Eh
jbe loc_1698
loc_1454:
mov r8, rcx
pxor xmm3, xmm3
pxor xmm6, xmm6
mov rax, rdi
and r8, 0FFFFFFFFFFFFFFF0h
movdqa xmm5, cs:xmmword_2080
pxor xmm4, xmm4
lea rdx, [r8+rdi]
nop word ptr [rax+rax+00000000h]
loc_1480:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm1, xmm6
movdqa xmm7, xmm4
add rax, 10h
pcmpgtb xmm1, xmm0
movdqa xmm2, xmm0
punpcklbw xmm2, xmm1
punpckhbw xmm0, xmm1
paddw xmm2, xmm5
paddw xmm0, xmm5
pcmpgtw xmm7, xmm2
movdqa xmm1, xmm2
punpcklwd xmm1, xmm7
punpckhwd xmm2, xmm7
paddd xmm1, xmm3
movdqa xmm3, xmm0
paddd xmm1, xmm2
movdqa xmm2, xmm4
pcmpgtw xmm2, xmm0
punpcklwd xmm3, xmm2
punpckhwd xmm0, xmm2
paddd xmm1, xmm3
movdqa xmm3, xmm1
paddd xmm3, xmm0
cmp rdx, rax
jnz short loc_1480
movdqa xmm0, xmm3
psrldq xmm0, 8
paddd xmm0, xmm3
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd ebx, xmm0
movdqa xmm0, xmm3
psrldq xmm3, 8
paddd xmm0, xmm3
cmp rcx, r8
jz loc_162A
loc_1519:
sub rcx, r8
lea rax, [rcx-1]
cmp rax, 6
jbe loc_15BD
movq xmm3, qword ptr [rdi+r8]
pxor xmm4, xmm4
movq xmm1, qword ptr cs:xmmword_2080
pcmpgtb xmm4, xmm3
movdqa xmm2, xmm3
punpcklbw xmm2, xmm4
punpcklbw xmm3, xmm4
paddw xmm2, xmm1
pshufd xmm3, xmm3, 4Eh ; 'N'
paddw xmm1, xmm3
pxor xmm3, xmm3
movdqa xmm4, xmm3
pcmpgtw xmm4, xmm2
movdqa xmm5, xmm2
pcmpgtw xmm3, xmm1
punpcklwd xmm5, xmm4
punpcklwd xmm2, xmm4
paddd xmm0, xmm5
pshufd xmm2, xmm2, 4Eh ; 'N'
paddd xmm0, xmm2
movdqa xmm2, xmm3
movdqa xmm3, xmm1
punpcklwd xmm3, xmm2
punpcklwd xmm1, xmm2
pshufd xmm1, xmm1, 4Eh ; 'N'
paddd xmm0, xmm3
paddd xmm0, xmm1
movd ebx, xmm0
pshufd xmm6, xmm0, 0E5h
movd eax, xmm6
add ebx, eax
mov rax, rcx
and rax, 0FFFFFFFFFFFFFFF8h
add rdx, rax
and ecx, 7
jz short loc_162A
loc_15BD:
movsx eax, byte ptr [rdx]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+1]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+1]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+2]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+2]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+3]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+3]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+4]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+4]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+5]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+5]
lea ebx, [rbx+rax-30h]
lea rax, [rdx+6]
cmp rsi, rax
jz short loc_162A
movsx eax, byte ptr [rdx+6]
lea ebx, [rbx+rax-30h]
loc_162A:
mov rax, [rsp+78h+var_70]
cmp rdi, rax
jz short loc_1642
mov rax, [rsp+78h+var_58]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1642:
mov rax, [rsp+78h+var_40]
sub rax, fs:28h
jnz short loc_16A9
add rsp, 48h
mov eax, ebx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1668:
add r14d, 1
cmp r15d, r14d
jnz loc_1439
lea rsi, [rdi+rcx]
cmp rdi, rsi
jnz loc_1454
loc_1682:
xor ebx, ebx
jmp short loc_162A
loc_1686:
mov rdx, rax
lea rsi, [rsp+78h+var_58+1]
mov rdi, rax
xor ebx, ebx
jmp loc_15BD
loc_1698:
mov rdx, rdi
pxor xmm0, xmm0
xor r8d, r8d
xor ebx, ebx
jmp loc_1519
loc_16A9:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0ii_cold; func0(int,int) [clone] | long long func0(int a1, int a2)
{
__m128i *v3; // rdi
long long v4; // rcx
int v5; // r14d
__int8 *v6; // rdx
int v7; // eax
int v8; // ebx
long long v9; // rdx
_BYTE *v10; // rcx
char *v11; // rsi
__m128i v12; // xmm3
const __m128i *v13; // rax
unsigned long long v14; // r8
__m128i si128; // xmm5
char *v16; // rdx
__m128i v17; // xmm0
__m128i v18; // xmm1
__m128i v19; // xmm2
__m128i v20; // xmm0
__m128i v21; // xmm7
__m128i v22; // xmm1
__m128i v23; // xmm2
__m128i v24; // xmm0
unsigned int v25; // ebx
__m128i v26; // xmm0
unsigned long long v27; // rcx
__m128i v28; // xmm3
__m128i v29; // xmm1
__m128i v30; // xmm3
__m128i v31; // xmm2
__m128i v32; // xmm1
__m128i v33; // xmm2
__m128i v34; // xmm3
__m128i v35; // xmm0
void *v37; // [rsp+10h] [rbp-68h] BYREF
long long v38; // [rsp+18h] [rbp-60h]
_QWORD v39[11]; // [rsp+20h] [rbp-58h] BYREF
v39[3] = __readfsqword(0x28u);
LOWORD(v39[0]) = 49;
v37 = v39;
v38 = 1LL;
if ( a2 > 0 )
{
v3 = (__m128i *)v39;
v4 = 1LL;
v5 = 0;
while ( (int)v4 - 1 >= 0 )
{
v6 = &v3->m128i_i8[(unsigned int)(v4 - 1)];
v7 = a1 * (*v6 - 48);
v8 = v7 / 10;
*v6 = v7 % 10 + 48;
v9 = (unsigned int)(v4 - 2);
if ( (_DWORD)v4 != 1 )
{
do
{
v10 = (char *)v37 + v9--;
v7 = v8 + a1 * ((char)*v10 - 48);
v8 = v7 / 10;
*v10 = v7 % 10 + 48;
}
while ( (int)v9 >= 0 );
}
if ( v7 > 9 )
{
while ( 1 )
{
std::string::_M_replace_aux(&v37, 0LL, 0LL, 1LL, (unsigned __int8)(v8 % 10 + 48));
if ( v8 <= 9 )
break;
v8 /= 10;
}
}
++v5;
v3 = (__m128i *)v37;
v4 = v38;
if ( a2 == v5 )
goto LABEL_11;
}
if ( a2 == v5 + 1 )
{
v11 = &v3->m128i_i8[v4];
if ( v3 == (__m128i *)&v3->m128i_i8[v4] )
goto LABEL_30;
}
else
{
LABEL_11:
v11 = &v3->m128i_i8[v4];
if ( &v3->m128i_i8[v4] == (__int8 *)v3 )
{
LABEL_30:
v25 = 0;
goto LABEL_25;
}
if ( (unsigned long long)(v4 - 1) <= 0xE )
{
v16 = (char *)v3;
v26 = 0LL;
v14 = 0LL;
v25 = 0;
LABEL_16:
v27 = v4 - v14;
if ( v27 - 1 > 6 )
{
v28 = _mm_loadl_epi64((__m128i *)((char *)v3 + v14));
v29 = _mm_loadl_epi64((const __m128i *)&xmmword_2080);
v30 = _mm_unpacklo_epi8(v28, _mm_cmpgt_epi8((__m128i)0LL, v28));
v31 = _mm_add_epi16(v30, v29);
v32 = _mm_add_epi16(v29, _mm_shuffle_epi32(v30, 78));
v33 = _mm_unpacklo_epi16(v31, _mm_cmpgt_epi16((__m128i)0LL, v31));
v34 = _mm_unpacklo_epi16(v32, _mm_cmpgt_epi16((__m128i)0LL, v32));
v35 = _mm_add_epi32(
_mm_add_epi32(_mm_add_epi32(_mm_add_epi32(v26, v33), _mm_shuffle_epi32(v33, 78)), v34),
_mm_shuffle_epi32(v34, 78));
v25 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v35, 229)) + _mm_cvtsi128_si32(v35);
v16 += v27 & 0xFFFFFFFFFFFFFFF8LL;
if ( (v27 & 7) == 0 )
goto LABEL_25;
}
goto LABEL_18;
}
}
v12 = 0LL;
v13 = v3;
v14 = v4 & 0xFFFFFFFFFFFFFFF0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2080);
v16 = &v3->m128i_i8[v4 & 0xFFFFFFFFFFFFFFF0LL];
do
{
v17 = _mm_loadu_si128(v13++);
v18 = _mm_cmpgt_epi8((__m128i)0LL, v17);
v19 = _mm_add_epi16(_mm_unpacklo_epi8(v17, v18), si128);
v20 = _mm_add_epi16(_mm_unpackhi_epi8(v17, v18), si128);
v21 = _mm_cmpgt_epi16((__m128i)0LL, v19);
v22 = _mm_add_epi32(_mm_add_epi32(_mm_unpacklo_epi16(v19, v21), v12), _mm_unpackhi_epi16(v19, v21));
v23 = _mm_cmpgt_epi16((__m128i)0LL, v20);
v12 = _mm_add_epi32(_mm_add_epi32(v22, _mm_unpacklo_epi16(v20, v23)), _mm_unpackhi_epi16(v20, v23));
}
while ( v16 != (char *)v13 );
v24 = _mm_add_epi32(_mm_srli_si128(v12, 8), v12);
v25 = _mm_cvtsi128_si32(_mm_add_epi32(v24, _mm_srli_si128(v24, 4)));
v26 = _mm_add_epi32(v12, _mm_srli_si128(v12, 8));
if ( v4 == v14 )
goto LABEL_25;
goto LABEL_16;
}
v16 = (char *)v39;
v11 = (char *)v39 + 1;
v3 = (__m128i *)v39;
v25 = 0;
LABEL_18:
v25 = v25 + *v16 - 48;
if ( v11 != v16 + 1 )
{
v25 = v25 + v16[1] - 48;
if ( v11 != v16 + 2 )
{
v25 = v25 + v16[2] - 48;
if ( v11 != v16 + 3 )
{
v25 = v25 + v16[3] - 48;
if ( v11 != v16 + 4 )
{
v25 = v25 + v16[4] - 48;
if ( v11 != v16 + 5 )
{
v25 = v25 + v16[5] - 48;
if ( v11 != v16 + 6 )
v25 = v25 + v16[6] - 48;
}
}
}
}
}
LABEL_25:
if ( v3 != (__m128i *)v39 )
operator delete(v3, v39[0] + 1LL);
return v25;
} | func0:
ENDBR64
PUSH R15
MOV EDX,0x31
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
LEA RAX,[RSP + 0x20]
MOV word ptr [RSP + 0x20],DX
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x18],0x1
TEST ESI,ESI
JLE 0x00101686
MOV R12D,EDI
MOV R15D,ESI
MOV RDI,RAX
MOV ECX,0x1
XOR R14D,R14D
LEA R13,[RSP + 0x10]
NOP word ptr [RAX + RAX*0x1]
LAB_00101338:
MOV EAX,ECX
SUB EAX,0x1
JS 0x00101668
MOV EAX,EAX
LEA RDX,[RDI + RAX*0x1]
MOVSX EAX,byte ptr [RDX]
SUB EAX,0x30
IMUL EAX,R12D
MOVSXD RBX,EAX
MOV ESI,EAX
IMUL RBX,RBX,0x66666667
SAR ESI,0x1f
SAR RBX,0x22
SUB EBX,ESI
MOV ESI,EAX
LEA EDI,[RBX + RBX*0x4]
ADD EDI,EDI
SUB ESI,EDI
ADD ESI,0x30
MOV byte ptr [RDX],SIL
LEA EDX,[RCX + -0x2]
CMP ECX,0x1
JZ 0x001013c0
NOP
LAB_00101380:
MOV RCX,qword ptr [RSP + 0x10]
ADD RCX,RDX
SUB RDX,0x1
MOVSX EAX,byte ptr [RCX]
SUB EAX,0x30
IMUL EAX,R12D
ADD EAX,EBX
MOVSXD RBX,EAX
MOV ESI,EAX
IMUL RBX,RBX,0x66666667
SAR ESI,0x1f
SAR RBX,0x22
SUB EBX,ESI
MOV ESI,EAX
LEA EDI,[RBX + RBX*0x4]
ADD EDI,EDI
SUB ESI,EDI
ADD ESI,0x30
MOV byte ptr [RCX],SIL
TEST EDX,EDX
JNS 0x00101380
LAB_001013c0:
CMP EAX,0x9
JG 0x001013d2
JMP 0x00101422
LAB_001013d0:
MOV EBX,EBP
LAB_001013d2:
MOVSXD RBP,EBX
MOV EDX,EBX
MOV R8D,EBX
MOV ECX,0x1
IMUL RAX,RBP,0x66666667
SAR EDX,0x1f
XOR ESI,ESI
MOV RDI,R13
SAR RAX,0x22
SUB EAX,EDX
XOR EDX,EDX
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
SUB R8D,EAX
ADD R8D,0x30
MOVZX R8D,R8B
LAB_00101406:
CALL 0x001010f0
IMUL RBP,RBP,0x66666667
MOV EAX,EBX
SAR EAX,0x1f
SAR RBP,0x22
SUB EBP,EAX
CMP EBX,0x9
JG 0x001013d0
LAB_00101422:
ADD R14D,0x1
MOV RDI,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
CMP R15D,R14D
JNZ 0x00101338
LAB_00101439:
LEA RSI,[RDI + RCX*0x1]
CMP RSI,RDI
JZ 0x00101682
LEA RAX,[RCX + -0x1]
CMP RAX,0xe
JBE 0x00101698
LAB_00101454:
MOV R8,RCX
PXOR XMM3,XMM3
PXOR XMM6,XMM6
MOV RAX,RDI
AND R8,-0x10
MOVDQA XMM5,xmmword ptr [0x00102080]
PXOR XMM4,XMM4
LEA RDX,[R8 + RDI*0x1]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101480:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM1,XMM6
MOVDQA XMM7,XMM4
ADD RAX,0x10
PCMPGTB XMM1,XMM0
MOVDQA XMM2,XMM0
PUNPCKLBW XMM2,XMM1
PUNPCKHBW XMM0,XMM1
PADDW XMM2,XMM5
PADDW XMM0,XMM5
PCMPGTW XMM7,XMM2
MOVDQA XMM1,XMM2
PUNPCKLWD XMM1,XMM7
PUNPCKHWD XMM2,XMM7
PADDD XMM1,XMM3
MOVDQA XMM3,XMM0
PADDD XMM1,XMM2
MOVDQA XMM2,XMM4
PCMPGTW XMM2,XMM0
PUNPCKLWD XMM3,XMM2
PUNPCKHWD XMM0,XMM2
PADDD XMM1,XMM3
MOVDQA XMM3,XMM1
PADDD XMM3,XMM0
CMP RDX,RAX
JNZ 0x00101480
MOVDQA XMM0,XMM3
PSRLDQ XMM0,0x8
PADDD XMM0,XMM3
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EBX,XMM0
MOVDQA XMM0,XMM3
PSRLDQ XMM3,0x8
PADDD XMM0,XMM3
CMP RCX,R8
JZ 0x0010162a
LAB_00101519:
SUB RCX,R8
LEA RAX,[RCX + -0x1]
CMP RAX,0x6
JBE 0x001015bd
MOVQ XMM3,qword ptr [RDI + R8*0x1]
PXOR XMM4,XMM4
MOVQ XMM1,qword ptr [0x00102080]
PCMPGTB XMM4,XMM3
MOVDQA XMM2,XMM3
PUNPCKLBW XMM2,XMM4
PUNPCKLBW XMM3,XMM4
PADDW XMM2,XMM1
PSHUFD XMM3,XMM3,0x4e
PADDW XMM1,XMM3
PXOR XMM3,XMM3
MOVDQA XMM4,XMM3
PCMPGTW XMM4,XMM2
MOVDQA XMM5,XMM2
PCMPGTW XMM3,XMM1
PUNPCKLWD XMM5,XMM4
PUNPCKLWD XMM2,XMM4
PADDD XMM0,XMM5
PSHUFD XMM2,XMM2,0x4e
PADDD XMM0,XMM2
MOVDQA XMM2,XMM3
MOVDQA XMM3,XMM1
PUNPCKLWD XMM3,XMM2
PUNPCKLWD XMM1,XMM2
PSHUFD XMM1,XMM1,0x4e
PADDD XMM0,XMM3
PADDD XMM0,XMM1
MOVD EBX,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD EAX,XMM6
ADD EBX,EAX
MOV RAX,RCX
AND RAX,-0x8
ADD RDX,RAX
AND ECX,0x7
JZ 0x0010162a
LAB_001015bd:
MOVSX EAX,byte ptr [RDX]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x1]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x1]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x2]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x2]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x3]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x3]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x4]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x4]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x5]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x5]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LEA RAX,[RDX + 0x6]
CMP RSI,RAX
JZ 0x0010162a
MOVSX EAX,byte ptr [RDX + 0x6]
LEA EBX,[RBX + RAX*0x1 + -0x30]
LAB_0010162a:
MOV RAX,qword ptr [RSP + 0x8]
CMP RDI,RAX
JZ 0x00101642
MOV RAX,qword ptr [RSP + 0x20]
LEA RSI,[RAX + 0x1]
CALL 0x001010b0
LAB_00101642:
MOV RAX,qword ptr [RSP + 0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001016a9
ADD RSP,0x48
MOV EAX,EBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101668:
ADD R14D,0x1
CMP R15D,R14D
JNZ 0x00101439
LEA RSI,[RDI + RCX*0x1]
CMP RDI,RSI
JNZ 0x00101454
LAB_00101682:
XOR EBX,EBX
JMP 0x0010162a
LAB_00101686:
MOV RDX,RAX
LEA RSI,[RSP + 0x21]
MOV RDI,RAX
XOR EBX,EBX
JMP 0x001015bd
LAB_00101698:
MOV RDX,RDI
PXOR XMM0,XMM0
XOR R8D,R8D
XOR EBX,EBX
JMP 0x00101519
LAB_001016a9:
CALL 0x001010c0 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
int func0(int param_1,int param_2)
{
int auVar1 [14];
int auVar2 [12];
unkbyte10 Var3;
int auVar4 [12];
int auVar5 [12];
int auVar6 [14];
int auVar7 [12];
int auVar8 [12];
int auVar9 [12];
unkbyte10 Var10;
int iVar11;
int iVar12;
int (*pauVar13) [16];
char *pcVar14;
ulong uVar15;
ulong uVar16;
int (*pauVar17) [16];
int iVar18;
long in_FS_OFFSET;
short sVar19;
int4 uVar20;
short sVar29;
int iVar21;
short sVar30;
short sVar31;
short sVar32;
short sVar33;
short sVar34;
short sVar35;
short sVar36;
short sVar54;
int iVar37;
short sVar55;
short sVar56;
short sVar57;
short sVar58;
short sVar59;
int auVar39 [16];
int auVar47 [16];
char cVar68;
char cVar69;
int iVar60;
char cVar70;
char cVar71;
char cVar73;
char cVar74;
int iVar72;
int uVar75;
int iVar76;
int auVar61 [16];
int (*local_68) [16];
ulong local_60;
int2 local_58;
int6 uStack_56;
long local_40;
int6 uVar22;
int8 uVar23;
int auVar25 [12];
int auVar24 [12];
int auVar26 [14];
int auVar28 [16];
int auVar27 [16];
int auVar38 [12];
int auVar48 [16];
int auVar49 [16];
int auVar50 [16];
int auVar51 [16];
int auVar52 [16];
int auVar53 [16];
int auVar40 [16];
int auVar41 [16];
int auVar42 [16];
int auVar43 [16];
int auVar46 [16];
int auVar44 [16];
int auVar45 [16];
int auVar62 [16];
int auVar63 [16];
int auVar64 [16];
int auVar65 [16];
int auVar66 [16];
int auVar67 [16];
local_40 = *(long *)(in_FS_OFFSET + 0x28);
local_58 = 0x31;
local_60 = 1;
local_68 = (int (*) [16])&local_58;
if (param_2 < 1) {
pauVar17 = (int (*) [16])((long)&local_58 + 1);
iVar18 = 0;
pauVar13 = (int (*) [16])&local_58;
}
else {
iVar18 = 0;
do {
iVar60 = (int)local_60;
if ((int)(iVar60 - 1U) < 0) {
if (param_2 == iVar18 + 1) {
pauVar17 = (int (*) [16])(*local_68 + local_60);
if (local_68 != pauVar17) goto LAB_00101454;
goto LAB_00101682;
}
break;
}
iVar12 = ((char)(*local_68)[iVar60 - 1U] + -0x30) * param_1;
iVar72 = iVar12 / 10;
(*local_68)[iVar60 - 1U] = (char)iVar12 + (char)iVar72 * -10 + '0';
uVar16 = (ulong)(iVar60 - 2);
if (iVar60 != 1) {
do {
pcVar14 = *local_68 + uVar16;
uVar16 = uVar16 - 1;
iVar12 = (*pcVar14 + -0x30) * param_1 + iVar72;
iVar72 = iVar12 / 10;
*pcVar14 = (char)iVar12 + (char)iVar72 * -10 + '0';
} while (-1 < (int)uVar16);
}
while (iVar60 = iVar72, 9 < iVar12) {
/* try { // try from 00101406 to 0010140a has its CatchHandler @ 001016ae */
std::string::_M_replace_aux((ulong)&local_68,0,0,'\x01');
iVar72 = iVar60 / 10;
iVar12 = iVar60;
}
iVar18 = iVar18 + 1;
} while (param_2 != iVar18);
pauVar17 = (int (*) [16])(*local_68 + local_60);
if (pauVar17 == local_68) {
LAB_00101682:
iVar18 = 0;
goto LAB_0010162a;
}
if (local_60 - 1 < 0xf) {
iVar60 = 0;
iVar72 = 0;
uVar16 = 0;
iVar18 = 0;
pauVar13 = local_68;
}
else {
LAB_00101454:
iVar60 = 0;
iVar72 = 0;
iVar12 = 0;
iVar76 = 0;
uVar16 = local_60 & 0xfffffffffffffff0;
pauVar13 = local_68;
do {
auVar28 = *pauVar13;
pauVar13 = pauVar13 + 1;
auVar45._0_14_ = auVar28._0_14_;
auVar45[0xe] = auVar28[7];
auVar45[0xf] = -(auVar28[7] < '\0');
auVar44._14_2_ = auVar45._14_2_;
auVar44._0_13_ = auVar28._0_13_;
auVar44[0xd] = -(auVar28[6] < '\0');
auVar43._13_3_ = auVar44._13_3_;
auVar43._0_12_ = auVar28._0_12_;
auVar43[0xc] = auVar28[6];
auVar42._12_4_ = auVar43._12_4_;
auVar42._0_11_ = auVar28._0_11_;
auVar42[0xb] = -(auVar28[5] < '\0');
auVar41._11_5_ = auVar42._11_5_;
auVar41._0_10_ = auVar28._0_10_;
auVar41[10] = auVar28[5];
auVar40._10_6_ = auVar41._10_6_;
auVar40._0_9_ = auVar28._0_9_;
auVar40[9] = -(auVar28[4] < '\0');
auVar39._9_7_ = auVar40._9_7_;
auVar39._0_8_ = auVar28._0_8_;
auVar39[8] = auVar28[4];
Var3 = CONCAT91(CONCAT81(auVar39._8_8_,-(auVar28[3] < '\0')),auVar28[3]);
auVar2._2_10_ = Var3;
auVar2[1] = -(auVar28[2] < '\0');
auVar2[0] = auVar28[2];
auVar1._2_12_ = auVar2;
auVar1[1] = -(auVar28[1] < '\0');
auVar1[0] = auVar28[1];
sVar19 = CONCAT11(-(auVar28[8] < '\0'),auVar28[8]);
uVar20 = CONCAT13(-(auVar28[9] < '\0'),CONCAT12(auVar28[9],sVar19));
uVar22 = CONCAT15(-(auVar28[10] < '\0'),CONCAT14(auVar28[10],uVar20));
uVar23 = CONCAT17(-(auVar28[0xb] < '\0'),CONCAT16(auVar28[0xb],uVar22));
auVar24._0_10_ = CONCAT19(-(auVar28[0xc] < '\0'),CONCAT18(auVar28[0xc],uVar23));
auVar24[10] = auVar28[0xd];
auVar24[0xb] = -(auVar28[0xd] < '\0');
auVar26[0xc] = auVar28[0xe];
auVar26._0_12_ = auVar24;
auVar26[0xd] = -(auVar28[0xe] < '\0');
auVar27[0xe] = auVar28[0xf];
auVar27._0_14_ = auVar26;
auVar27[0xf] = -(auVar28[0xf] < '\0');
sVar36 = CONCAT11(-(auVar28[0] < '\0'),auVar28[0]) + (short)DAT_00102080;
sVar54 = auVar1._0_2_ + DAT_00102080._2_2_;
sVar55 = auVar2._0_2_ + DAT_00102080._4_2_;
sVar56 = (short)Var3 + DAT_00102080._6_2_;
sVar57 = auVar39._8_2_ + _UNK_00102088;
sVar58 = auVar41._10_2_ + _UNK_0010208a;
sVar59 = auVar43._12_2_ + _UNK_0010208c;
sVar19 = sVar19 + (short)DAT_00102080;
sVar29 = (short)((uint)uVar20 >> 0x10) + DAT_00102080._2_2_;
sVar30 = (short)((uint6)uVar22 >> 0x20) + DAT_00102080._4_2_;
sVar31 = (short)((ulong)uVar23 >> 0x30) + DAT_00102080._6_2_;
sVar32 = (short)((unkuint10)auVar24._0_10_ >> 0x40) + _UNK_00102088;
sVar33 = auVar24._10_2_ + _UNK_0010208a;
sVar34 = auVar26._12_2_ + _UNK_0010208c;
sVar35 = auVar27._14_2_ + _UNK_0010208e;
iVar18 = CONCAT22(-(ushort)(sVar56 < 0),sVar56);
Var3 = CONCAT64(CONCAT42(iVar18,-(ushort)(sVar55 < 0)),CONCAT22(sVar55,sVar56));
auVar4._4_8_ = (long)((unkuint10)Var3 >> 0x10);
auVar4._2_2_ = -(ushort)(sVar54 < 0);
auVar4._0_2_ = sVar54;
iVar37 = CONCAT22(-(ushort)(sVar57 < 0),sVar57);
auVar38._0_8_ = CONCAT26(-(ushort)(sVar58 < 0),CONCAT24(sVar58,iVar37));
auVar38._8_2_ = sVar59;
auVar38._10_2_ = -(ushort)(sVar59 < 0);
auVar46._12_2_ = auVar44._14_2_ + _UNK_0010208e;
auVar46._0_12_ = auVar38;
auVar46._14_2_ = -(ushort)((short)(auVar44._14_2_ + _UNK_0010208e) < 0);
iVar11 = CONCAT22(-(ushort)(sVar31 < 0),sVar31);
Var10 = CONCAT64(CONCAT42(iVar11,-(ushort)(sVar30 < 0)),CONCAT22(sVar30,sVar31));
auVar5._4_8_ = (long)((unkuint10)Var10 >> 0x10);
auVar5._2_2_ = -(ushort)(sVar29 < 0);
auVar5._0_2_ = sVar29;
iVar21 = CONCAT22(-(ushort)(sVar32 < 0),sVar32);
auVar25._0_8_ = CONCAT26(-(ushort)(sVar33 < 0),CONCAT24(sVar33,iVar21));
auVar25._8_2_ = sVar34;
auVar25._10_2_ = -(ushort)(sVar34 < 0);
auVar28._12_2_ = sVar35;
auVar28._0_12_ = auVar25;
auVar28._14_2_ = -(ushort)(sVar35 < 0);
iVar60 = CONCAT22(-(ushort)(sVar36 < 0),sVar36) + iVar60 + iVar37 +
CONCAT22(-(ushort)(sVar19 < 0),sVar19) + iVar21;
iVar72 = auVar4._0_4_ + iVar72 + (int)((ulong)auVar38._0_8_ >> 0x20) + auVar5._0_4_ +
(int)((ulong)auVar25._0_8_ >> 0x20);
iVar12 = (int)((unkuint10)Var3 >> 0x10) + iVar12 + auVar38._8_4_ +
(int)((unkuint10)Var10 >> 0x10) + auVar25._8_4_;
iVar76 = iVar18 + iVar76 + auVar46._12_4_ + iVar11 + auVar28._12_4_;
} while ((int (*) [16])(*local_68 + uVar16) != pauVar13);
iVar18 = iVar12 + iVar60 + iVar76 + iVar72;
iVar60 = iVar60 + iVar12;
iVar72 = iVar72 + iVar76;
pauVar13 = (int (*) [16])(*local_68 + uVar16);
if (local_60 == uVar16) goto LAB_0010162a;
}
uVar15 = local_60 - uVar16;
if (6 < uVar15 - 1) {
uVar16 = *(ulong *)(*local_68 + uVar16);
cVar68 = (char)(uVar16 >> 8);
cVar69 = (char)(uVar16 >> 0x10);
cVar70 = (char)(uVar16 >> 0x18);
cVar71 = (char)(uVar16 >> 0x20);
cVar73 = (char)(uVar16 >> 0x28);
cVar74 = (char)(uVar16 >> 0x30);
uVar75 = (int)(uVar16 >> 0x38);
auVar53._8_6_ = 0;
auVar53._0_8_ = uVar16;
auVar53[0xe] = uVar75;
auVar53[0xf] = -((long)uVar16 < 0);
auVar52._14_2_ = auVar53._14_2_;
auVar52._8_5_ = 0;
auVar52._0_8_ = uVar16;
auVar52[0xd] = -(cVar74 < '\0');
auVar51._13_3_ = auVar52._13_3_;
auVar51._8_4_ = 0;
auVar51._0_8_ = uVar16;
auVar51[0xc] = cVar74;
auVar50._12_4_ = auVar51._12_4_;
auVar50._8_3_ = 0;
auVar50._0_8_ = uVar16;
auVar50[0xb] = -(cVar73 < '\0');
auVar49._11_5_ = auVar50._11_5_;
auVar49._8_2_ = 0;
auVar49._0_8_ = uVar16;
auVar49[10] = cVar73;
auVar48._10_6_ = auVar49._10_6_;
auVar48[8] = 0;
auVar48._0_8_ = uVar16;
auVar48[9] = -(cVar71 < '\0');
auVar47._9_7_ = auVar48._9_7_;
auVar47[8] = cVar71;
auVar47._0_8_ = uVar16;
Var3 = CONCAT91(CONCAT81(auVar47._8_8_,-(cVar70 < '\0')),cVar70);
auVar7._2_10_ = Var3;
auVar7[1] = -(cVar69 < '\0');
auVar7[0] = cVar69;
auVar6._2_12_ = auVar7;
auVar6[1] = -(cVar68 < '\0');
auVar6[0] = cVar68;
auVar67._8_6_ = 0;
auVar67._0_8_ = uVar16;
auVar67[0xe] = uVar75;
auVar67[0xf] = -((long)uVar16 < 0);
auVar66._14_2_ = auVar67._14_2_;
auVar66._8_5_ = 0;
auVar66._0_8_ = uVar16;
auVar66[0xd] = -(cVar74 < '\0');
auVar65._13_3_ = auVar66._13_3_;
auVar65._8_4_ = 0;
auVar65._0_8_ = uVar16;
auVar65[0xc] = cVar74;
auVar64._12_4_ = auVar65._12_4_;
auVar64._8_3_ = 0;
auVar64._0_8_ = uVar16;
auVar64[0xb] = -(cVar73 < '\0');
auVar63._11_5_ = auVar64._11_5_;
auVar63._8_2_ = 0;
auVar63._0_8_ = uVar16;
auVar63[10] = cVar73;
auVar62._10_6_ = auVar63._10_6_;
auVar62[8] = 0;
auVar62._0_8_ = uVar16;
auVar62[9] = -(cVar71 < '\0');
auVar61._9_7_ = auVar62._9_7_;
auVar61[8] = cVar71;
auVar61._0_8_ = uVar16;
sVar32 = CONCAT11(-((char)uVar16 < '\0'),(char)uVar16) + (short)DAT_00102080;
sVar33 = auVar6._0_2_ + DAT_00102080._2_2_;
sVar34 = auVar7._0_2_ + DAT_00102080._4_2_;
sVar35 = (short)Var3 + DAT_00102080._6_2_;
sVar19 = (short)DAT_00102080 + auVar61._8_2_;
sVar29 = DAT_00102080._2_2_ + auVar63._10_2_;
sVar30 = DAT_00102080._4_2_ + auVar65._12_2_;
sVar31 = DAT_00102080._6_2_ + auVar66._14_2_;
auVar8._4_8_ = (long)(((unkuint10)
(uint6)(((unkuint10)CONCAT22(-(ushort)(sVar35 < 0),sVar35) << 0x30) >>
0x20) << 0x20) >> 0x10);
auVar8._2_2_ = -(ushort)(sVar33 < 0);
auVar8._0_2_ = sVar33;
iVar18 = CONCAT22(-(ushort)(sVar35 < 0),sVar35);
auVar9._4_8_ = (long)(((unkuint10)
(uint6)(((unkuint10)CONCAT22(-(ushort)(sVar31 < 0),sVar31) << 0x30) >>
0x20) << 0x20) >> 0x10);
auVar9._2_2_ = -(ushort)(sVar29 < 0);
auVar9._0_2_ = sVar29;
iVar12 = CONCAT22(-(ushort)(sVar31 < 0),sVar31);
iVar18 = iVar60 + CONCAT22(-(ushort)(sVar32 < 0),sVar32) +
(int)(CONCAT64(CONCAT42(iVar18,-(ushort)(sVar34 < 0)),CONCAT22(sVar34,sVar35)) >>
0x10) + CONCAT22(-(ushort)(sVar19 < 0),sVar19) +
(int)(CONCAT64(CONCAT42(iVar12,-(ushort)(sVar30 < 0)),CONCAT22(sVar30,sVar31)) >>
0x10) + iVar72 + auVar8._0_4_ + iVar18 + auVar9._0_4_ + iVar12;
pauVar13 = (int (*) [16])(*pauVar13 + (uVar15 & 0xfffffffffffffff8));
if ((uVar15 & 7) == 0) goto LAB_0010162a;
}
}
iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[0];
if ((((pauVar17 != (int (*) [16])(*pauVar13 + 1)) &&
(iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[1],
pauVar17 != (int (*) [16])(*pauVar13 + 2))) &&
(iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[2],
pauVar17 != (int (*) [16])(*pauVar13 + 3))) &&
(((iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[3],
pauVar17 != (int (*) [16])(*pauVar13 + 4) &&
(iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[4],
pauVar17 != (int (*) [16])(*pauVar13 + 5))) &&
(iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[5],
pauVar17 != (int (*) [16])(*pauVar13 + 6))))) {
iVar18 = iVar18 + -0x30 + (int)(char)(*pauVar13)[6];
}
LAB_0010162a:
if (local_68 != (int (*) [16])&local_58) {
operator_delete(local_68,CONCAT62(uStack_56,local_58) + 1);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return iVar18;
} |
2,896 | func0 |
#include <iostream>
#include <string>
#include <vector>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text1) {
std::regex pattern(R"(\"([^\"]*)\")");
std::smatch matches;
std::vector<std::string> results;
std::string::const_iterator searchStart(text1.cbegin());
while (regex_search(searchStart, text1.cend(), matches, pattern)) {
results.push_back(matches[1]);
searchStart = matches.suffix().first;
}
return results;
}
| int main() {
std::vector<std::string> result1 = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"");
assert((result1[0] == "A53" && result1[1] == "multi" && result1[2] == "Processor"));
std::vector<std::string> result2 = func0("Cast your \"favorite\" entertainment \"apps\"");
assert((result2[0] == "favorite" && result2[1] == "apps"));
std::vector<std::string> result3 = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support");
assert((result3[0] == "4k Ultra HD" && result3[1] == "HDR 10"));
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 $0x98,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x80(%rbp),%rax
mov $0x10,%edx
lea 0x2c3c3(%rip),%rsi
mov %rax,%rdi
callq 73be <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1EPKcNSt15regex_constants18syntax_option_typeE>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 747c <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC1Ev>
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 7154 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC1Ev>
mov -0xa0(%rbp),%rax
mov %rax,%rdi
callq 56f0 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6cbeginEv@plt>
mov %rax,-0x88(%rbp)
mov -0xa0(%rbp),%rax
mov %rax,%rdi
callq 5650 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4cendEv@plt>
mov %rax,%rsi
lea -0x80(%rbp),%rcx
lea -0x60(%rbp),%rdx
mov -0x88(%rbp),%rax
mov $0x0,%r8d
mov %rax,%rdi
callq 760c <_ZSt12regex_searchIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS4_9sub_matchISA_EEEcNS4_12regex_traitsIcEEEbT_SG_RNS4_13match_resultsISG_T0_EERKNS4_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5d92 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x109>
lea -0x60(%rbp),%rax
mov $0x1,%esi
mov %rax,%rdi
callq 764c <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEixEm>
mov %rax,%rdx
lea -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 7696 <_ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEEcvS9_Ev>
lea -0x40(%rbp),%rdx
mov -0x98(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 76e6 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 771c <_ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE6suffixEv>
mov (%rax),%rax
mov %rax,-0x88(%rbp)
jmpq 5cff <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x76>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 70f4 <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED1Ev>
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 7448 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5e10 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x187>
jmp 5e0b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x182>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 57c0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
jmp 5dd9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
endbr64
mov %rax,%rbx
mov -0x98(%rbp),%rax
mov %rax,%rdi
callq 75c4 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 70f4 <_ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED1Ev>
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 7448 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5b10 <_Unwind_Resume@plt>
callq 5970 <__stack_chk_fail@plt>
mov -0x98(%rbp),%rax
add $0x98,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov edx, 10h
lea rcx, asc_33051; "\\\"([^\\\"]*)\\\""
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)
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEC2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(void)
mov rax, [rbp+var_98]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov rax, [rbp+var_A0]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6cbeginEv; std::string::cbegin(void)
mov [rbp+var_88], rax
jmp short loc_4BFF
loc_4BA4:
lea rax, [rbp+var_60]
mov esi, 1
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEEixEm; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator[](ulong)
mov rdx, rax
lea rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEEEcvS9_Ev; std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator std::string(void)
lea rdx, [rbp+var_40]
mov rax, [rbp+var_98]
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_60]
mov rdi, rax
call _ZNKSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEE6suffixEv; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::suffix(void)
mov rax, [rax]
mov [rbp+var_88], rax
loc_4BFF:
mov rax, [rbp+var_A0]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4cendEv; std::string::cend(void)
mov rsi, rax
lea rcx, [rbp+var_80]
lea rdx, [rbp+var_60]
mov rax, [rbp+var_88]
mov r8d, 0
mov rdi, rax
call _ZSt12regex_searchIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS4_9sub_matchISA_EEEcNS4_12regex_traitsIcEEEbT_SG_RNS4_13match_resultsISG_T0_EERKNS4_11basic_regexIT1_T2_EENSt15regex_constants15match_flag_typeE; std::regex_search<__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)
test al, al
jnz loc_4BA4
nop
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
lea rax, [rbp+var_80]
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 short loc_4CC8
jmp short loc_4CC3
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_4C7D
endbr64
mov rbx, rax
loc_4C7D:
mov rax, [rbp+var_98]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rax, [rbp+var_60]
mov rdi, rax
call _ZNSt7__cxx1113match_resultsIN9__gnu_cxx17__normal_iteratorIPKcNS_12basic_stringIcSt11char_traitsIcESaIcEEEEESaINS_9sub_matchISA_EEEED2Ev; std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results()
lea rax, [rbp+var_80]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4CBB
call ___stack_chk_fail
loc_4CBB:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4CC3:
call ___stack_chk_fail
loc_4CC8:
mov rax, [rbp+var_98]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long i; // [rsp+18h] [rbp-88h]
_BYTE v6[32]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+40h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+60h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+88h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v6, "\\\"([^\\\"]*)\\\"", 16LL);
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::match_results(v7);
std::vector<std::string>::vector(a1);
for ( i = std::string::cbegin(a2);
;
i = *(_QWORD *)std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::suffix(v7) )
{
v3 = std::string::cend(a2);
if ( !(unsigned __int8)std::regex_search<__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>>(
i,
v3,
v7,
v6,
0LL) )
break;
v2 = std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator[](v7, 1LL);
std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>::operator std::string(v8, v2);
std::vector<std::string>::push_back(a1, v8);
std::string::~string(v8);
}
std::match_results<__gnu_cxx::__normal_iterator<char const*,std::string>>::~match_results(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,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV EDX,0x10
LEA RCX,[0x133051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b6c:
CALL 0x00106400
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x001064d2
MOV RAX,qword ptr [RBP + -0x98]
MOV RDI,RAX
CALL 0x00106102
MOV RAX,qword ptr [RBP + -0xa0]
MOV RDI,RAX
CALL 0x00104610
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00104bff
LAB_00104ba4:
LEA RAX,[RBP + -0x60]
MOV ESI,0x1
MOV RDI,RAX
LAB_00104bb0:
CALL 0x001066ba
MOV RDX,RAX
LEA RAX,[RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010672e
LEA RDX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x98]
MOV RSI,RDX
MOV RDI,RAX
LAB_00104bd8:
CALL 0x0010677e
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001046e0
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
LAB_00104bf0:
CALL 0x001067b4
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x88],RAX
LAB_00104bff:
MOV RAX,qword ptr [RBP + -0xa0]
MOV RDI,RAX
CALL 0x00104590
MOV RSI,RAX
LEA RCX,[RBP + -0x80]
LEA RDX,[RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x88]
MOV R8D,0x0
MOV RDI,RAX
CALL 0x0010666a
TEST AL,AL
JNZ 0x00104ba4
NOP
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x0010609a
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x0010649e
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104cc8
JMP 0x00104cc3
LAB_00104cc3:
CALL 0x00104870
LAB_00104cc8:
MOV RAX,qword ptr [RBP + -0x98]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
__normal_iterator _Var2;
int8 uVar3;
int8 *puVar4;
long in_FS_OFFSET;
int8 local_90;
regex local_88 [32];
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_68 [32];
sub_match local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_88,"\\\"([^\\\"]*)\\\"",0x10);
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::match_results(local_68);
std::vector<std::string,std::allocator<std::string>>::vector
((vector<std::string,std::allocator<std::string>> *)param_1);
local_90 = std::string::cbegin();
while( true ) {
_Var2 = std::string::cend();
bVar1 = std::
regex_search<__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_90,_Var2,(match_results *)local_68,local_88,0);
if (!bVar1) break;
/* try { // try from 00104bb0 to 00104bc6 has its CatchHandler @ 00104c76 */
uVar3 = std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator[](local_68,1);
std::sub_match::operator_cast_to_string(local_48,uVar3);
/* try { // try from 00104bd8 to 00104bdc has its CatchHandler @ 00104c61 */
std::vector<std::string,std::allocator<std::string>>::push_back
((vector<std::string,std::allocator<std::string>> *)param_1,(string *)local_48);
std::string::~string((string *)local_48);
/* try { // try from 00104bf0 to 00104c2d has its CatchHandler @ 00104c76 */
puVar4 = (int8 *)
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::suffix(local_68);
local_90 = *puVar4;
}
std::
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~match_results(local_68);
std::regex::~basic_regex(local_88);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,897 | func0 |
#include <iostream>
#include <string>
#include <vector>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text1) {
std::regex pattern(R"(\"([^\"]*)\")");
std::smatch matches;
std::vector<std::string> results;
std::string::const_iterator searchStart(text1.cbegin());
while (regex_search(searchStart, text1.cend(), matches, pattern)) {
results.push_back(matches[1]);
searchStart = matches.suffix().first;
}
return results;
}
| int main() {
std::vector<std::string> result1 = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"");
assert((result1[0] == "A53" && result1[1] == "multi" && result1[2] == "Processor"));
std::vector<std::string> result2 = func0("Cast your \"favorite\" entertainment \"apps\"");
assert((result2[0] == "favorite" && result2[1] == "apps"));
std::vector<std::string> result3 = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support");
assert((result3[0] == "4k Ultra HD" && result3[1] == "HDR 10"));
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1f0,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
lea 0x30(%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 0x50(%rsp),%rdi
mov 0x10(%rsp),%r8d
mov %r12,%rcx
lea 0x14e2d(%rip),%rdx
lea -0xc(%rdx),%rsi
callq 17f9a <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x150(%rsp),%rax
mov %rax,0x20(%rsp)
mov 0x158(%rsp),%rax
movq $0x0,0x158(%rsp)
mov %rax,0x28(%rsp)
movq $0x0,0x150(%rsp)
lea 0x180(%rsp),%rdi
callq 6a16 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x160(%rsp),%rdi
lea 0x170(%rsp),%rax
cmp %rax,%rdi
je 48f0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xc7>
callq 4570 <_ZdlPv@plt>
mov 0x158(%rsp),%r12
test %r12,%r12
je 4920 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf7>
cmpq $0x0,0x1b6c3(%rip)
je 4992 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x169>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r12)
cmp $0x1,%eax
je 49a4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x17b>
mov 0x120(%rsp),%rdi
lea 0x130(%rsp),%rax
cmp %rax,%rdi
je 493a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x111>
callq 4570 <_ZdlPv@plt>
lea 0x30(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,(%rbx)
movq $0x0,0x8(%rbx)
movq $0x0,0x10(%rbx)
mov 0x0(%rbp),%rdi
movabs $0xaaaaaaaaaaaaaaab,%r12
jmpq 4b9a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x371>
mov 0x8(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r12)
jmpq 4917 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xee>
mov (%r12),%rax
mov %r12,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1b612(%rip)
je 49dc <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b3>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r12)
cmp $0x1,%eax
jne 4920 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf7>
mov (%r12),%rax
mov %r12,%rdi
callq *0x18(%rax)
jmpq 4920 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf7>
mov 0xc(%r12),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r12)
jmp 49c4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19b>
endbr64
mov %rax,%rbx
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x30(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov %rbx,%rdi
callq 46c0 <_Unwind_Resume@plt>
test %al,%al
je 4bbc <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x393>
mov 0x38(%rsp),%rcx
mov 0x30(%rsp),%rax
cmp %rax,%rcx
je 4a41 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x218>
mov %rcx,%rdx
sub %rax,%rdx
sar $0x3,%rdx
imul %r12,%rdx
sub $0x3,%rdx
add $0x18,%rax
cmp $0x1,%rdx
ja 4a45 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x21c>
lea -0x48(%rcx),%rax
cmpb $0x0,0x10(%rax)
jne 4ad6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2ad>
lea 0x60(%rsp),%rax
mov %rax,0x50(%rsp)
movq $0x0,0x58(%rsp)
movb $0x0,0x60(%rsp)
mov 0x8(%rbx),%rsi
cmp 0x10(%rbx),%rsi
je 4b69 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x340>
lea 0x10(%rsi),%rax
mov %rax,(%rsi)
mov 0x50(%rsp),%rax
lea 0x60(%rsp),%rdx
cmp %rdx,%rax
je 4b5a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x331>
mov %rax,(%rsi)
mov 0x60(%rsp),%rax
mov %rax,0x10(%rsi)
mov 0x58(%rsp),%rax
mov %rax,0x8(%rsi)
addq $0x20,0x8(%rbx)
mov 0x38(%rsp),%rax
mov 0x30(%rsp),%rdx
cmp %rdx,%rax
je 4b93 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x36a>
mov %rax,%rcx
sub %rdx,%rcx
cmp $0x48,%rcx
je 4b93 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x36a>
lea -0x18(%rdx,%rcx,1),%rax
jmpq 4b97 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x36e>
mov (%rax),%r14
mov 0x8(%rax),%r13
lea 0x60(%rsp),%rax
mov %rax,0x50(%rsp)
sub %r14,%r13
mov %r13,0x8(%rsp)
cmp $0xf,%r13
ja 4b1b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2f2>
cmp $0x1,%r13
jne 4b4e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x325>
movzbl (%r14),%eax
mov %al,0x60(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0x58(%rsp)
mov 0x50(%rsp),%rdx
movb $0x0,(%rdx,%rax,1)
jmpq 4a67 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x23e>
lea 0x8(%rsp),%rsi
lea 0x50(%rsp),%rdi
mov $0x0,%edx
callq 46d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,%rdi
mov %rax,0x50(%rsp)
mov 0x8(%rsp),%rax
mov %rax,0x60(%rsp)
mov %r13,%rdx
mov %r14,%rsi
callq 4540 <memcpy@plt>
jmp 4b03 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2da>
test %r13,%r13
je 4b03 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2da>
lea 0x60(%rsp),%rdi
jmp 4b41 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x318>
movdqa 0x60(%rsp),%xmm0
movups %xmm0,0x10(%rsi)
jmpq 4a9b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x272>
lea 0x50(%rsp),%rdx
mov %rbx,%rdi
callq 5c9e <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_>
mov 0x50(%rsp),%rdi
lea 0x60(%rsp),%rax
cmp %rax,%rdi
je 4aa9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x280>
callq 4570 <_ZdlPv@plt>
jmpq 4aa9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x280>
lea -0x48(%rax),%rax
mov (%rax),%rdi
mov 0x8(%rbp),%rsi
add 0x0(%rbp),%rsi
lea 0x10(%rsp),%rcx
lea 0x30(%rsp),%rdx
mov $0x0,%r8d
callq 990f <_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>
jmpq 4a0e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1e5>
mov 0x30(%rsp),%rdi
test %rdi,%rdi
je 4bcb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3a2>
callq 4570 <_ZdlPv@plt>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4bee <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c5>
cmpq $0x0,0x1b3eb(%rip)
je 4c22 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3f9>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4c2d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x404>
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x1e8(%rsp),%rax
xor %fs:0x28,%rax
jne 4cb4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x48b>
mov %rbx,%rax
add $0x1f0,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmp 4be9 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1b389(%rip)
je 4c5c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x433>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4bee <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c5>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 4bee <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c5>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4c4b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x422>
endbr64
mov %rax,%rbp
mov 0x50(%rsp),%rdi
lea 0x60(%rsp),%rax
cmp %rax,%rdi
je 4c82 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x459>
callq 4570 <_ZdlPv@plt>
mov %rbx,%rdi
callq 5b80 <_ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED1Ev>
mov 0x30(%rsp),%rdi
test %rdi,%rdi
je 4c99 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x470>
callq 4570 <_ZdlPv@plt>
lea 0x10(%rsp),%rdi
callq 5afc <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbp,%rdi
callq 46c0 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbp
jmp 4c82 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x459>
callq 45d0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1F8h
mov rbx, rdi
mov r15, rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea r12, [rbp+var_208]
mov rdi, r12; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_200], 0
mov [rbp+var_1F8], 0
lea rdi, [rbp+var_1D0]
mov r8d, 10h
mov rcx, r12
lea rdx, asc_1973F+0Ch; ""
lea rsi, [rdx-0Ch]
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_D0]
mov rax, [rbp+var_C8]
mov [rbp+var_C8], 0
mov [rbp+var_D0], 0
mov [rbp+var_200], rdx
mov rdi, [rbp+var_1F8]
mov [rbp+var_1F8], rax
test rdi, rdi
jz short loc_489E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_489E:
mov [rbp+var_210], 10h
lea rdi, [rbp+var_A0]
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_48D7
mov rax, [rbp+var_B0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48D7:
mov r12, [rbp+var_C8]
test r12, r12
jz short loc_4923
lea rcx, [r12+8]
mov rdx, [r12+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_499B
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_49C6
mov eax, [r12+8]
lea edx, [rax-1]
mov [r12+8], edx
loc_491A:
cmp eax, 1
jz loc_49D4
loc_4923:
mov rdi, [rbp+var_100]; void *
lea rax, [rbp+var_F0]
cmp rdi, rax
jz short loc_4946
mov rax, [rbp+var_F0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4946:
mov [rbp+var_1F0], 0
mov [rbp+var_1E8], 0
mov [rbp+var_1E0], 0
mov [rbp+var_1D8], 0
mov qword ptr [rbx], 0
mov qword ptr [rbx+8], 0
mov qword ptr [rbx+10h], 0
mov rdi, [r15]
mov r12, 0AAAAAAAAAAAAAAABh
jmp loc_4BCE
loc_499B:
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_4923
loc_49C6:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_491A
loc_49D4:
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_4923
endbr64
mov rbx, rax
mov rdi, [rbp+var_1F8]
test rdi, rdi
jz short loc_49F9
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_49F9:
lea rdi, [rbp+var_208]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jz short loc_4A19
call ___stack_chk_fail
loc_4A19:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_4A21:
mov r14, [rax]
mov r13, [rax+8]
lea rax, [rbp+var_1C0]
mov [rbp+var_1D0], rax
mov [rbp+var_1C8], 0
sub r13, r14
mov [rbp+var_218], r13
cmp r13, 0Fh
ja short loc_4A7F
cmp r13, 1
jnz short loc_4ABC
movzx eax, byte ptr [r14]
mov byte ptr [rbp+var_1C0], al
loc_4A61:
mov rax, [rbp+var_218]
mov [rbp+var_1C8], rax
mov rdx, [rbp+var_1D0]
mov byte ptr [rdx+rax], 0
jmp loc_4C63
loc_4A7F:
lea rsi, [rbp+var_218]
lea rdi, [rbp+var_1D0]
mov edx, 0
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov rdi, rax; dest
mov [rbp+var_1D0], rax
mov rax, [rbp+var_218]
mov [rbp+var_1C0], rax
loc_4AAF:
mov rdx, r13; n
mov rsi, r14; src
call _memcpy
jmp short loc_4A61
loc_4ABC:
test r13, r13
jz short loc_4A61
lea rdi, [rbp+var_1C0]
jmp short loc_4AAF
loc_4ACA:
mov rax, [rbp+var_1C8]
add rax, 1
cmp eax, 8
jnb short loc_4B22
test al, 4
jnz short loc_4B0A
test eax, eax
jz loc_4C9D
movzx edi, byte ptr [rbp+var_1C0]
mov [rsi+10h], dil
test al, 2
jz loc_4C9D
mov eax, eax
movzx ecx, word ptr [rcx+rax-2]
mov [rdx+rax-2], cx
jmp loc_4C9D
loc_4B0A:
mov edi, dword ptr [rbp+var_1C0]
mov [rsi+10h], edi
mov eax, eax
mov ecx, [rcx+rax-4]
mov [rdx+rax-4], ecx
jmp loc_4C9D
loc_4B22:
mov rdi, [rbp+var_1C0]
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_4C9D
and eax, 0FFFFFFF8h
mov edx, 0
loc_4B5D:
mov edi, edx
mov r9, [rcx+rdi]
mov [r8+rdi], r9
add edx, 8
cmp edx, eax
jb short loc_4B5D
jmp loc_4C9D
loc_4B73:
lea rdx, [rbp+var_1D0]
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 *
lea rax, [rbp+var_1C0]
cmp rdi, rax
jz short loc_4BA5
mov rax, [rbp+var_1C0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4BA5:
mov rdx, [rbp+var_1F0]
mov rax, [rbp+var_1E8]
sub rax, rdx
lea rcx, [rdx+rax-18h]
lea rdx, [rdx+rax-48h]
cmp rax, 49h ; 'I'
mov rax, rcx
cmovb rax, rdx
mov rdi, [rax]
loc_4BCE:
mov rsi, [r15+8]
add rsi, [r15]
lea rcx, [rbp+var_210]
lea rdx, [rbp+var_1F0]
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)
add rsp, 10h
test al, al
jz loc_4CB2
mov rcx, [rbp+var_1E8]
mov rax, [rbp+var_1F0]
cmp rcx, rax
jz short loc_4C35
mov rdx, rcx
sub rdx, rax
sar rdx, 3
imul rdx, r12
sub rdx, 3
add rax, 18h
cmp rdx, 1
ja short loc_4C39
loc_4C35:
lea rax, [rcx-48h]
loc_4C39:
cmp byte ptr [rax+10h], 0
jnz loc_4A21
lea rax, [rbp+var_1C0]
mov [rbp+var_1D0], rax
mov [rbp+var_1C8], 0
mov byte ptr [rbp+var_1C0], 0
loc_4C63:
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jz loc_4B73
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rbp+var_1D0]
lea rcx, [rbp+var_1C0]
cmp rax, rcx
jz loc_4ACA
mov [rsi], rax
mov rax, [rbp+var_1C0]
mov [rsi+10h], rax
loc_4C9D:
mov rax, [rbp+var_1C8]
mov [rsi+8], rax
add qword ptr [rbx+8], 20h ; ' '
jmp loc_4BA5
loc_4CB2:
mov rdi, [rbp+var_1F0]; void *
test rdi, rdi
jz short loc_4CCD
mov rsi, [rbp+var_1E0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4CCD:
mov rax, [rbp+var_1F8]
mov rdi, rax
test rax, rax
jz short loc_4D0A
lea rcx, [rax+8]
mov rdx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_4D3B
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz short loc_4D5D
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4D05:
cmp eax, 1
jz short loc_4D68
loc_4D0A:
lea rdi, [rbp+var_208]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_4DC7
mov rax, rbx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4D3B:
mov r14, rdi
mov dword ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 0
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, r14
mov rax, [r14]
call qword ptr [rax+18h]
jmp short loc_4D0A
loc_4D5D:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp short loc_4D05
loc_4D68:
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 short loc_4D0A
endbr64
mov r14, rax
lea rdi, [rbp+var_1D0]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
loc_4D82:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
lea rdi, [rbp+var_1F0]
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_210]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, [rbp+var_38]
sub rax, fs:28h
jz short loc_4DBF
call ___stack_chk_fail
endbr64
mov r14, rax
jmp short loc_4D82
loc_4DBF:
mov rdi, r14; struct _Unwind_Exception *
call __Unwind_Resume
loc_4DC7:
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; // rdi
_DWORD *v8; // r12
volatile signed __int32 *v9; // rcx
long long v10; // rdx
signed __int32 v11; // eax
long long i; // rdi
_BYTE *v13; // r14
long long v14; // r13
size_t v15; // r13
void **v16; // rdi
unsigned int v17; // eax
unsigned long long v18; // r8
char *v19; // rdx
char *v20; // rcx
unsigned int v21; // eax
unsigned int v22; // eax
unsigned int v23; // edx
long long *v24; // rax
long long v25; // rsi
char *v26; // rax
void **v27; // rsi
_QWORD *v28; // rdx
_DWORD *v29; // rdi
volatile signed __int32 *v30; // rcx
long long v31; // rdx
signed __int32 v32; // eax
char v34; // [rsp-8h] [rbp-228h]
int v35; // [rsp+0h] [rbp-220h]
size_t v36; // [rsp+8h] [rbp-218h] BYREF
int v37; // [rsp+10h] [rbp-210h] BYREF
int v38; // [rsp+18h] [rbp-208h] BYREF
long long v39; // [rsp+20h] [rbp-200h]
long long v40; // [rsp+28h] [rbp-1F8h]
void *v41; // [rsp+30h] [rbp-1F0h] BYREF
_BYTE *v42; // [rsp+38h] [rbp-1E8h]
long long v43; // [rsp+40h] [rbp-1E0h]
long long v44; // [rsp+48h] [rbp-1D8h]
void *v45; // [rsp+50h] [rbp-1D0h] BYREF
void *v46; // [rsp+58h] [rbp-1C8h]
void *v47; // [rsp+60h] [rbp-1C0h] BYREF
int v48; // [rsp+68h] [rbp-1B8h]
int v49; // [rsp+70h] [rbp-1B0h]
int v50; // [rsp+78h] [rbp-1A8h]
int v51; // [rsp+80h] [rbp-1A0h]
int v52; // [rsp+88h] [rbp-198h]
long long v53; // [rsp+90h] [rbp-190h]
void *v54; // [rsp+120h] [rbp-100h]
long long v55; // [rsp+130h] [rbp-F0h] BYREF
long long v56; // [rsp+150h] [rbp-D0h]
long long v57; // [rsp+158h] [rbp-C8h]
void *v58; // [rsp+160h] [rbp-C0h]
long long v59; // [rsp+170h] [rbp-B0h] BYREF
char v60[104]; // [rsp+180h] [rbp-A0h] BYREF
unsigned long long v61; // [rsp+1E8h] [rbp-38h]
v61 = __readfsqword(0x28u);
std::locale::locale((std::locale *)&v38);
v39 = 0LL;
v40 = 0LL;
v4 = "\\\"([^\\\"]*)\\\"";
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v45, "\\\"([^\\\"]*)\\\"", "", &v38, 16LL);
v5 = v56;
v6 = v57;
v57 = 0LL;
v56 = 0LL;
v39 = v5;
v7 = v40;
v40 = v6;
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v37 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v60);
if ( v58 != &v59 )
{
v4 = (char *)(v59 + 1);
operator delete(v58, v59 + 1);
}
v8 = (_DWORD *)v57;
if ( v57 )
{
v9 = (volatile signed __int32 *)(v57 + 8);
v10 = *(_QWORD *)(v57 + 8);
if ( v10 == 0x100000001LL )
{
*(_DWORD *)(v57 + 8) = 0;
v8[3] = 0;
(*(void ( **)(_DWORD *, char *, long long, volatile signed __int32 *))(*(_QWORD *)v8 + 16LL))(
v8,
v4,
0x100000001LL,
v9);
(*(void ( **)(_DWORD *))(*(_QWORD *)v8 + 24LL))(v8);
}
else
{
if ( _libc_single_threaded )
{
v11 = *(_DWORD *)(v57 + 8);
v10 = (unsigned int)(v11 - 1);
*(_DWORD *)(v57 + 8) = v10;
}
else
{
v11 = _InterlockedExchangeAdd(v9, 0xFFFFFFFF);
}
if ( v11 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v8, v4, v10, v9);
}
}
if ( v54 != &v55 )
operator delete(v54, v55 + 1);
v41 = 0LL;
v42 = 0LL;
v43 = 0LL;
v44 = 0LL;
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
for ( i = *a2; ; i = *v24 )
{
v25 = *a2 + a2[1];
if ( !(unsigned __int8)std::__detail::__regex_algo_impl<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,char,std::regex_traits<char>>(
i,
v25,
(unsigned int)&v41,
(unsigned int)&v37,
0,
0,
0,
v34,
v35,
v36,
v37,
v38,
v39,
v40,
(_DWORD)v41,
(_DWORD)v42,
v43,
v44,
(_DWORD)v45,
(_DWORD)v46,
(_DWORD)v47,
v48,
v49,
v50,
v51,
v52,
v53) )
break;
if ( v42 == v41 || (v26 = (char *)v41 + 24, 0xAAAAAAAAAAAAAAABLL * ((v42 - (_BYTE *)v41) >> 3) - 3 <= 1) )
v26 = v42 - 72;
if ( v26[16] )
{
v13 = *(_BYTE **)v26;
v14 = *((_QWORD *)v26 + 1);
v45 = &v47;
v46 = 0LL;
v15 = v14 - (_QWORD)v13;
v36 = v15;
if ( v15 > 0xF )
{
v16 = (void **)std::string::_M_create(&v45, &v36, 0LL);
v45 = v16;
v47 = (void *)v36;
}
else
{
if ( v15 == 1 )
{
LOBYTE(v47) = *v13;
LABEL_19:
v46 = (void *)v36;
*((_BYTE *)v45 + v36) = 0;
goto LABEL_45;
}
if ( !v15 )
goto LABEL_19;
v16 = &v47;
}
memcpy(v16, v13, v15);
goto LABEL_19;
}
v45 = &v47;
v46 = 0LL;
LOBYTE(v47) = 0;
LABEL_45:
v27 = (void **)a1[1];
if ( v27 == (void **)a1[2] )
{
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v27, &v45);
if ( v45 != &v47 )
operator delete(v45, (unsigned long long)v47 + 1);
}
else
{
v28 = v27 + 2;
*v27 = v27 + 2;
if ( v45 == &v47 )
{
v17 = (_DWORD)v46 + 1;
if ( (unsigned int)((_DWORD)v46 + 1) >= 8 )
{
v27[2] = v47;
*(_QWORD *)((char *)v28 + v17 - 8) = *(void **)((char *)&v46 + v17);
v18 = (unsigned long long)(v27 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v19 = (char *)v28 - v18;
v20 = (char *)((char *)&v47 - v19);
v21 = ((_DWORD)v19 + v17) & 0xFFFFFFF8;
if ( v21 >= 8 )
{
v22 = v21 & 0xFFFFFFF8;
v23 = 0;
do
{
*(_QWORD *)(v18 + v23) = *(_QWORD *)&v20[v23];
v23 += 8;
}
while ( v23 < v22 );
}
}
else if ( (v17 & 4) != 0 )
{
*((_DWORD *)v27 + 4) = (_DWORD)v47;
*(_DWORD *)((char *)v28 + v17 - 4) = *(_DWORD *)((char *)&v46 + v17 + 4);
}
else if ( (_DWORD)v46 != -1 )
{
*((_BYTE *)v27 + 16) = (_BYTE)v47;
if ( (v17 & 2) != 0 )
*(_WORD *)((char *)v28 + v17 - 2) = *(_WORD *)((char *)&v46 + v17 + 6);
}
}
else
{
*v27 = v45;
v27[2] = v47;
}
v27[1] = v46;
a1[1] += 32LL;
}
v24 = (long long *)(v42 - 24);
if ( (unsigned long long)(v42 - (_BYTE *)v41) < 0x49 )
v24 = (long long *)(v42 - 72);
}
if ( v41 )
{
v25 = v43 - (_QWORD)v41;
operator delete(v41, v43 - (_QWORD)v41);
}
v29 = (_DWORD *)v40;
if ( v40 )
{
v30 = (volatile signed __int32 *)(v40 + 8);
v31 = *(_QWORD *)(v40 + 8);
if ( v31 == 0x100000001LL )
{
*(_DWORD *)(v40 + 8) = 0;
v29[3] = 0;
(*(void ( **)(_DWORD *, long long, long long, volatile signed __int32 *))(*(_QWORD *)v29 + 16LL))(
v29,
v25,
0x100000001LL,
v30);
(*(void ( **)(_DWORD *))(*(_QWORD *)v29 + 24LL))(v29);
}
else
{
if ( _libc_single_threaded )
{
v32 = *(_DWORD *)(v40 + 8);
v31 = (unsigned int)(v32 - 1);
*(_DWORD *)(v40 + 8) = v31;
}
else
{
v32 = _InterlockedExchangeAdd(v30, 0xFFFFFFFF);
}
if ( v32 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v29, v25, v31, v30);
}
}
std::locale::~locale((std::locale *)&v38);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1f8
MOV RBX,RDI
MOV R15,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x208]
MOV RDI,R12
CALL 0x001046f0
MOV qword ptr [RBP + -0x200],0x0
MOV qword ptr [RBP + -0x1f8],0x0
LEA RDI,[RBP + -0x1d0]
MOV R8D,0x10
MOV RCX,R12
LEA RDX,[0x11974b]
LEA RSI,[RDX + -0xc]
LAB_00104856:
CALL 0x001167c0
MOV RDX,qword ptr [RBP + -0xd0]
MOV RAX,qword ptr [RBP + -0xc8]
MOV qword ptr [RBP + -0xc8],0x0
MOV qword ptr [RBP + -0xd0],0x0
MOV qword ptr [RBP + -0x200],RDX
MOV RDI,qword ptr [RBP + -0x1f8]
MOV qword ptr [RBP + -0x1f8],RAX
TEST RDI,RDI
JZ 0x0010489e
CALL 0x00105dba
LAB_0010489e:
MOV dword ptr [RBP + -0x210],0x10
LEA RDI,[RBP + -0xa0]
CALL 0x001065bc
MOV RDI,qword ptr [RBP + -0xc0]
LEA RAX,[RBP + -0xb0]
CMP RDI,RAX
JZ 0x001048d7
MOV RAX,qword ptr [RBP + -0xb0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_001048d7:
MOV R12,qword ptr [RBP + -0xc8]
TEST R12,R12
JZ 0x00104923
LEA RCX,[R12 + 0x8]
MOV RDX,qword ptr [R12 + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x0010499b
CMP byte ptr [0x0011f460],0x0
JZ 0x001049c6
MOV EAX,dword ptr [R12 + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [R12 + 0x8],EDX
LAB_0010491a:
CMP EAX,0x1
JZ 0x001049d4
LAB_00104923:
MOV RDI,qword ptr [RBP + -0x100]
LEA RAX,[RBP + -0xf0]
CMP RDI,RAX
JZ 0x00104946
MOV RAX,qword ptr [RBP + -0xf0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_00104946:
MOV qword ptr [RBP + -0x1f0],0x0
MOV qword ptr [RBP + -0x1e8],0x0
MOV qword ptr [RBP + -0x1e0],0x0
MOV qword ptr [RBP + -0x1d8],0x0
MOV qword ptr [RBX],0x0
MOV qword ptr [RBX + 0x8],0x0
MOV qword ptr [RBX + 0x10],0x0
MOV RDI,qword ptr [R15]
MOV R12,-0x5555555555555555
JMP 0x00104bce
LAB_0010499b:
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 0x00104923
LAB_001049c6:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x0010491a
LAB_001049d4:
MOV RDI,R12
CALL 0x00105d7c
JMP 0x00104923
LAB_00104a21:
MOV R14,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
LEA RAX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x1c8],0x0
SUB R13,R14
MOV qword ptr [RBP + -0x218],R13
CMP R13,0xf
JA 0x00104a7f
CMP R13,0x1
JNZ 0x00104abc
MOVZX EAX,byte ptr [R14]
MOV byte ptr [RBP + -0x1c0],AL
LAB_00104a61:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x1c8],RAX
MOV RDX,qword ptr [RBP + -0x1d0]
MOV byte ptr [RDX + RAX*0x1],0x0
JMP 0x00104c63
LAB_00104a7f:
LEA RSI,[RBP + -0x218]
LEA RDI,[RBP + -0x1d0]
MOV EDX,0x0
LAB_00104a92:
CALL 0x001046a0
MOV RDI,RAX
MOV qword ptr [RBP + -0x1d0],RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_00104aaf:
MOV RDX,R13
MOV RSI,R14
CALL 0x00104520
JMP 0x00104a61
LAB_00104abc:
TEST R13,R13
JZ 0x00104a61
LEA RDI,[RBP + -0x1c0]
JMP 0x00104aaf
LAB_00104aca:
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RAX,0x1
CMP EAX,0x8
JNC 0x00104b22
TEST AL,0x4
JNZ 0x00104b0a
TEST EAX,EAX
JZ 0x00104c9d
MOVZX EDI,byte ptr [RBP + -0x1c0]
MOV byte ptr [RSI + 0x10],DIL
TEST AL,0x2
JZ 0x00104c9d
MOV EAX,EAX
MOVZX ECX,word ptr [RCX + RAX*0x1 + -0x2]
MOV word ptr [RDX + RAX*0x1 + -0x2],CX
JMP 0x00104c9d
LAB_00104b0a:
MOV EDI,dword ptr [RBP + -0x1c0]
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 0x00104c9d
LAB_00104b22:
MOV RDI,qword ptr [RBP + -0x1c0]
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 0x00104c9d
AND EAX,0xfffffff8
MOV EDX,0x0
LAB_00104b5d:
MOV EDI,EDX
MOV R9,qword ptr [RCX + RDI*0x1]
MOV qword ptr [R8 + RDI*0x1],R9
ADD EDX,0x8
CMP EDX,EAX
JC 0x00104b5d
JMP 0x00104c9d
LAB_00104b73:
LEA RDX,[RBP + -0x1d0]
MOV RDI,RBX
LAB_00104b7d:
CALL 0x001061d0
MOV RDI,qword ptr [RBP + -0x1d0]
LEA RAX,[RBP + -0x1c0]
CMP RDI,RAX
JZ 0x00104ba5
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RSI,[RAX + 0x1]
CALL 0x00104540
LAB_00104ba5:
MOV RDX,qword ptr [RBP + -0x1f0]
MOV RAX,qword ptr [RBP + -0x1e8]
SUB RAX,RDX
LEA RCX,[RDX + RAX*0x1 + -0x18]
LEA RDX,[RDX + RAX*0x1 + -0x48]
CMP RAX,0x49
MOV RAX,RCX
CMOVC RAX,RDX
MOV RDI,qword ptr [RAX]
LAB_00104bce:
MOV RSI,qword ptr [R15 + 0x8]
ADD RSI,qword ptr [R15]
LEA RCX,[RBP + -0x210]
LEA RDX,[RBP + -0x1f0]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x0
MOV R8D,0x0
LAB_00104bf5:
CALL 0x0010be87
ADD RSP,0x10
TEST AL,AL
JZ 0x00104cb2
MOV RCX,qword ptr [RBP + -0x1e8]
MOV RAX,qword ptr [RBP + -0x1f0]
CMP RCX,RAX
JZ 0x00104c35
MOV RDX,RCX
SUB RDX,RAX
SAR RDX,0x3
IMUL RDX,R12
SUB RDX,0x3
ADD RAX,0x18
CMP RDX,0x1
JA 0x00104c39
LAB_00104c35:
LEA RAX,[RCX + -0x48]
LAB_00104c39:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00104a21
LEA RAX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x1c8],0x0
MOV byte ptr [RBP + -0x1c0],0x0
LAB_00104c63:
MOV RSI,qword ptr [RBX + 0x8]
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x00104b73
LEA RDX,[RSI + 0x10]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RBP + -0x1d0]
LEA RCX,[RBP + -0x1c0]
CMP RAX,RCX
JZ 0x00104aca
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RSI + 0x10],RAX
LAB_00104c9d:
MOV RAX,qword ptr [RBP + -0x1c8]
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [RBX + 0x8],0x20
JMP 0x00104ba5
LAB_00104cb2:
MOV RDI,qword ptr [RBP + -0x1f0]
TEST RDI,RDI
JZ 0x00104ccd
MOV RSI,qword ptr [RBP + -0x1e0]
SUB RSI,RDI
CALL 0x00104540
LAB_00104ccd:
MOV RAX,qword ptr [RBP + -0x1f8]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00104d0a
LEA RCX,[RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104d3b
CMP byte ptr [0x0011f460],0x0
JZ 0x00104d5d
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104d05:
CMP EAX,0x1
JZ 0x00104d68
LAB_00104d0a:
LEA RDI,[RBP + -0x208]
CALL 0x00104630
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00104dc7
MOV RAX,RBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00104d3b:
MOV R14,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RDI,R14
MOV RAX,qword ptr [R14]
CALL qword ptr [RAX + 0x18]
JMP 0x00104d0a
LAB_00104d5d:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104d05
LAB_00104d68:
CALL 0x00105d7c
JMP 0x00104d0a
LAB_00104dc7:
CALL 0x00104580 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int *__src;
long *plVar2;
_Sp_counted_base<(_Lock_policy)2> *p_Var3;
bool bVar4;
int iVar5;
uint uVar6;
ulong uVar7;
int8 *puVar8;
uint uVar9;
long lVar10;
int8 *in_RSI;
int8 uVar11;
long in_FS_OFFSET;
ulong local_220;
int4 local_218 [2];
locale local_210 [2];
int8 local_208;
_Sp_counted_base<(_Lock_policy)2> *local_200;
void *local_1f8;
void *local_1f0;
long local_1e8;
int8 local_1e0;
ulong *local_1d8;
int8 local_1d0;
ulong local_1c8 [24];
long *local_108;
long local_f8 [4];
int8 local_d8;
_Sp_counted_base<(_Lock_policy)2> *local_d0;
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);
std::locale::locale(local_210);
local_208 = 0;
local_200 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 00104856 to 0010485a has its CatchHandler @ 001049e1 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,"\\\"([^\\\"]*)\\\"","",local_210,0x10
);
p_Var1 = local_d0;
local_208 = local_d8;
p_Var3 = local_200;
local_d0 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
local_d8 = 0;
local_200 = p_Var1;
if (p_Var3 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release(p_Var3);
}
local_218[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);
}
p_Var3 = local_d0;
if (local_d0 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_d0 + 8;
if (*(long *)(local_d0 + 8) == 0x100000001) {
*(int4 *)(local_d0 + 8) = 0;
*(int4 *)(local_d0 + 0xc) = 0;
(**(code **)(*(long *)local_d0 + 0x10))(local_d0);
(**(code **)(*(long *)p_Var3 + 0x18))(p_Var3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar5 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar5 = *(int *)(local_d0 + 8);
*(int *)(local_d0 + 8) = iVar5 + -1;
}
if (iVar5 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_d0);
}
}
}
if (local_108 != local_f8) {
operator_delete(local_108,local_f8[0] + 1);
}
local_1f8 = (void *)0x0;
local_1f0 = (void *)0x0;
local_1e8 = 0;
local_1e0 = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
uVar11 = *in_RSI;
do {
/* try { // try from 00104bf5 to 00104bf9 has its CatchHandler @ 00104db6 */
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)uVar11,(int)in_RSI[1] + (int)*in_RSI,
(match_results *)&local_1f8,(regex *)local_218,0,0,false);
if (!bVar4) {
if (local_1f8 != (void *)0x0) {
operator_delete(local_1f8,local_1e8 - (long)local_1f8);
}
p_Var3 = local_200;
if (local_200 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_200 + 8;
if (*(long *)(local_200 + 8) == 0x100000001) {
*(int4 *)(local_200 + 8) = 0;
*(int4 *)(local_200 + 0xc) = 0;
(**(code **)(*(long *)local_200 + 0x10))();
(**(code **)(*(long *)p_Var3 + 0x18))(p_Var3);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar5 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar5 = *(int *)(local_200 + 8);
*(int *)(local_200 + 8) = iVar5 + -1;
}
if (iVar5 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_200);
}
}
}
std::locale::~locale(local_210);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
if ((local_1f0 == local_1f8) ||
(puVar8 = (int8 *)((long)local_1f8 + 0x18),
((long)local_1f0 - (long)local_1f8 >> 3) * -0x5555555555555555 - 3U < 2)) {
puVar8 = (int8 *)((long)local_1f0 + -0x48);
}
if (*(char *)(puVar8 + 2) == '\0') {
local_1d8 = local_1c8;
local_1d0 = 0;
local_1c8[0] = (ulong)local_1c8[0]._1_7_ << 8;
}
else {
__src = (int *)*puVar8;
local_1d8 = local_1c8;
local_1d0 = 0;
uVar7 = puVar8[1] - (long)__src;
local_220 = uVar7;
if (uVar7 < 0x10) {
if (uVar7 == 1) {
local_1c8[0] = CONCAT71(local_1c8[0]._1_7_,*__src);
}
else if (uVar7 != 0) goto LAB_00104aaf;
}
else {
/* try { // try from 00104a92 to 00104a96 has its CatchHandler @ 00104db6 */
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_220);
local_1c8[0] = local_220;
LAB_00104aaf:
memcpy(local_1d8,__src,uVar7);
}
local_1d0 = local_220;
*(int *)((long)local_1d8 + local_220) = 0;
}
plVar2 = *(long **)(param_1 + 8);
if (plVar2 == *(long **)(param_1 + 0x10)) {
/* try { // try from 00104b7d to 00104b81 has its CatchHandler @ 00104d6f */
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_1d8);
if (local_1d8 != local_1c8) {
operator_delete(local_1d8,local_1c8[0] + 1);
}
}
else {
*plVar2 = (long)(plVar2 + 2);
if (local_1d8 == local_1c8) {
uVar7 = local_1d0 + 1;
uVar6 = (uint)uVar7;
if (uVar6 < 8) {
if ((uVar7 & 4) == 0) {
if (uVar6 != 0) {
*(int *)(plVar2 + 2) = (int)local_1c8[0];
if ((uVar7 & 2) != 0) {
*(int2 *)((long)plVar2 + (uVar7 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1c8 + ((uVar7 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar2 + 2) = (int4)local_1c8[0];
*(int4 *)((long)plVar2 + (uVar7 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1c8 + ((uVar7 & 0xffffffff) - 4));
}
}
else {
plVar2[2] = local_1c8[0];
*(int8 *)((long)plVar2 + (uVar7 & 0xffffffff) + 8) =
*(int8 *)((long)local_1c8 + ((uVar7 & 0xffffffff) - 8));
lVar10 = (long)(plVar2 + 2) - ((ulong)(plVar2 + 3) & 0xfffffffffffffff8);
uVar6 = uVar6 + (int)lVar10 & 0xfffffff8;
if (7 < uVar6) {
uVar9 = 0;
do {
*(int8 *)(((ulong)(plVar2 + 3) & 0xfffffffffffffff8) + (ulong)uVar9) =
*(int8 *)((long)local_1c8 + ((ulong)uVar9 - lVar10));
uVar9 = uVar9 + 8;
} while (uVar9 < uVar6);
}
}
}
else {
*plVar2 = (long)local_1d8;
plVar2[2] = local_1c8[0];
}
plVar2[1] = local_1d0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
lVar10 = (long)local_1f8 + -0x18;
if ((ulong)((long)local_1f0 - (long)local_1f8) < 0x49) {
lVar10 = (long)local_1f8 + -0x48;
}
uVar11 = *(int8 *)(lVar10 + ((long)local_1f0 - (long)local_1f8));
} while( true );
} |
2,898 | func0 |
#include <iostream>
#include <string>
#include <vector>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text1) {
std::regex pattern(R"(\"([^\"]*)\")");
std::smatch matches;
std::vector<std::string> results;
std::string::const_iterator searchStart(text1.cbegin());
while (regex_search(searchStart, text1.cend(), matches, pattern)) {
results.push_back(matches[1]);
searchStart = matches.suffix().first;
}
return results;
}
| int main() {
std::vector<std::string> result1 = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"");
assert((result1[0] == "A53" && result1[1] == "multi" && result1[2] == "Processor"));
std::vector<std::string> result2 = func0("Cast your \"favorite\" entertainment \"apps\"");
assert((result2[0] == "favorite" && result2[1] == "apps"));
std::vector<std::string> result3 = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support");
assert((result3[0] == "4k Ultra HD" && result3[1] == "HDR 10"));
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x228,%rsp
mov %fs:0x28,%rax
mov %rax,0x218(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%r13
lea 0x48(%rsp),%rbx
mov %r13,%rdi
callq 4750 <_ZNSt6localeC1Ev@plt>
mov %r13,%rsi
mov %rbx,%rdi
mov %rbx,0x18(%rsp)
movl $0x10,0x40(%rsp)
callq 44f0 <_ZNSt6localeC1ERKS_@plt>
lea 0x80(%rsp),%rax
mov 0x40(%rsp),%r8d
mov %rbx,%rcx
lea 0x16a1c(%rip),%rdx
mov %rax,%rdi
mov %rax,0x20(%rsp)
lea -0xc(%rdx),%rsi
callq 19460 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
mov 0x180(%rsp),%rax
lea 0x1b0(%rsp),%rdi
movq $0x0,0x180(%rsp)
mov %rax,0x50(%rsp)
mov 0x188(%rsp),%rax
movq $0x0,0x188(%rsp)
mov %rax,0x58(%rsp)
callq 6e80 <_ZNSt11_Deque_baseINSt8__detail9_StateSeqINSt7__cxx1112regex_traitsIcEEEESaIS5_EED1Ev>
mov 0x190(%rsp),%rdi
lea 0x1a0(%rsp),%rax
cmp %rax,%rdi
je 4d09 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd9>
callq 4590 <_ZdlPv@plt>
mov 0x188(%rsp),%rbp
test %rbp,%rbp
je 4d40 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x110>
mov 0x1d293(%rip),%rbx
test %rbx,%rbx
je 51b0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x580>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 51c2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x592>
nopl 0x0(%rax)
mov 0x150(%rsp),%rdi
lea 0x160(%rsp),%rax
cmp %rax,%rdi
je 4d5a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x12a>
callq 4590 <_ZdlPv@plt>
mov %r13,%rdi
lea 0x90(%rsp),%rbp
callq 4680 <_ZNSt6localeD1Ev@plt>
mov (%r15),%rdi
lea 0x40(%rsp),%rax
movq $0x0,0x60(%rsp)
movq $0x0,0x68(%rsp)
movq $0x0,0x70(%rsp)
mov %rdi,%rsi
movq $0x0,0x78(%rsp)
movq $0x0,(%r12)
movq $0x0,0x8(%r12)
movq $0x0,0x10(%r12)
mov %rax,(%rsp)
jmpq 4e61 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x231>
nopl 0x0(%rax)
add $0x18,%rdi
cmpb $0x0,0x10(%rdi)
jne 4ec3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x293>
mov %rbp,0x80(%rsp)
mov 0x8(%r12),%rbx
movq $0x0,0x88(%rsp)
movb $0x0,0x90(%rsp)
cmp 0x10(%r12),%rbx
je 4f18 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2e8>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
mov 0x80(%rsp),%rax
cmp %rbp,%rax
je 5040 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x410>
mov %rax,(%rbx)
mov 0x90(%rsp),%rax
mov %rax,0x10(%rbx)
mov 0x88(%rsp),%rax
mov %rax,0x8(%rbx)
addq $0x20,0x8(%r12)
mov 0x68(%rsp),%rdx
mov 0x60(%rsp),%rax
mov %rdx,%rcx
sub %rax,%rcx
cmp %rax,%rdx
je 5030 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x400>
cmp $0x48,%rcx
je 5030 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x400>
lea -0x18(%rax,%rcx,1),%rax
mov (%rax),%rdi
mov (%r15),%rsi
mov (%rsp),%rcx
add 0x8(%r15),%rsi
xor %r8d,%r8d
mov %r13,%rdx
callq 9dd0 <_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>
mov 0x60(%rsp),%rdi
test %al,%al
je 50d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4a0>
mov 0x68(%rsp),%rax
mov %rax,%rdx
sub %rdi,%rdx
cmp %rdi,%rax
je 4eb4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x284>
movabs $0xaaaaaaaaaaaaaaab,%rbx
mov %rdx,%rax
sar $0x3,%rax
imul %rbx,%rax
sub $0x3,%rax
cmp $0x1,%rax
ja 4dc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x190>
lea -0x48(%rdi,%rdx,1),%rdi
cmpb $0x0,0x10(%rdi)
je 4dce <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19e>
mov (%rdi),%rbx
mov 0x8(%rdi),%r14
mov %rbp,0x80(%rsp)
sub %rbx,%r14
mov %r14,0x38(%rsp)
cmp $0xf,%r14
ja 5168 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x538>
cmp $0x1,%r14
jne 5150 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x520>
movzbl (%rbx),%eax
mov %al,0x90(%rsp)
mov %rbp,%rax
mov %r14,0x88(%rsp)
movb $0x0,(%rax,%r14,1)
mov 0x8(%r12),%rbx
cmp 0x10(%r12),%rbx
jne 4dfa <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ca>
mov (%r12),%rax
mov %rbx,%r14
movabs $0x3ffffffffffffff,%rcx
sub %rax,%r14
mov %rax,0x8(%rsp)
mov %r14,%rax
sar $0x5,%rax
cmp %rcx,%rax
je 528c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x65c>
test %rax,%rax
je 5248 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x618>
movabs $0x7fffffffffffffe0,%rcx
lea (%rax,%rax,1),%rdx
mov %rcx,0x10(%rsp)
cmp %rdx,%rax
jbe 5058 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x428>
mov 0x10(%rsp),%rdi
callq 45a0 <_Znwm@plt>
mov 0x10(%rsp),%r8
lea 0x20(%rax),%rdx
add %rax,%r8
add %rax,%r14
lea 0x10(%r14),%rcx
mov %rcx,(%r14)
mov 0x80(%rsp),%rcx
cmp %rbp,%rcx
je 5260 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x630>
mov %rcx,(%r14)
mov 0x90(%rsp),%rcx
mov %rcx,0x10(%r14)
mov 0x88(%rsp),%rcx
mov 0x8(%rsp),%rsi
mov %rbp,0x80(%rsp)
movq $0x0,0x88(%rsp)
mov %rcx,0x8(%r14)
movb $0x0,0x90(%rsp)
cmp %rsi,%rbx
je 507a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x44a>
mov %rax,%rcx
mov %rsi,%rdx
jmp 5008 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3d8>
nopl 0x0(%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 5070 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x440>
lea 0x10(%rcx),%rsi
lea 0x10(%rdx),%rdi
mov %rsi,(%rcx)
mov (%rdx),%rsi
cmp %rdi,%rsi
jne 4fe8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3b8>
movdqu 0x10(%rdx),%xmm0
movups %xmm0,0x10(%rcx)
jmp 4ff3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c3>
nopw %cs:0x0(%rax,%rax,1)
lea -0x48(%rax,%rcx,1),%rax
jmpq 4e5b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x22b>
nopw 0x0(%rax,%rax,1)
movdqa 0x90(%rsp),%xmm1
movups %xmm1,0x10(%rbx)
jmpq 4e21 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f1>
nopw 0x0(%rax,%rax,1)
test %rdx,%rdx
jne 5298 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x668>
mov $0x20,%edx
xor %r8d,%r8d
xor %eax,%eax
jmpq 4f7c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x34c>
sub 0x8(%rsp),%rbx
lea 0x20(%rax,%rbx,1),%rdx
mov 0x8(%rsp),%rdi
test %rdi,%rdi
je 50a7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x477>
mov %r8,0x28(%rsp)
mov %rax,0x10(%rsp)
mov %rdx,0x8(%rsp)
callq 4590 <_ZdlPv@plt>
mov 0x28(%rsp),%r8
mov 0x10(%rsp),%rax
mov 0x8(%rsp),%rdx
mov 0x80(%rsp),%rdi
mov %rax,(%r12)
mov %rdx,0x8(%r12)
mov %r8,0x10(%r12)
cmp %rbp,%rdi
je 4e33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x203>
callq 4590 <_ZdlPv@plt>
jmpq 4e33 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x203>
test %rdi,%rdi
je 50da <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4aa>
callq 4590 <_ZdlPv@plt>
mov 0x58(%rsp),%rbp
test %rbp,%rbp
je 5110 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4e0>
mov 0x1cec5(%rip),%rbx
test %rbx,%rbx
je 5200 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5d0>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 5212 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5e2>
nopw 0x0(%rax,%rax,1)
mov 0x18(%rsp),%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x218(%rsp),%rax
xor %fs:0x28,%rax
jne 52bf <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x68f>
add $0x228,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
test %r14,%r14
jne 52b7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x687>
mov %rbp,%rax
jmpq 4efb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2cb>
nopl 0x0(%rax)
mov 0x20(%rsp),%rdi
lea 0x38(%rsp),%rsi
xor %edx,%edx
callq 46f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x80(%rsp)
mov %rax,%rdi
mov 0x38(%rsp),%rax
mov %rax,0x90(%rsp)
mov %r14,%rdx
mov %rbx,%rsi
callq 4560 <memcpy@plt>
mov 0x38(%rsp),%r14
mov 0x80(%rsp),%rax
jmpq 4efb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2cb>
xchg %ax,%ax
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 4d40 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x110>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5273 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x643>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4d40 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x110>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4d40 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x110>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 5110 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4e0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5281 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x651>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 5110 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4e0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 5110 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4e0>
nopl 0x0(%rax,%rax,1)
movq $0x20,0x10(%rsp)
jmpq 4f66 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x336>
nopw %cs:0x0(%rax,%rax,1)
movdqa 0x90(%rsp),%xmm2
movups %xmm2,0x10(%r14)
jmpq 4fa6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x376>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 51df <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5af>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 522b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5fb>
lea 0x15f2f(%rip),%rdi
callq 44d0 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x3ffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
shl $0x5,%rdx
mov %rdx,0x10(%rsp)
jmpq 4f66 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x336>
mov %rbp,%rdi
jmpq 5191 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x561>
callq 45f0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 47d8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x15>
endbr64
mov %rax,%rbp
jmpq 4800 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x3d>
endbr64
mov %rax,%rbx
jmpq 47c3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r15, [rbp+var_208]
push r13
mov r13, rsi
push r12
push rbx
mov rbx, rdi
mov rdi, r15; this
sub rsp, 218h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov [rbp+var_240], r15
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, asc_1973F+0Ch; ""
pxor xmm0, xmm0
lea rdi, [rbp+var_1D0]
mov r8d, 10h
mov rcx, r15
lea rsi, [rdx-0Ch]
mov [rbp+var_238], rdi
movaps [rbp+var_200], xmm0
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rbp+var_D0]
mov rax, qword ptr [rbp+var_200+8]
pxor xmm1, xmm1
movaps [rbp+var_D0], xmm1
mov rdi, rax
movaps [rbp+var_200], xmm0
test rax, rax
jz short loc_4D38
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_51A0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5240
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4D2F:
cmp eax, 1
jz loc_5258
loc_4D38:
lea rdi, [rbp+var_A0]
mov [rbp+var_210], 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_4D71
mov rax, [rbp+var_B0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4D71:
mov rax, qword ptr [rbp+var_D0+8]
mov rdi, rax
test rax, rax
jz short loc_4DBA
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_51E0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5230
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4DB1:
cmp eax, 1
jz loc_524E
loc_4DBA:
mov rdi, [rbp+var_100]; void *
lea rax, [rbp+var_F0]
cmp rdi, rax
jz short loc_4DDD
mov rax, [rbp+var_F0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4DDD:
mov rdi, [r13+0]
pxor xmm0, xmm0
lea rax, [rbp+var_210]
mov qword ptr [rbx+10h], 0
mov [rbp+var_230], rax
lea r14, [rbp+var_1F0]
movaps xmmword ptr [rbp+var_1F0], xmm0
mov rsi, rdi
movaps [rbp+var_1E0], xmm0
movups xmmword ptr [rbx], xmm0
jmp loc_4ECC
loc_4E20:
add rax, 18h
cmp byte ptr [rax+10h], 0
jnz loc_4F40
loc_4E2E:
lea rax, [rbp+var_1C0]
mov byte ptr [rbp+var_1C0], 0
mov rsi, [rbx+8]
mov [rbp+var_228], rax
mov [rbp+var_1D0], rax
mov [rbp+var_1C8], 0
cmp rsi, [rbx+10h]
jz loc_4FB0
loc_4E63:
lea rdx, [rsi+10h]
mov rcx, [rbp+var_228]
mov [rsi], rdx
mov rax, [rbp+var_1D0]
cmp rax, rcx
jz loc_4FF0
mov [rsi], rax
mov rax, [rbp+var_1C0]
mov [rsi+10h], rax
mov rax, [rbp+var_1C8]
loc_4E96:
mov [rsi+8], rax
add qword ptr [rbx+8], 20h ; ' '
loc_4E9F:
mov rdx, [rbp+var_1F0]
mov rax, [rbp+var_1F0+8]
mov rsi, [r13+0]
sub rax, rdx
lea rcx, [rdx+rax-18h]
cmp rax, 49h ; 'I'
lea rdx, [rdx+rax-48h]
mov rax, rcx
cmovb rax, rdx
mov rdi, [rax]
loc_4ECC:
sub rsp, 8
add rsi, [r13+8]
xor r9d, r9d
xor r8d, r8d
push 0
mov rcx, [rbp+var_230]
mov rdx, r14
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_5048
mov rdx, [rbp+var_1F0+8]
mov rax, [rbp+var_1F0]
mov rcx, rdx
sub rcx, rax
cmp rdx, rax
jz short loc_4F31
mov rdi, 0AAAAAAAAAAAAAAABh
mov rdx, rcx
sar rdx, 3
imul rdx, rdi
sub rdx, 3
cmp rdx, 1
ja loc_4E20
loc_4F31:
lea rax, [rax+rcx-48h]
cmp byte ptr [rax+10h], 0
jz loc_4E2E
loc_4F40:
mov r15, [rax]
mov r12, [rax+8]
lea rax, [rbp+var_1C0]
mov [rbp+var_1C8], 0
mov [rbp+var_228], rax
sub r12, r15
mov [rbp+var_1D0], rax
mov [rbp+var_218], r12
cmp r12, 0Fh
ja loc_50F8
cmp r12, 1
jnz loc_50E0
movzx eax, byte ptr [r15]
mov byte ptr [rbp+var_1C0], al
loc_4F8F:
mov rax, [rbp+var_228]
loc_4F96:
mov [rbp+var_1C8], r12
mov byte ptr [rax+r12], 0
mov rsi, [rbx+8]
cmp rsi, [rbx+10h]
jnz loc_4E63
loc_4FB0:
mov rdx, [rbp+var_238]
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_228]
cmp rdi, rax
jz loc_4E9F
mov rax, [rbp+var_1C0]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_4E9F
loc_4FF0:
mov rax, [rbp+var_1C8]
lea rcx, [rax+1]
cmp ecx, 8
jnb loc_5148
test cl, 4
jnz loc_51FF
test ecx, ecx
jz loc_4E96
mov rdi, [rbp+var_228]
movzx edi, byte ptr [rdi]
mov [rsi+10h], dil
test cl, 2
jz loc_4E96
mov rdi, [rbp+var_228]
mov ecx, ecx
movzx edi, word ptr [rdi+rcx-2]
mov [rdx+rcx-2], di
jmp loc_4E96
loc_5048:
mov rdi, [rbp+var_1F0]; void *
test rdi, rdi
jz short loc_5063
mov rsi, qword ptr [rbp+var_1E0]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5063:
mov rax, qword ptr [rbp+var_200+8]
mov rdi, rax
test rax, rax
jz short loc_50AC
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_51C0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_5220
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_50A3:
cmp eax, 1
jz loc_5262
loc_50AC:
mov rdi, [rbp+var_240]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_526C
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_50E0:
test r12, r12
jz loc_4F8F
mov rdi, [rbp+var_228]
jmp short loc_5125
loc_50F8:
mov rdi, [rbp+var_238]
lea rsi, [rbp+var_218]
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rbp+var_1D0], rax
mov rdi, rax; dest
mov rax, [rbp+var_218]
mov [rbp+var_1C0], rax
loc_5125:
mov rdx, r12; n
mov rsi, r15; src
call _memcpy
mov r12, [rbp+var_218]
mov rax, [rbp+var_1D0]
jmp loc_4F96
loc_5148:
mov r10, [rbp+var_228]
mov rdi, [r10]
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [r10+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rsi+18h]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
add ecx, edx
sub r10, rdx
and ecx, 0FFFFFFF8h
mov r11, r10
cmp ecx, 8
jb loc_4E96
and ecx, 0FFFFFFF8h
xor edx, edx
loc_5186:
mov r8d, edx
add edx, 8
mov r9, [r11+r8]
mov [rdi+r8], r9
cmp edx, ecx
jb short loc_5186
jmp loc_4E96
loc_51A0:
mov rax, [rdi]
mov r14, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+18h]
jmp loc_4D38
loc_51C0:
mov rax, [rdi]
mov r14, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+18h]
jmp loc_50AC
loc_51E0:
mov rax, [rdi]
mov r14, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+18h]
jmp loc_4DBA
loc_51FF:
mov r11, [rbp+var_228]
mov ecx, ecx
mov edi, [r11]
mov [rsi+10h], edi
mov edi, [r11+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_4E96
loc_5220:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_50A3
loc_5230:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4DB1
loc_5240:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4D2F
loc_524E:
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_4DBA
loc_5258:
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_4D38
loc_5262:
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_50AC
loc_526C:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov r15, rax
jmp loc_379B
endbr64
mov r15, rax
jmp loc_37A7 | long long func0(long long a1, long long *a2)
{
char *v4; // rsi
__m128i v5; // xmm0
long long v6; // rax
signed __int32 *v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v11; // rdi
long long v12; // rdx
volatile signed __int32 *v13; // rcx
signed __int32 v14; // eax
long long v15; // rdi
long long v16; // rsi
char *v17; // rax
void **v18; // rsi
_QWORD *v19; // rdx
void *v20; // rax
char *v21; // rax
long long v22; // rsi
_BYTE *v23; // r15
long long v24; // r12
size_t v25; // r12
_QWORD *v26; // rax
unsigned int v27; // ecx
long long v28; // rdi
long long v29; // rdx
volatile signed __int32 *v30; // rcx
signed __int32 v31; // eax
_QWORD *v33; // rdi
unsigned long long v34; // rdi
char *v35; // rdx
char *v36; // r10
unsigned int v37; // ecx
unsigned int v38; // ecx
unsigned int v39; // edx
long long v40; // r8
long long v41; // rax
long long v42; // rax
long long v43; // rax
size_t v44; // [rsp+28h] [rbp-218h] BYREF
int v45; // [rsp+30h] [rbp-210h] BYREF
char v46[8]; // [rsp+38h] [rbp-208h] BYREF
__m128i v47; // [rsp+40h] [rbp-200h]
void *v48[2]; // [rsp+50h] [rbp-1F0h] BYREF
__int128 v49; // [rsp+60h] [rbp-1E0h]
void *v50; // [rsp+70h] [rbp-1D0h] BYREF
size_t v51; // [rsp+78h] [rbp-1C8h]
_QWORD v52[24]; // [rsp+80h] [rbp-1C0h] BYREF
void *v53; // [rsp+140h] [rbp-100h]
long long v54; // [rsp+150h] [rbp-F0h] BYREF
__m128i v55; // [rsp+170h] [rbp-D0h] BYREF
void *v56; // [rsp+180h] [rbp-C0h]
long long v57; // [rsp+190h] [rbp-B0h] BYREF
char v58[104]; // [rsp+1A0h] [rbp-A0h] BYREF
unsigned long long v59; // [rsp+208h] [rbp-38h]
v59 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v46);
v4 = "\\\"([^\\\"]*)\\\"";
v47 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v50, "\\\"([^\\\"]*)\\\"", "", v46, 16LL);
v5 = _mm_load_si128(&v55);
v6 = v47.m128i_i64[1];
v55 = 0LL;
v7 = (signed __int32 *)v47.m128i_i64[1];
v47 = v5;
if ( v7 )
{
v8 = *(_QWORD *)(v6 + 8);
v9 = (volatile signed __int32 *)(v6 + 8);
if ( v8 == 0x100000001LL )
{
v41 = *(_QWORD *)v7;
*((_QWORD *)v7 + 1) = 0LL;
(*(void ( **)(signed __int32 *, char *, long long, volatile signed __int32 *))(v41 + 16))(
v7,
v4,
0x100000001LL,
v9);
(*(void ( **)(signed __int32 *))(*(_QWORD *)v7 + 24LL))(v7);
}
else
{
if ( _libc_single_threaded )
{
v10 = v7[2];
v8 = (unsigned int)(v10 - 1);
v7[2] = v8;
}
else
{
v10 = _InterlockedExchangeAdd(v9, 0xFFFFFFFF);
}
if ( v10 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v7, v4, v8, v9);
}
}
v45 = 16;
std::_Deque_base<std::__detail::_StateSeq<std::regex_traits<char>>>::~_Deque_base(v58);
if ( v56 != &v57 )
{
v4 = (char *)(v57 + 1);
operator delete(v56, v57 + 1);
}
v11 = v55.m128i_i64[1];
if ( v55.m128i_i64[1] )
{
v12 = *(_QWORD *)(v55.m128i_i64[1] + 8);
v13 = (volatile signed __int32 *)(v55.m128i_i64[1] + 8);
if ( v12 == 0x100000001LL )
{
v43 = *(_QWORD *)v55.m128i_i64[1];
*(_QWORD *)(v55.m128i_i64[1] + 8) = 0LL;
(*(void ( **)(long long, char *, long long, volatile signed __int32 *))(v43 + 16))(
v11,
v4,
0x100000001LL,
v13);
(*(void ( **)(long long))(*(_QWORD *)v11 + 24LL))(v11);
}
else
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v55.m128i_i64[1] + 8);
v12 = (unsigned int)(v14 - 1);
*(_DWORD *)(v55.m128i_i64[1] + 8) = v12;
}
else
{
v14 = _InterlockedExchangeAdd(v13, 0xFFFFFFFF);
}
if ( v14 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v11, v4, v12, v13);
}
}
if ( v53 != &v54 )
operator delete(v53, v54 + 1);
v15 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)v48 = 0LL;
v16 = v15;
v49 = 0LL;
*(_OWORD *)a1 = 0LL;
while ( 1 )
{
v22 = a2[1] + v16;
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>>(
v15,
v22,
(unsigned int)v48,
(unsigned int)&v45,
0,
0,
0) )
break;
if ( v48[1] == v48[0] || 0xAAAAAAAAAAAAAAABLL * (((char *)v48[1] - (char *)v48[0]) >> 3) - 3 <= 1 )
{
v17 = (char *)v48[1] - 72;
if ( !*((_BYTE *)v48[1] - 56) )
{
LABEL_19:
LOBYTE(v52[0]) = 0;
v18 = *(void ***)(a1 + 8);
v50 = v52;
v51 = 0LL;
if ( v18 == *(void ***)(a1 + 16) )
goto LABEL_35;
goto LABEL_20;
}
}
else
{
v17 = (char *)v48[0] + 24;
if ( !*((_BYTE *)v48[0] + 40) )
goto LABEL_19;
}
v23 = *(_BYTE **)v17;
v24 = *((_QWORD *)v17 + 1);
v51 = 0LL;
v25 = v24 - (_QWORD)v23;
v50 = v52;
v44 = v25;
if ( v25 > 0xF )
{
v50 = (void *)std::string::_M_create(&v50, &v44, 0LL);
v33 = v50;
v52[0] = v44;
}
else
{
if ( v25 == 1 )
{
LOBYTE(v52[0]) = *v23;
LABEL_33:
v26 = v52;
goto LABEL_34;
}
if ( !v25 )
goto LABEL_33;
v33 = v52;
}
memcpy(v33, v23, v25);
v25 = v44;
v26 = v50;
LABEL_34:
v51 = v25;
*((_BYTE *)v26 + v25) = 0;
v18 = *(void ***)(a1 + 8);
if ( v18 == *(void ***)(a1 + 16) )
{
LABEL_35:
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v18, &v50);
if ( v50 != v52 )
operator delete(v50, v52[0] + 1LL);
goto LABEL_23;
}
LABEL_20:
v19 = v18 + 2;
*v18 = v18 + 2;
if ( v50 == v52 )
{
v20 = (void *)v51;
v27 = v51 + 1;
if ( (unsigned int)(v51 + 1) >= 8 )
{
v18[2] = (void *)v52[0];
*(_QWORD *)((char *)v19 + v27 - 8) = *(_QWORD *)((char *)&v52[-1] + v27);
v34 = (unsigned long long)(v18 + 3) & 0xFFFFFFFFFFFFFFF8LL;
v35 = (char *)v19 - v34;
v36 = (char *)((char *)v52 - v35);
v37 = ((_DWORD)v35 + v27) & 0xFFFFFFF8;
if ( v37 >= 8 )
{
v38 = v37 & 0xFFFFFFF8;
v39 = 0;
do
{
v40 = v39;
v39 += 8;
*(_QWORD *)(v34 + v40) = *(_QWORD *)&v36[v40];
}
while ( v39 < v38 );
}
}
else if ( (v27 & 4) != 0 )
{
*((_DWORD *)v18 + 4) = v52[0];
*(_DWORD *)((char *)v19 + v27 - 4) = *(_DWORD *)((char *)&v51 + v27 + 4);
}
else if ( (_DWORD)v51 != -1 )
{
*((_BYTE *)v18 + 16) = v52[0];
if ( (v27 & 2) != 0 )
*(_WORD *)((char *)v19 + v27 - 2) = *(_WORD *)((char *)&v51 + v27 + 6);
}
}
else
{
*v18 = v50;
v18[2] = (void *)v52[0];
v20 = (void *)v51;
}
v18[1] = v20;
*(_QWORD *)(a1 + 8) += 32LL;
LABEL_23:
v16 = *a2;
v21 = (char *)v48[1] - 24;
if ( (long long *)((char *)v48[1] - (char *)v48[0]) < (long long *)((char *)&qword_48 + 1) )
v21 = (char *)v48[1] - 72;
v15 = *(_QWORD *)v21;
}
if ( v48[0] )
{
v22 = v49 - (unsigned long long)v48[0];
operator delete(v48[0], v49 - (unsigned long long)v48[0]);
}
v28 = v47.m128i_i64[1];
if ( v47.m128i_i64[1] )
{
v29 = *(_QWORD *)(v47.m128i_i64[1] + 8);
v30 = (volatile signed __int32 *)(v47.m128i_i64[1] + 8);
if ( v29 == 0x100000001LL )
{
v42 = *(_QWORD *)v47.m128i_i64[1];
*(_QWORD *)(v47.m128i_i64[1] + 8) = 0LL;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(v42 + 16))(
v28,
v22,
0x100000001LL,
v30);
(*(void ( **)(long long))(*(_QWORD *)v28 + 24LL))(v28);
}
else
{
if ( _libc_single_threaded )
{
v31 = *(_DWORD *)(v47.m128i_i64[1] + 8);
v29 = (unsigned int)(v31 - 1);
*(_DWORD *)(v47.m128i_i64[1] + 8) = v29;
}
else
{
v31 = _InterlockedExchangeAdd(v30, 0xFFFFFFFF);
}
if ( v31 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v28, v22, v29, v30);
}
}
std::locale::~locale((std::locale *)v46);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R15,[RBP + -0x208]
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBX
MOV RBX,RDI
MOV RDI,R15
SUB RSP,0x218
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RBP + -0x240],R15
CALL 0x001036d0
LEA RDX,[0x11974b]
PXOR XMM0,XMM0
LEA RDI,[RBP + -0x1d0]
MOV R8D,0x10
MOV RCX,R15
LEA RSI,[RDX + -0xc]
MOV qword ptr [RBP + -0x238],RDI
MOVAPS xmmword ptr [RBP + -0x200],XMM0
LAB_00104cd0:
CALL 0x00117910
MOVDQA XMM0,xmmword ptr [RBP + -0xd0]
MOV RAX,qword ptr [RBP + -0x1f8]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM1
MOV RDI,RAX
MOVAPS xmmword ptr [RBP + -0x200],XMM0
TEST RAX,RAX
JZ 0x00104d38
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001051a0
CMP byte ptr [0x0011f460],0x0
JZ 0x00105240
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104d2f:
CMP EAX,0x1
JZ 0x00105258
LAB_00104d38:
LEA RDI,[RBP + -0xa0]
MOV dword ptr [RBP + -0x210],0x10
CALL 0x00106e70
MOV RDI,qword ptr [RBP + -0xc0]
LEA RAX,[RBP + -0xb0]
CMP RDI,RAX
JZ 0x00104d71
MOV RAX,qword ptr [RBP + -0xb0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
LAB_00104d71:
MOV RAX,qword ptr [RBP + -0xc8]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00104dba
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001051e0
CMP byte ptr [0x0011f460],0x0
JZ 0x00105230
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104db1:
CMP EAX,0x1
JZ 0x0010524e
LAB_00104dba:
MOV RDI,qword ptr [RBP + -0x100]
LEA RAX,[RBP + -0xf0]
CMP RDI,RAX
JZ 0x00104ddd
MOV RAX,qword ptr [RBP + -0xf0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
LAB_00104ddd:
MOV RDI,qword ptr [R13]
PXOR XMM0,XMM0
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [RBP + -0x230],RAX
LEA R14,[RBP + -0x1f0]
MOVAPS xmmword ptr [RBP + -0x1f0],XMM0
MOV RSI,RDI
MOVAPS xmmword ptr [RBP + -0x1e0],XMM0
MOVUPS xmmword ptr [RBX],XMM0
JMP 0x00104ecc
LAB_00104e20:
ADD RAX,0x18
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00104f40
LAB_00104e2e:
LEA RAX,[RBP + -0x1c0]
MOV byte ptr [RBP + -0x1c0],0x0
MOV RSI,qword ptr [RBX + 0x8]
MOV qword ptr [RBP + -0x228],RAX
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x1c8],0x0
CMP RSI,qword ptr [RBX + 0x10]
JZ 0x00104fb0
LAB_00104e63:
LEA RDX,[RSI + 0x10]
MOV RCX,qword ptr [RBP + -0x228]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RBP + -0x1d0]
CMP RAX,RCX
JZ 0x00104ff0
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RBP + -0x1c0]
MOV qword ptr [RSI + 0x10],RAX
MOV RAX,qword ptr [RBP + -0x1c8]
LAB_00104e96:
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [RBX + 0x8],0x20
LAB_00104e9f:
MOV RDX,qword ptr [RBP + -0x1f0]
MOV RAX,qword ptr [RBP + -0x1e8]
MOV RSI,qword ptr [R13]
SUB RAX,RDX
LEA RCX,[RDX + RAX*0x1 + -0x18]
CMP RAX,0x49
LEA RDX,[RDX + RAX*0x1 + -0x48]
MOV RAX,RCX
CMOVC RAX,RDX
MOV RDI,qword ptr [RAX]
LAB_00104ecc:
SUB RSP,0x8
ADD RSI,qword ptr [R13 + 0x8]
XOR R9D,R9D
XOR R8D,R8D
PUSH 0x0
MOV RCX,qword ptr [RBP + -0x230]
MOV RDX,R14
LAB_00104ee6:
CALL 0x0010bc10
POP RDX
POP RCX
TEST AL,AL
JZ 0x00105048
MOV RDX,qword ptr [RBP + -0x1e8]
MOV RAX,qword ptr [RBP + -0x1f0]
MOV RCX,RDX
SUB RCX,RAX
CMP RDX,RAX
JZ 0x00104f31
MOV RDI,-0x5555555555555555
MOV RDX,RCX
SAR RDX,0x3
IMUL RDX,RDI
SUB RDX,0x3
CMP RDX,0x1
JA 0x00104e20
LAB_00104f31:
LEA RAX,[RAX + RCX*0x1 + -0x48]
CMP byte ptr [RAX + 0x10],0x0
JZ 0x00104e2e
LAB_00104f40:
MOV R15,qword ptr [RAX]
MOV R12,qword ptr [RAX + 0x8]
LEA RAX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x1c8],0x0
MOV qword ptr [RBP + -0x228],RAX
SUB R12,R15
MOV qword ptr [RBP + -0x1d0],RAX
MOV qword ptr [RBP + -0x218],R12
CMP R12,0xf
JA 0x001050f8
CMP R12,0x1
JNZ 0x001050e0
MOVZX EAX,byte ptr [R15]
MOV byte ptr [RBP + -0x1c0],AL
LAB_00104f8f:
MOV RAX,qword ptr [RBP + -0x228]
LAB_00104f96:
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 0x00104e63
LAB_00104fb0:
MOV RDX,qword ptr [RBP + -0x238]
MOV RDI,RBX
LAB_00104fba:
CALL 0x00106960
MOV RDI,qword ptr [RBP + -0x1d0]
MOV RAX,qword ptr [RBP + -0x228]
CMP RDI,RAX
JZ 0x00104e9f
MOV RAX,qword ptr [RBP + -0x1c0]
LEA RSI,[RAX + 0x1]
CALL 0x00103540
JMP 0x00104e9f
LAB_00104ff0:
MOV RAX,qword ptr [RBP + -0x1c8]
LEA RCX,[RAX + 0x1]
CMP ECX,0x8
JNC 0x00105148
TEST CL,0x4
JNZ 0x001051ff
TEST ECX,ECX
JZ 0x00104e96
MOV RDI,qword ptr [RBP + -0x228]
MOVZX EDI,byte ptr [RDI]
MOV byte ptr [RSI + 0x10],DIL
TEST CL,0x2
JZ 0x00104e96
MOV RDI,qword ptr [RBP + -0x228]
MOV ECX,ECX
MOVZX EDI,word ptr [RDI + RCX*0x1 + -0x2]
MOV word ptr [RDX + RCX*0x1 + -0x2],DI
JMP 0x00104e96
LAB_00105048:
MOV RDI,qword ptr [RBP + -0x1f0]
TEST RDI,RDI
JZ 0x00105063
MOV RSI,qword ptr [RBP + -0x1e0]
SUB RSI,RDI
CALL 0x00103540
LAB_00105063:
MOV RAX,qword ptr [RBP + -0x1f8]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001050ac
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001051c0
CMP byte ptr [0x0011f460],0x0
JZ 0x00105220
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_001050a3:
CMP EAX,0x1
JZ 0x00105262
LAB_001050ac:
MOV RDI,qword ptr [RBP + -0x240]
CALL 0x00103620
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010526c
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001050e0:
TEST R12,R12
JZ 0x00104f8f
MOV RDI,qword ptr [RBP + -0x228]
JMP 0x00105125
LAB_001050f8:
MOV RDI,qword ptr [RBP + -0x238]
LEA RSI,[RBP + -0x218]
XOR EDX,EDX
LAB_00105108:
CALL 0x00103680
MOV qword ptr [RBP + -0x1d0],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x1c0],RAX
LAB_00105125:
MOV RDX,R12
MOV RSI,R15
CALL 0x00103520
MOV R12,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RBP + -0x1d0]
JMP 0x00104f96
LAB_00105148:
MOV R10,qword ptr [RBP + -0x228]
MOV RDI,qword ptr [R10]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,ECX
MOV R8,qword ptr [R10 + 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 R10,RDX
AND ECX,0xfffffff8
MOV R11,R10
CMP ECX,0x8
JC 0x00104e96
AND ECX,0xfffffff8
XOR EDX,EDX
LAB_00105186:
MOV R8D,EDX
ADD EDX,0x8
MOV R9,qword ptr [R11 + R8*0x1]
MOV qword ptr [RDI + R8*0x1],R9
CMP EDX,ECX
JC 0x00105186
JMP 0x00104e96
LAB_001051a0:
MOV RAX,qword ptr [RDI]
MOV R14,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x18]
JMP 0x00104d38
LAB_001051c0:
MOV RAX,qword ptr [RDI]
MOV R14,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x18]
JMP 0x001050ac
LAB_001051e0:
MOV RAX,qword ptr [RDI]
MOV R14,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x18]
JMP 0x00104dba
LAB_001051ff:
MOV R11,qword ptr [RBP + -0x228]
MOV ECX,ECX
MOV EDI,dword ptr [R11]
MOV dword ptr [RSI + 0x10],EDI
MOV EDI,dword ptr [R11 + RCX*0x1 + -0x4]
MOV dword ptr [RDX + RCX*0x1 + -0x4],EDI
JMP 0x00104e96
LAB_00105220:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x001050a3
LAB_00105230:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104db1
LAB_00105240:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104d2f
LAB_0010524e:
CALL 0x00106520
JMP 0x00104dba
LAB_00105258:
CALL 0x00106520
JMP 0x00104d38
LAB_00105262:
CALL 0x00106520
JMP 0x001050ac
LAB_0010526c:
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;
int *__src;
int auVar2 [16];
bool bVar3;
int iVar4;
int8 *puVar5;
uint uVar6;
uint uVar7;
long lVar8;
int8 *in_RSI;
long *plVar9;
int8 uVar10;
int8 uVar11;
ulong uVar12;
long in_FS_OFFSET;
ulong *local_230;
ulong local_220;
int4 local_218 [2];
locale local_210 [2];
int local_208 [16];
int 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);
std::locale::locale(local_210);
local_208 = (int [16])0x0;
/* try { // try from 00104cd0 to 00104cd4 has its CatchHandler @ 00105271 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,"\\\"([^\\\"]*)\\\"","",local_210,0x10
);
auVar2 = local_d8;
uVar10 = local_208._8_8_;
local_d8 = (int [16])0x0;
local_208 = auVar2;
if ((_Sp_counted_base<(_Lock_policy)2> *)uVar10 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(uVar10 + 8);
if (*(long *)(uVar10 + 8) == 0x100000001) {
*(int8 *)(uVar10 + 8) = 0;
(**(code **)(*(long *)uVar10 + 0x10))();
(**(code **)(*(long *)uVar10 + 0x18))(uVar10);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar4 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)(uVar10 + 8);
*(int *)(uVar10 + 8) = iVar4 + -1;
}
if (iVar4 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)uVar10);
}
}
}
local_218[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);
}
uVar10 = 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))();
(**(code **)(*(long *)uVar10 + 0x18))(uVar10);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar4 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)(local_d8._8_8_ + 8);
*(int *)(local_d8._8_8_ + 8) = iVar4 + -1;
}
if (iVar4 == 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);
}
uVar10 = *in_RSI;
*(int8 *)(param_1 + 0x10) = 0;
local_1f8 = (int [16])0x0;
local_1e8 = (int [16])0x0;
*(int (*) [16])param_1 = (int [16])0x0;
uVar11 = uVar10;
do {
/* try { // try from 00104ee6 to 00104eea has its CatchHandler @ 00105289 */
bVar3 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)uVar11,(int)uVar10 + (int)in_RSI[1],
(match_results *)local_1f8,(regex *)local_218,0,0,false);
if (!bVar3) {
if ((void *)local_1f8._0_8_ != (void *)0x0) {
operator_delete((void *)local_1f8._0_8_,local_1e8._0_8_ - local_1f8._0_8_);
}
if ((_Sp_counted_base<(_Lock_policy)2> *)local_208._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_208._8_8_ + 8);
if (*(long *)(local_208._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_208._8_8_ + 8) = 0;
(**(code **)(*(long *)local_208._8_8_ + 0x10))();
(**(code **)(*(long *)local_208._8_8_ + 0x18))(local_208._8_8_);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar4 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)(local_208._8_8_ + 8);
*(int *)(local_208._8_8_ + 8) = iVar4 + -1;
}
if (iVar4 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_208._8_8_);
}
}
}
std::locale::~locale(local_210);
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
}
if ((local_1f8._8_8_ == local_1f8._0_8_) ||
(((long)(local_1f8._8_8_ - local_1f8._0_8_) >> 3) * -0x5555555555555555 - 3U < 2)) {
puVar5 = (int8 *)(local_1f8._0_8_ + (local_1f8._8_8_ - local_1f8._0_8_) + -0x48);
if (*(char *)(puVar5 + 2) == '\0') goto LAB_00104e2e;
LAB_00104f40:
__src = (int *)*puVar5;
local_1d8 = local_1c8;
local_1d0 = 0;
uVar12 = puVar5[1] - (long)__src;
local_220 = uVar12;
if (uVar12 < 0x10) {
if (uVar12 == 1) {
local_1c8[0] = CONCAT71(local_1c8[0]._1_7_,*__src);
}
else if (uVar12 != 0) goto LAB_00105125;
}
else {
/* try { // try from 00105108 to 0010510c has its CatchHandler @ 00105289 */
local_1d8 = (ulong *)std::string::_M_create((ulong *)&local_1d8,(ulong)&local_220);
local_1c8[0] = local_220;
LAB_00105125:
memcpy(local_1d8,__src,uVar12);
}
*(int *)((long)local_1d8 + local_220) = 0;
plVar9 = *(long **)(param_1 + 8);
local_1d0 = local_220;
if (plVar9 != *(long **)(param_1 + 0x10)) goto LAB_00104e63;
LAB_00104fb0:
local_230 = local_1c8;
/* try { // try from 00104fba to 00104fbe has its CatchHandler @ 0010527d */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar9,(string *)&local_1d8);
if (local_1d8 != local_230) {
operator_delete(local_1d8,local_1c8[0] + 1);
}
}
else {
puVar5 = (int8 *)(local_1f8._0_8_ + 0x18);
if (*(char *)(local_1f8._0_8_ + 0x28) != '\0') goto LAB_00104f40;
LAB_00104e2e:
local_1d8 = local_1c8;
local_1c8[0] = (ulong)local_1c8[0]._1_7_ << 8;
plVar9 = *(long **)(param_1 + 8);
local_1d0 = 0;
if (plVar9 == *(long **)(param_1 + 0x10)) goto LAB_00104fb0;
LAB_00104e63:
local_230 = local_1c8;
*plVar9 = (long)(plVar9 + 2);
if (local_1d8 == local_230) {
uVar12 = local_1d0 + 1;
uVar6 = (uint)uVar12;
if (uVar6 < 8) {
if ((uVar12 & 4) == 0) {
if (uVar6 != 0) {
*(int *)(plVar9 + 2) = (int)local_1c8[0];
if ((uVar12 & 2) != 0) {
*(int2 *)((long)plVar9 + (uVar12 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1c8 + ((uVar12 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar9 + 2) = (int4)local_1c8[0];
*(int4 *)((long)plVar9 + (uVar12 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1c8 + ((uVar12 & 0xffffffff) - 4));
}
}
else {
plVar9[2] = local_1c8[0];
*(int8 *)((long)plVar9 + (uVar12 & 0xffffffff) + 8) =
*(int8 *)((long)local_1c8 + ((uVar12 & 0xffffffff) - 8));
lVar8 = (long)(plVar9 + 2) - ((ulong)(plVar9 + 3) & 0xfffffffffffffff8);
uVar6 = uVar6 + (int)lVar8 & 0xfffffff8;
if (7 < uVar6) {
uVar7 = 0;
do {
uVar12 = (ulong)uVar7;
uVar7 = uVar7 + 8;
*(int8 *)(((ulong)(plVar9 + 3) & 0xfffffffffffffff8) + uVar12) =
*(int8 *)((long)local_230 + (uVar12 - lVar8));
} while (uVar7 < uVar6);
}
}
}
else {
*plVar9 = (long)local_1d8;
plVar9[2] = local_1c8[0];
}
plVar9[1] = local_1d0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
uVar10 = *in_RSI;
lVar8 = local_1f8._0_8_ + -0x18;
if ((ulong)(local_1f8._8_8_ - local_1f8._0_8_) < 0x49) {
lVar8 = local_1f8._0_8_ + -0x48;
}
uVar11 = *(int8 *)(lVar8 + (local_1f8._8_8_ - local_1f8._0_8_));
} while( true );
} |
2,899 | func0 |
#include <iostream>
#include <string>
#include <vector>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text1) {
std::regex pattern(R"(\"([^\"]*)\")");
std::smatch matches;
std::vector<std::string> results;
std::string::const_iterator searchStart(text1.cbegin());
while (regex_search(searchStart, text1.cend(), matches, pattern)) {
results.push_back(matches[1]);
searchStart = matches.suffix().first;
}
return results;
}
| int main() {
std::vector<std::string> result1 = func0("Cortex \"A53\" Based \"multi\" tasking \"Processor\"");
assert((result1[0] == "A53" && result1[1] == "multi" && result1[2] == "Processor"));
std::vector<std::string> result2 = func0("Cast your \"favorite\" entertainment \"apps\"");
assert((result2[0] == "favorite" && result2[1] == "apps"));
std::vector<std::string> result3 = func0("Watch content \"4k Ultra HD\" resolution with \"HDR 10\" Support");
assert((result3[0] == "4k Ultra HD" && result3[1] == "HDR 10"));
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x228,%rsp
mov %fs:0x28,%rax
mov %rax,0x218(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%r13
lea 0x48(%rsp),%rbx
mov %r13,%rdi
callq 47b0 <_ZNSt6localeC1Ev@plt>
mov %r13,%rsi
mov %rbx,%rdi
mov %rbx,0x18(%rsp)
movl $0x10,0x40(%rsp)
callq 4530 <_ZNSt6localeC1ERKS_@plt>
lea 0x80(%rsp),%rax
mov 0x40(%rsp),%r8d
mov %rbx,%rcx
lea 0x160ec(%rip),%rdx
mov %rax,%rdi
mov %rax,0x20(%rsp)
lea -0xc(%rdx),%rsi
callq 19890 <_ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC1EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE>
movdqa 0x180(%rsp),%xmm3
mov 0x1b0(%rsp),%rdi
pxor %xmm0,%xmm0
movaps %xmm0,0x180(%rsp)
movaps %xmm3,0x50(%rsp)
test %rdi,%rdi
je 567f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xdf>
mov 0x1f8(%rsp),%rax
mov 0x1d8(%rsp),%rbp
lea 0x8(%rax),%rbx
cmp %rbp,%rbx
jbe 567a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xda>
mov 0x0(%rbp),%rdi
add $0x8,%rbp
callq 45e0 <_ZdlPv@plt>
cmp %rbp,%rbx
ja 5660 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xc0>
mov 0x1b0(%rsp),%rdi
callq 45e0 <_ZdlPv@plt>
mov 0x190(%rsp),%rdi
lea 0x1a0(%rsp),%rax
cmp %rax,%rdi
je 5699 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf9>
callq 45e0 <_ZdlPv@plt>
mov 0x188(%rsp),%rbp
test %rbp,%rbp
je 56d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x1c91b(%rip),%rbx
test %rbx,%rbx
je 5b30 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x590>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 5b42 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5a2>
nopl 0x0(%rax)
mov 0x150(%rsp),%rdi
lea 0x160(%rsp),%rax
cmp %rax,%rdi
je 56ea <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14a>
callq 45e0 <_ZdlPv@plt>
mov %r13,%rdi
lea 0x90(%rsp),%rbp
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov (%r15),%rdi
pxor %xmm0,%xmm0
lea 0x40(%rsp),%rax
movq $0x0,0x10(%r12)
mov %rax,(%rsp)
mov %rdi,%rsi
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movups %xmm0,(%r12)
jmpq 57d1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x231>
nopw 0x0(%rax,%rax,1)
add $0x18,%rdi
cmpb $0x0,0x10(%rdi)
jne 5833 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x293>
mov %rbp,0x80(%rsp)
mov 0x8(%r12),%rbx
movq $0x0,0x88(%rsp)
movb $0x0,0x90(%rsp)
cmp 0x10(%r12),%rbx
je 5888 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2e8>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
mov 0x80(%rsp),%rax
cmp %rbp,%rax
je 59b0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x410>
mov %rax,(%rbx)
mov 0x90(%rsp),%rax
mov %rax,0x10(%rbx)
mov 0x88(%rsp),%rax
mov %rax,0x8(%rbx)
addq $0x20,0x8(%r12)
mov 0x68(%rsp),%rdx
mov 0x60(%rsp),%rax
mov %rdx,%rcx
sub %rax,%rcx
cmp %rax,%rdx
je 59a0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x400>
cmp $0x48,%rcx
je 59a0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x400>
lea -0x18(%rax,%rcx,1),%rax
mov (%rax),%rdi
mov (%r15),%rsi
mov (%rsp),%rcx
add 0x8(%r15),%rsi
xor %r8d,%r8d
mov %r13,%rdx
callq b510 <_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>
mov 0x60(%rsp),%rdi
test %al,%al
je 5a50 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4b0>
mov 0x68(%rsp),%rax
mov %rax,%rdx
sub %rdi,%rdx
cmp %rdi,%rax
je 5824 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x284>
movabs $0xaaaaaaaaaaaaaaab,%rbx
mov %rdx,%rax
sar $0x3,%rax
imul %rbx,%rax
sub $0x3,%rax
cmp $0x1,%rax
ja 5730 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x190>
lea -0x48(%rdi,%rdx,1),%rdi
cmpb $0x0,0x10(%rdi)
je 573e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19e>
mov (%rdi),%rbx
mov 0x8(%rdi),%r14
mov %rbp,0x80(%rsp)
sub %rbx,%r14
mov %r14,0x38(%rsp)
cmp $0xf,%r14
ja 5ae8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x548>
cmp $0x1,%r14
jne 5ad0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x530>
movzbl (%rbx),%eax
mov %al,0x90(%rsp)
mov %rbp,%rax
mov %r14,0x88(%rsp)
movb $0x0,(%rax,%r14,1)
mov 0x8(%r12),%rbx
cmp 0x10(%r12),%rbx
jne 576a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1ca>
mov (%r12),%rax
mov %rbx,%r14
movabs $0x3ffffffffffffff,%rcx
sub %rax,%r14
mov %rax,0x10(%rsp)
mov %r14,%rax
sar $0x5,%rax
cmp %rcx,%rax
je 5c0c <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x66c>
test %rax,%rax
je 5bc8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x628>
movabs $0x7fffffffffffffe0,%rcx
lea (%rax,%rax,1),%rdx
mov %rcx,0x8(%rsp)
cmp %rdx,%rax
jbe 59c8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x428>
mov 0x8(%rsp),%rdi
callq 45f0 <_Znwm@plt>
lea 0x20(%rax),%rcx
mov 0x8(%rsp),%r8
mov %rcx,0x8(%rsp)
add %rax,%r8
add %rax,%r14
lea 0x10(%r14),%rdx
mov %rdx,(%r14)
mov 0x80(%rsp),%rdx
cmp %rbp,%rdx
je 5be0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x640>
mov %rdx,(%r14)
mov 0x90(%rsp),%rdx
mov %rdx,0x10(%r14)
mov 0x88(%rsp),%rdx
mov %rbp,0x80(%rsp)
movq $0x0,0x88(%rsp)
mov %rdx,0x8(%r14)
mov 0x10(%rsp),%rdx
movb $0x0,0x90(%rsp)
cmp %rdx,%rbx
je 59f7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x457>
mov %rax,%rcx
jmp 5980 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3e0>
nopw %cs: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 59e8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x448>
lea 0x10(%rcx),%rsi
lea 0x10(%rdx),%rdi
mov %rsi,(%rcx)
mov (%rdx),%rsi
cmp %rdi,%rsi
jne 5960 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3c0>
movdqu 0x10(%rdx),%xmm1
movups %xmm1,0x10(%rcx)
jmp 596b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x3cb>
xchg %ax,%ax
lea -0x48(%rax,%rcx,1),%rax
jmpq 57cb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x22b>
nopw 0x0(%rax,%rax,1)
movdqa 0x90(%rsp),%xmm2
movups %xmm2,0x10(%rbx)
jmpq 5791 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f1>
nopw 0x0(%rax,%rax,1)
test %rdx,%rdx
jne 5c18 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x678>
movq $0x20,0x8(%rsp)
xor %r8d,%r8d
xor %eax,%eax
jmpq 58f1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x351>
nopl 0x0(%rax)
sub 0x10(%rsp),%rbx
lea 0x20(%rax,%rbx,1),%rbx
mov %rbx,0x8(%rsp)
mov 0x10(%rsp),%rdi
test %rdi,%rdi
je 5a1a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x47a>
mov %rax,0x28(%rsp)
mov %r8,0x10(%rsp)
callq 45e0 <_ZdlPv@plt>
mov 0x28(%rsp),%rax
mov 0x10(%rsp),%r8
movq %rax,%xmm0
mov 0x80(%rsp),%rdi
mov %r8,0x10(%r12)
movhps 0x8(%rsp),%xmm0
movups %xmm0,(%r12)
cmp %rbp,%rdi
je 57a3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x203>
callq 45e0 <_ZdlPv@plt>
jmpq 57a3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x203>
nopl 0x0(%rax)
test %rdi,%rdi
je 5a5a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4ba>
callq 45e0 <_ZdlPv@plt>
mov 0x58(%rsp),%rbp
test %rbp,%rbp
je 5a90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f0>
mov 0x1c55d(%rip),%rbx
test %rbx,%rbx
je 5b80 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5e0>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 5b92 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5f2>
nopw 0x0(%rax,%rax,1)
mov 0x18(%rsp),%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x218(%rsp),%rax
xor %fs:0x28,%rax
jne 5c3f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x69f>
add $0x228,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw %cs:0x0(%rax,%rax,1)
test %r14,%r14
jne 5c37 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x697>
mov %rbp,%rax
jmpq 586b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2cb>
nopl 0x0(%rax)
mov 0x20(%rsp),%rdi
lea 0x38(%rsp),%rsi
xor %edx,%edx
callq 4750 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm@plt>
mov %rax,0x80(%rsp)
mov %rax,%rdi
mov 0x38(%rsp),%rax
mov %rax,0x90(%rsp)
mov %r14,%rdx
mov %rbx,%rsi
callq 45a0 <memcpy@plt>
mov 0x38(%rsp),%r14
mov 0x80(%rsp),%rax
jmpq 586b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x2cb>
xchg %ax,%ax
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 56d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5bf3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x653>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 56d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 56d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 5a90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5c01 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x661>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 5a90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 5a90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x4f0>
nopl 0x0(%rax,%rax,1)
movq $0x20,0x8(%rsp)
jmpq 58d6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x336>
nopw %cs:0x0(%rax,%rax,1)
movdqa 0x90(%rsp),%xmm4
movups %xmm4,0x10(%r14)
jmpq 591b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x37b>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmpq 5b5f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x5bf>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 5bab <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x60b>
lea 0x155af(%rip),%rdi
callq 4500 <_ZSt20__throw_length_errorPKc@plt>
movabs $0x3ffffffffffffff,%rax
cmp %rax,%rdx
cmova %rax,%rdx
shl $0x5,%rdx
mov %rdx,0x8(%rsp)
jmpq 58d6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x336>
mov %rbp,%rdi
jmpq 5b11 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x571>
callq 4640 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 484b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x15>
endbr64
mov %rax,%rbp
jmpq 4873 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x3d>
endbr64
mov %rax,%rbx
jmpq 4836 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 2F8h
mov [rsp+328h+var_318], rsi
lea rbx, [rsp+328h+var_2A0]
mov rdi, rbx; this
mov rax, fs:28h
mov [rsp+328h+var_40], rax
xor eax, eax
mov [rsp+328h+var_2F0], rbx
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, asc_1A784+0Ch; ""
pxor xmm0, xmm0
lea rdi, [rsp+328h+var_1D8]
mov r8d, 10h
mov rcx, rbx
lea rsi, [rdx-0Ch]
mov [rsp+328h+var_2F8], rdi
movaps [rsp+328h+var_298], xmm0
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rsp+328h+var_D8]
mov rdi, qword ptr [rsp+328h+var_298+8]
pxor xmm1, xmm1
movaps [rsp+328h+var_D8], xmm1
movaps [rsp+328h+var_298], xmm0
test rdi, rdi
jz short loc_5E06
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5E06:
mov rdi, [rsp+328h+var_A8]
mov [rsp+328h+var_2A8], 10h
test rdi, rdi
jz short loc_5E73
mov rax, [rsp+328h+var_60]
mov rbx, [rsp+328h+var_80]
lea rbp, [rax+8]
cmp rbx, rbp
jnb short loc_5E5E
nop word ptr [rax+rax+00000000h]
loc_5E40:
mov rdi, [rbx]; void *
mov esi, 1F8h; unsigned __int64
add rbx, 8
call __ZdlPvm; operator delete(void *,ulong)
cmp rbx, rbp
jb short loc_5E40
mov rdi, [rsp+328h+var_A8]; void *
loc_5E5E:
mov rax, [rsp+328h+var_A0]
lea rsi, ds:0[rax*8]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E73:
lea rdi, [rsp+328h+var_C8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, qword ptr [rsp+328h+var_D8+8]
test rdi, rdi
jz short loc_5E92
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5E92:
lea rdi, [rsp+328h+var_108]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rax, [rsp+328h+var_318]
mov rdx, qword ptr [rsp+328h+var_298]
pxor xmm0, xmm0
mov qword ptr [r13+10h], 0
mov r12, [rax]
mov rbx, [rax+8]
movaps [rsp+328h+var_288], xmm0
movaps [rsp+328h+var_278], xmm0
movups xmmword ptr [r13+0], xmm0
test rdx, rdx
jz loc_6A80
lea rdi, [rsp+328h+var_2A8]
add rbx, r12
xor esi, esi
xor eax, eax
mov [rsp+328h+var_308], rdi
xor ecx, ecx
lea rdi, [rsp+328h+var_288]
mov r15, 0AAAAAAAAAAAAAAABh
mov [rsp+328h+var_310], rdi
nop word ptr [rax+rax+00h]
loc_5F10:
sub rcx, rax
mov rdi, [rdx+28h]
mov qword ptr [rsp+328h+var_278+8], r12
sar rcx, 3
imul rcx, r15
add edi, 3
cmp rcx, rdi
jb loc_6580
mov rcx, rsi
sub rcx, rax
sar rcx, 3
imul rcx, r15
cmp rcx, rdi
jnb loc_6510
cmp rax, rsi
jz short loc_5F65
nop
loc_5F50:
pxor xmm2, xmm2
mov byte ptr [rax+10h], 0
add rax, 18h
movups xmmword ptr [rax-18h], xmm2
cmp rsi, rax
jnz short loc_5F50
loc_5F65:
sub rdi, rcx
mov rax, rsi
mov rcx, rdi
xchg ax, ax
loc_5F70:
pxor xmm3, xmm3
mov byte ptr [rax+10h], 0
add rax, 18h
movups xmmword ptr [rax-18h], xmm3
sub rcx, 1
jnz short loc_5F70
lea rax, [rdi+rdi*2]
lea rax, [rsi+rax*8]
mov qword ptr [rsp+328h+var_288+8], rax
loc_5F96:
mov rcx, [rdx+40h]
sub rcx, [rdx+38h]
mov rbp, rcx
sar rbp, 4
mov rax, rbp
imul rax, r15
mov rbp, rax
test byte ptr [rsp+328h+var_2A8+1], 4
jnz loc_6610
mov rsi, [rsp+328h+var_308]
pxor xmm6, xmm6
mov [rsp+328h+var_248], r12
mov [rsp+328h+var_240], rbx
mov [rsp+328h+var_238], rsi
mov rsi, [rsp+328h+var_310]
mov [rsp+328h+var_230], rdx
mov [rsp+328h+var_228], rsi
movaps [rsp+328h+var_268], xmm6
movaps [rsp+328h+var_258], xmm6
test rcx, rcx
js loc_6AC5
mov [rsp+328h+var_210], 0
pxor xmm7, xmm7
movups xmmword ptr [rsp+328h+var_220], xmm7
jz loc_6870
shl rax, 4
mov rdi, rax; unsigned __int64
mov rbp, rax
call __Znwm; operator new(ulong)
add rbp, rax
mov [rsp+328h+var_220], rax
mov [rsp+328h+var_210], rbp
nop dword ptr [rax+00h]
loc_6050:
mov qword ptr [rax], 0
add rax, 10h
mov dword ptr [rax-8], 0
cmp rax, rbp
jnz short loc_6050
mov rdx, [rsp+328h+var_230]
mov rsi, [rsp+328h+var_228]
loc_6077:
mov rax, [rdx+20h]
mov [rsp+328h+var_220+8], rbp
lea rbp, [rsp+328h+var_268]
mov rdi, rbp
mov byte ptr [rsp+328h+var_1F8+4], 0
mov [rsp+328h+var_208], rax
mov rax, [rsp+328h+var_248]
mov [rsp+328h+var_208+8], 0
mov dword ptr [rsp+328h+var_1F8], 0
mov qword ptr [rsp+328h+var_258+8], rax
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 rdx, [rsp+328h+var_208]
mov esi, 1
mov rdi, rbp
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb1EE6_M_dfsENSH_11_Match_modeEl; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_Match_mode,long)
cmp byte ptr [rsp+328h+var_1F8+4], 0
jnz loc_62B8
mov eax, dword ptr [rsp+328h+var_1F8]
test al, 40h
jnz short loc_6175
or al, 80h
mov dword ptr [rsp+328h+var_1F8], eax
jmp short loc_6163
loc_6108:
mov rsi, [rsp+328h+var_228]
add rax, 1
mov rdi, rbp
mov byte ptr [rsp+328h+var_1F8+4], 0
mov [rsp+328h+var_248], rax
mov qword ptr [rsp+328h+var_258+8], rax
mov [rsp+328h+var_208+8], 0
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 rdx, [rsp+328h+var_208]
mov esi, 1
mov rdi, rbp
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb1EE6_M_dfsENSH_11_Match_modeEl; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_Match_mode,long)
cmp byte ptr [rsp+328h+var_1F8+4], 0
jnz loc_62B8
loc_6163:
mov rax, [rsp+328h+var_248]
cmp rax, [rsp+328h+var_240]
jnz short loc_6108
loc_6175:
mov rdi, [rsp+328h+var_220]; void *
test rdi, rdi
jz short loc_6192
mov rsi, [rsp+328h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6192:
mov rdi, rbp
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_619A:
mov rax, qword ptr [rsp+328h+var_288]
movq xmm1, rbx
mov rdx, qword ptr [rsp+328h+var_278]
mov [rsp+328h+var_2D8], 0
punpcklqdq xmm1, xmm1
sub rdx, rax
movaps [rsp+328h+var_328], xmm1
cmp rdx, 30h ; '0'
jbe loc_69F0
mov rdx, qword ptr [rsp+328h+var_288+8]
mov rcx, rdx
sub rcx, rax
cmp rcx, 30h ; '0'
ja loc_6980
cmp rax, rdx
jz short loc_6206
nop word ptr [rax+rax+00h]
loc_61F0:
movdqa xmm7, [rsp+328h+var_328]
mov byte ptr [rax+10h], 0
add rax, 18h
movups xmmword ptr [rax-18h], xmm7
cmp rdx, rax
jnz short loc_61F0
loc_6206:
sar rcx, 3
movdqa xmm0, [rsp+328h+var_328]
mov rsi, [rsp+328h+var_2D8]
mov rax, 0AAAAAAAAAAAAAAABh
imul rcx, rax
mov eax, 3
mov [rdx+10h], rsi
movups xmmword ptr [rdx], xmm0
sub rax, rcx
cmp rax, 1
jz short loc_624C
mov [rdx+28h], rsi
movups xmmword ptr [rdx+18h], xmm0
test rcx, rcx
jnz short loc_624C
mov [rdx+40h], rsi
movups xmmword ptr [rdx+30h], xmm0
loc_624C:
lea rax, [rax+rax*2]
lea rax, [rdx+rax*8]
mov qword ptr [rsp+328h+var_288+8], rax
nop dword ptr [rax+00h]
loc_6260:
mov rdi, [rsp+328h+var_310]
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 [rsp+328h+var_298+8]
test rdi, rdi
jz short loc_627C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_627C:
mov rdi, [rsp+328h+var_2F0]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rsp+328h+var_40]
sub rax, fs:28h
jnz loc_6AEE
add rsp, 2F8h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_62B8:
mov rdi, [rsp+328h+var_220]; void *
test rdi, rdi
jz short loc_62D5
mov rsi, [rsp+328h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_62D5:
mov rdi, rbp
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_62DD:
mov rdx, qword ptr [rsp+328h+var_288]
mov rcx, qword ptr [rsp+328h+var_288+8]
mov rax, rdx
cmp rdx, rcx
jz short loc_630E
nop dword ptr [rax]
loc_62F8:
cmp byte ptr [rax+10h], 0
jnz short loc_6305
mov [rax+8], rbx
mov [rax], rbx
loc_6305:
add rax, 18h
cmp rcx, rax
jnz short loc_62F8
loc_630E:
mov [rcx-30h], r12
mov r8, [rdx]
mov rdi, rcx
sub rdi, rdx
mov [rcx-28h], r8
mov rsi, [rdx+8]
cmp r8, r12
setnz byte ptr [rcx-20h]
cmp rsi, rbx
mov [rcx-18h], rsi
mov [rcx-10h], rbx
setnz byte ptr [rcx-8]
cmp rdx, rcx
jz loc_6428
mov rax, rdi
sar rax, 3
imul rax, r15
sub rax, 3
cmp rax, 1
jbe loc_6428
add rdx, 18h
cmp byte ptr [rdx+10h], 0
jnz loc_6437
loc_6369:
lea rbx, [rsp+328h+var_1C8]
mov byte ptr [rsp+328h+var_1C8], 0
mov rsi, [r13+8]
mov [rsp+328h+var_1D8], rbx
mov [rsp+328h+var_1D0], 0
cmp rsi, [r13+10h]
jz loc_64A2
loc_639B:
lea rdx, [rsi+10h]
mov [rsi], rdx
mov rax, [rsp+328h+var_1D8]
cmp rax, rbx
jz loc_68A0
mov [rsi], rax
mov rax, [rsp+328h+var_1C8]
mov [rsi+10h], rax
mov rax, [rsp+328h+var_1D0]
loc_63CA:
mov [rsi+8], rax
add qword ptr [r13+8], 20h ; ' '
loc_63D3:
mov rsi, qword ptr [rsp+328h+var_288+8]
mov rax, qword ptr [rsp+328h+var_288]
mov rdx, rsi
sub rdx, rax
cmp rdx, 48h ; 'H'
jbe loc_64E0
mov rdx, [rsp+328h+var_318]
mov r12, [rsi-18h]
mov rbx, [rdx]
mov rcx, [rdx+8]
mov rdx, qword ptr [rsp+328h+var_298]
test rdx, rdx
jz loc_6260
loc_6414:
add rbx, rcx
mov rcx, qword ptr [rsp+328h+var_278]
jmp loc_5F10
loc_6428:
lea rdx, [rdx+rdi-48h]
cmp byte ptr [rdx+10h], 0
jz loc_6369
loc_6437:
mov r14, [rdx]
mov r12, [rdx+8]
lea rbx, [rsp+328h+var_1C8]
mov [rsp+328h+var_1D0], 0
mov [rsp+328h+var_1D8], rbx
sub r12, r14
mov qword ptr [rsp+328h+var_268], r12
cmp r12, 0Fh
ja loc_6930
cmp r12, 1
jnz loc_6920
movzx eax, byte ptr [r14]
mov byte ptr [rsp+328h+var_1C8], al
loc_6484:
mov rax, rbx
loc_6487:
mov [rsp+328h+var_1D0], r12
mov byte ptr [rax+r12], 0
mov rsi, [r13+8]
cmp rsi, [r13+10h]
jnz loc_639B
loc_64A2:
mov rdx, [rsp+328h+var_2F8]
mov rdi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE17_M_realloc_insertIJS5_EEEvN9__gnu_cxx17__normal_iteratorIPS5_S7_EEDpOT_; std::vector<std::string>::_M_realloc_insert<std::string>(__gnu_cxx::__normal_iterator<std::string*,std::vector<std::string>>,std::string &&)
mov rdi, [rsp+328h+var_1D8]; void *
cmp rdi, rbx
jz loc_63D3
mov rax, [rsp+328h+var_1C8]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_63D3
loc_64E0:
mov rcx, [rsp+328h+var_318]
mov rdx, qword ptr [rsp+328h+var_298]
mov r12, [rsi-48h]
mov rbx, [rcx]
mov rcx, [rcx+8]
test rdx, rdx
jnz loc_6414
jmp loc_6260
loc_6510:
test rdi, rdi
jz short loc_6569
lea rdi, [rdi+rdi*2]
mov rcx, rax
shl rdi, 3
lea r8, [rax+rdi]
nop dword ptr [rax+00h]
loc_6528:
pxor xmm5, xmm5
mov byte ptr [rcx+10h], 0
add rcx, 18h
movups xmmword ptr [rcx-18h], xmm5
cmp r8, rcx
jnz short loc_6528
mov rcx, 0AAAAAAAAAAAAAABh
sub rdi, 18h
shr rdi, 3
imul rdi, rcx
mov rcx, 1FFFFFFFFFFFFFFFh
and rdi, rcx
lea rcx, [rdi+rdi*2+3]
lea rax, [rax+rcx*8]
loc_6569:
cmp rsi, rax
jz loc_5F96
mov qword ptr [rsp+328h+var_288+8], rax
jmp loc_5F96
loc_6580:
lea rbp, [rdi+rdi*2]
pxor xmm0, xmm0
mov [rsp+328h+var_2B8], 0
shl rbp, 3
movaps [rsp+328h+var_2C8], xmm0
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
add rbp, rax
mov rdx, rax
nop dword ptr [rax+rax+00000000h]
loc_65B0:
pxor xmm4, xmm4
mov byte ptr [rdx+10h], 0
add rdx, 18h
movups xmmword ptr [rdx-18h], xmm4
cmp rdx, rbp
jnz short loc_65B0
movdqa xmm0, [rsp+328h+var_288]
mov rcx, qword ptr [rsp+328h+var_278]
lea rdi, [rsp+328h+var_2C8]
mov qword ptr [rsp+328h+var_288+8], rdx
mov qword ptr [rsp+328h+var_278], rdx
mov [rsp+328h+var_2B8], rcx
mov qword ptr [rsp+328h+var_288], rax
movaps [rsp+328h+var_2C8], xmm0
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 rdx, qword ptr [rsp+328h+var_298]
jmp loc_5F96
loc_6610:
mov rsi, [rsp+328h+var_308]
pxor xmm1, xmm1
mov [rsp+328h+var_248], r12
mov [rsp+328h+var_240], rbx
mov [rsp+328h+var_238], rsi
mov rsi, [rsp+328h+var_310]
mov [rsp+328h+var_230], rdx
mov [rsp+328h+var_228], rsi
movaps [rsp+328h+var_268], xmm1
movaps [rsp+328h+var_258], xmm1
test rcx, rcx
js loc_6AA6
mov [rsp+328h+var_210], 0
pxor xmm7, xmm7
movups xmmword ptr [rsp+328h+var_220], xmm7
test rax, rax
jz loc_6900
shl rax, 4
mov rdi, rax; unsigned __int64
mov rbp, rax
call __Znwm; operator new(ulong)
lea rcx, [rax+rbp]
mov [rsp+328h+var_220], rax
mov [rsp+328h+var_210], rcx
nop dword ptr [rax+rax+00h]
loc_66A8:
mov qword ptr [rax], 0
add rax, 10h
mov dword ptr [rax-8], 0
cmp rax, rcx
jnz short loc_66A8
mov rdx, [rsp+328h+var_230]
mov rbp, [rdx+40h]
sub rbp, [rdx+38h]
sar rbp, 4
imul rbp, r15
loc_66D7:
pxor xmm5, xmm5
mov rdi, rbp; unsigned __int64
mov r14, [rdx+20h]
mov [rsp+328h+var_220+8], rcx
mov [rsp+328h+var_1F8], 0
movaps xmmword ptr [rsp+328h+var_208], xmm5
call __Znam; operator new[](ulong)
mov rcx, rax
mov rax, rbp
sub rax, 1
js short loc_671F
mov rdi, rcx; s
mov rdx, rbp; n
xor esi, esi; c
call _memset
mov rcx, rax
loc_671F:
mov rax, [rsp+328h+var_248]
lea rbp, [rsp+328h+var_268]
mov [rsp+328h+var_1F0], rcx
mov rdi, rbp
mov [rsp+328h+var_1E8], r14
mov [rsp+328h+var_1E0], 0
mov qword ptr [rsp+328h+var_258+8], rax
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb0EE16_M_main_dispatchENSH_11_Match_modeESt17integral_constantIbLb0EE_constprop_0; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_Match_mode,std::integral_constant<bool,false>) [clone]
mov [rsp+328h+var_2F9], al
test al, al
jnz loc_6890
mov eax, [rsp+328h+var_1E0]
test al, 40h
jnz short loc_67B6
or al, 80h
mov [rsp+328h+var_1E0], eax
jmp short loc_67A4
loc_6780:
add rax, 1
mov rdi, rbp
mov [rsp+328h+var_248], rax
mov qword ptr [rsp+328h+var_258+8], rax
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb0EE16_M_main_dispatchENSH_11_Match_modeESt17integral_constantIbLb0EE_constprop_0; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_Match_mode,std::integral_constant<bool,false>) [clone]
test al, al
jnz loc_6890
loc_67A4:
mov rax, [rsp+328h+var_248]
cmp rax, [rsp+328h+var_240]
jnz short loc_6780
loc_67B6:
mov rdi, [rsp+328h+var_1F0]; void *
test rdi, rdi
jz short loc_67C8
call __ZdaPv; operator delete[](void *)
loc_67C8:
mov rax, [rsp+328h+var_208+8]
mov r14, [rsp+328h+var_208]
mov qword ptr [rsp+328h+var_328], rax
cmp rax, r14
jz short loc_680F
nop dword ptr [rax+00000000h]
loc_67E8:
mov rdi, [r14+8]; void *
test rdi, rdi
jz short loc_6860
mov rsi, [r14+18h]
add r14, 20h ; ' '
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
cmp qword ptr [rsp+328h+var_328], r14
jnz short loc_67E8
loc_6807:
mov r14, [rsp+328h+var_208]
loc_680F:
test r14, r14
jz short loc_6827
mov rsi, [rsp+328h+var_1F8]
mov rdi, r14; void *
sub rsi, r14; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6827:
mov rdi, [rsp+328h+var_220]; void *
test rdi, rdi
jz short loc_6844
mov rsi, [rsp+328h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6844:
mov rdi, rbp
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()
cmp [rsp+328h+var_2F9], 0
jnz loc_62DD
jmp loc_619A
loc_6860:
add r14, 20h ; ' '
cmp qword ptr [rsp+328h+var_328], r14
jnz loc_67E8
jmp short loc_6807
loc_6870:
mov [rsp+328h+var_220], 0
xor ebp, ebp
mov [rsp+328h+var_210], 0
jmp loc_6077
loc_6890:
mov [rsp+328h+var_2F9], 1
jmp loc_67B6
loc_68A0:
mov rax, [rsp+328h+var_1D0]
lea rcx, [rax+1]
cmp ecx, 8
jb loc_69B8
mov rdi, [rbx]
mov [rsi+10h], rdi
mov edi, ecx
mov r8, [rbx+rdi-8]
mov [rdx+rdi-8], r8
lea rdi, [rsi+18h]
and rdi, 0FFFFFFFFFFFFFFF8h
sub rdx, rdi
add ecx, edx
sub rbx, rdx
and ecx, 0FFFFFFF8h
cmp ecx, 8
jb loc_63CA
and ecx, 0FFFFFFF8h
xor edx, edx
loc_68E9:
mov r8d, edx
add edx, 8
mov r9, [rbx+r8]
mov [rdi+r8], r9
cmp edx, ecx
jb short loc_68E9
jmp loc_63CA
loc_6900:
mov [rsp+328h+var_220], 0
xor ecx, ecx
mov [rsp+328h+var_210], 0
jmp loc_66D7
loc_6920:
test r12, r12
jz loc_6484
mov rdi, rbx
jmp short loc_695A
loc_6930:
mov rdi, [rsp+328h+var_2F8]
xor edx, edx
mov rsi, rbp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_createERmm; std::string::_M_create(ulong &,ulong)
mov [rsp+328h+var_1D8], rax
mov rdi, rax; dest
mov rax, qword ptr [rsp+328h+var_268]
mov [rsp+328h+var_1C8], rax
loc_695A:
mov rdx, r12; n
mov rsi, r14; src
call _memcpy
mov r12, qword ptr [rsp+328h+var_268]
mov rax, [rsp+328h+var_1D8]
jmp loc_6487
loc_6980:
lea rcx, [rax+48h]
mov byte ptr [rax+10h], 0
mov byte ptr [rax+28h], 0
mov byte ptr [rax+40h], 0
movups xmmword ptr [rax], xmm1
movups xmmword ptr [rax+18h], xmm1
movups xmmword ptr [rax+30h], xmm1
cmp rdx, rcx
jz loc_6260
mov qword ptr [rsp+328h+var_288+8], rcx
jmp loc_6260
loc_69B8:
test cl, 4
jnz loc_6A92
test ecx, ecx
jz loc_63CA
movzx edi, byte ptr [rbx]
mov [rsi+10h], dil
test cl, 2
jz loc_63CA
mov ecx, ecx
movzx edi, word ptr [rbx+rcx-2]
mov [rdx+rcx-2], di
jmp loc_63CA
loc_69F0:
pxor xmm0, xmm0
mov edi, 48h ; 'H'; unsigned __int64
mov qword ptr [rsp+328h+var_258], 0
movaps [rsp+328h+var_268], xmm0
call __Znwm; operator new(ulong)
mov rdx, [rsp+328h+var_2D8]
movdqa xmm0, [rsp+328h+var_328]
lea rcx, [rax+48h]
mov rdi, rbp
mov [rax+10h], rdx
mov [rax+28h], rdx
mov [rax+40h], rdx
mov rdx, qword ptr [rsp+328h+var_278]
movups xmmword ptr [rax], xmm0
movups xmmword ptr [rax+18h], xmm0
movups xmmword ptr [rax+30h], xmm0
movdqa xmm0, [rsp+328h+var_288]
mov qword ptr [rsp+328h+var_258], rdx
mov qword ptr [rsp+328h+var_288], rax
mov qword ptr [rsp+328h+var_288+8], rcx
mov qword ptr [rsp+328h+var_278], rcx
movaps [rsp+328h+var_268], xmm0
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_6260
loc_6A80:
lea rax, [rsp+328h+var_288]
mov [rsp+328h+var_310], rax
jmp loc_6260
loc_6A92:
mov edi, [rbx]
mov ecx, ecx
mov [rsi+10h], edi
mov edi, [rbx+rcx-4]
mov [rdx+rcx-4], edi
jmp loc_63CA
loc_6AA6:
mov rax, [rsp+328h+var_40]
sub rax, fs:28h
jnz short loc_6AE4
lea rdi, aCannotCreateSt_0; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_6AC5:
mov rax, [rsp+328h+var_40]
sub rax, fs:28h
jnz short loc_6AE9
lea rdi, aCannotCreateSt_0; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_6AE4:
call ___stack_chk_fail
loc_6AE9:
call ___stack_chk_fail
loc_6AEE:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
jmp loc_47E1
endbr64
mov rbx, rax
jmp loc_4841
endbr64
mov rbx, rax
jmp loc_4850
endbr64
mov rbx, rax
jmp loc_4827
endbr64
mov rbx, rax
jmp loc_485A
endbr64
mov rbx, rax
jmp loc_4874
endbr64
mov rbx, rax
jmp loc_47EB | long long func0(long long a1, long long *a2)
{
char *v3; // rsi
__m128i v4; // xmm0
long long v5; // rdi
void *v6; // rdi
void **v7; // rbx
unsigned long long v8; // rbp
void *v9; // rdi
long long *v10; // rax
_QWORD *v11; // rdx
long long v12; // r12
long long v13; // rbx
unsigned long long v14; // rbx
long long v15; // rax
long long v16; // rcx
long long v17; // rdi
unsigned long long v18; // rdi
unsigned long long v19; // rcx
unsigned long long v20; // rdi
char *v21; // rax
unsigned long long v22; // rcx
long long v23; // rcx
unsigned long long v24; // rbp
__m128i *v25; // rsi
unsigned long long v26; // rbp
char *v27; // rax
char *v28; // rbp
void *v29; // rax
int v30; // eax
long long v31; // rax
__m128i v32; // xmm1
long long v33; // rdx
long long v34; // rcx
__m128i v35; // xmm7
__m128i v36; // xmm0
unsigned long long v37; // rcx
__m128i v39; // kr00_16
long long i; // rax
long long v41; // r8
long long v42; // rsi
long long v43; // rdx
long long v44; // rsi
long long v45; // rdx
size_t v46; // rax
long long v47; // rbx
long long v48; // rcx
_BYTE *v49; // r14
long long v50; // r12
size_t v51; // r12
_QWORD *v52; // rax
long long v53; // rcx
long long v54; // rdi
__m128i v55; // rax
__m128i v56; // xmm0
long long v57; // rcx
unsigned long long v58; // rbp
_QWORD *v59; // rax
_QWORD *v60; // rcx
long long v61; // r14
void *v62; // rcx
int v63; // eax
_QWORD *v64; // r14
void *v65; // rdi
long long v66; // rsi
unsigned int v67; // ecx
unsigned long long v68; // rdi
long long v69; // rdx
char *v70; // rbx
unsigned int v71; // ecx
unsigned int v72; // ecx
unsigned int v73; // edx
long long v74; // r8
_QWORD *v75; // rdi
long long v76; // rax
char *v77; // rdx
__m128i v78; // xmm0
long long v79; // rdx
__m128i v80; // xmm0
__m128i v81; // [rsp+0h] [rbp-328h] BYREF
long long *v82; // [rsp+10h] [rbp-318h]
__m128i *v83; // [rsp+18h] [rbp-310h]
int *v84; // [rsp+20h] [rbp-308h]
char v85; // [rsp+2Fh] [rbp-2F9h]
void **v86; // [rsp+30h] [rbp-2F8h]
std::locale *v87; // [rsp+38h] [rbp-2F0h]
char *v88; // [rsp+50h] [rbp-2D8h]
__m128i v89; // [rsp+60h] [rbp-2C8h] BYREF
long long v90; // [rsp+70h] [rbp-2B8h]
int v91; // [rsp+80h] [rbp-2A8h] BYREF
char v92[8]; // [rsp+88h] [rbp-2A0h] BYREF
__m128i v93; // [rsp+90h] [rbp-298h]
__m128i v94; // [rsp+A0h] [rbp-288h] BYREF
__int128 v95; // [rsp+B0h] [rbp-278h]
__m128i v96; // [rsp+C0h] [rbp-268h] BYREF
__int128 v97; // [rsp+D0h] [rbp-258h]
long long v98; // [rsp+E0h] [rbp-248h]
unsigned long long v99; // [rsp+E8h] [rbp-240h]
int *v100; // [rsp+F0h] [rbp-238h]
_QWORD *v101; // [rsp+F8h] [rbp-230h]
__m128i *v102; // [rsp+100h] [rbp-228h]
void *v103[2]; // [rsp+108h] [rbp-220h]
char *v104; // [rsp+118h] [rbp-210h]
void *v105[2]; // [rsp+120h] [rbp-208h]
long long v106; // [rsp+130h] [rbp-1F8h]
void *v107; // [rsp+138h] [rbp-1F0h]
long long v108; // [rsp+140h] [rbp-1E8h]
int v109; // [rsp+148h] [rbp-1E0h]
void *v110; // [rsp+150h] [rbp-1D8h] BYREF
size_t v111; // [rsp+158h] [rbp-1D0h]
_QWORD v112[24]; // [rsp+160h] [rbp-1C8h] BYREF
char v113[48]; // [rsp+220h] [rbp-108h] BYREF
__m128i v114; // [rsp+250h] [rbp-D8h] BYREF
char v115[32]; // [rsp+260h] [rbp-C8h] BYREF
void *v116; // [rsp+280h] [rbp-A8h]
long long v117; // [rsp+288h] [rbp-A0h]
unsigned long long v118; // [rsp+2A8h] [rbp-80h]
long long v119; // [rsp+2C8h] [rbp-60h]
unsigned long long v120; // [rsp+2E8h] [rbp-40h]
v82 = a2;
v120 = __readfsqword(0x28u);
v87 = (std::locale *)v92;
std::locale::locale((std::locale *)v92);
v3 = "\\\"([^\\\"]*)\\\"";
v86 = &v110;
v93 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(&v110, "\\\"([^\\\"]*)\\\"", "", v92, 16LL);
v4 = _mm_load_si128(&v114);
v5 = v93.m128i_i64[1];
v114 = 0LL;
v93 = v4;
if ( v5 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v6 = v116;
v91 = 16;
if ( v116 )
{
v7 = (void **)v118;
v8 = v119 + 8;
if ( v118 < v119 + 8 )
{
do
{
v9 = *v7++;
operator delete(v9, 0x1F8uLL);
}
while ( (unsigned long long)v7 < v8 );
v6 = v116;
}
v3 = (char *)(8 * v117);
operator delete(v6, 8 * v117);
}
std::string::_M_dispose(v115);
if ( v114.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::string::_M_dispose(v113);
v10 = v82;
v11 = (_QWORD *)v93.m128i_i64[0];
*(_QWORD *)(a1 + 16) = 0LL;
v12 = *v10;
v13 = v10[1];
v94 = 0LL;
v95 = 0LL;
*(_OWORD *)a1 = 0LL;
if ( !v11 )
{
v83 = &v94;
goto LABEL_41;
}
v14 = v12 + v13;
v3 = 0LL;
v15 = 0LL;
v84 = &v91;
v16 = 0LL;
v83 = &v94;
while ( 1 )
{
v17 = v11[5];
*((_QWORD *)&v95 + 1) = v12;
v18 = (unsigned int)(v17 + 3);
if ( 0xAAAAAAAAAAAAAAABLL * ((v16 - v15) >> 3) < v18 )
{
v90 = 0LL;
v89 = 0LL;
v55.m128i_i64[0] = operator new(24 * v18);
v55.m128i_i64[1] = v55.m128i_i64[0];
do
{
*(_BYTE *)(v55.m128i_i64[1] + 16) = 0;
v55.m128i_i64[1] += 24LL;
*(_OWORD *)(v55.m128i_i64[1] - 24) = 0LL;
}
while ( v55.m128i_i64[1] != v55.m128i_i64[0] + 24 * v18 );
v56 = _mm_load_si128(&v94);
v57 = v95;
*(_QWORD *)&v95 = v55.m128i_i64[1];
v90 = v57;
v94 = v55;
v89 = v56;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v89, v3);
v11 = (_QWORD *)v93.m128i_i64[0];
}
else
{
v19 = 0xAAAAAAAAAAAAAAABLL * ((long long)&v3[-v15] >> 3);
if ( v19 >= v18 )
{
if ( v18 )
{
v53 = v15;
v54 = 24 * v18;
do
{
*(_BYTE *)(v53 + 16) = 0;
v53 += 24LL;
*(_OWORD *)(v53 - 24) = 0LL;
}
while ( v15 + v54 != v53 );
v15 += 8 * (3 * ((0xAAAAAAAAAAAAAABLL * ((unsigned long long)(v54 - 24) >> 3)) & 0x1FFFFFFFFFFFFFFFLL) + 3);
}
if ( v3 != (char *)v15 )
v94.m128i_i64[1] = v15;
}
else
{
if ( (char *)v15 != v3 )
{
do
{
*(_BYTE *)(v15 + 16) = 0;
v15 += 24LL;
*(_OWORD *)(v15 - 24) = 0LL;
}
while ( v3 != (char *)v15 );
}
v20 = v18 - v19;
v21 = v3;
v22 = v20;
do
{
v21[16] = 0;
v21 += 24;
*(_OWORD *)(v21 - 24) = 0LL;
--v22;
}
while ( v22 );
v94.m128i_i64[1] = (long long)&v3[24 * v20];
}
}
v23 = v11[8] - v11[7];
v24 = 0xAAAAAAAAAAAAAAABLL * (v23 >> 4);
if ( (v91 & 0x400) == 0 )
break;
v98 = v12;
v99 = v14;
v100 = v84;
v3 = (char *)v83;
v101 = v11;
v102 = v83;
v96 = 0LL;
v97 = 0LL;
if ( v23 < 0 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v104 = 0LL;
*(_OWORD *)v103 = 0LL;
if ( 0xAAAAAAAAAAAAAAABLL * (v23 >> 4) )
{
v58 = 0x1555555555555556LL * (v23 >> 4);
v59 = (_QWORD *)operator new(v58 * 8);
v60 = &v59[v58];
v103[0] = v59;
v104 = (char *)&v59[v58];
do
{
*v59 = 0LL;
v59 += 2;
*((_DWORD *)v59 - 2) = 0;
}
while ( v59 != v60 );
v11 = v101;
v24 = 0xAAAAAAAAAAAAAAABLL * ((long long)(v101[8] - v101[7]) >> 4);
}
else
{
v103[0] = 0LL;
v60 = 0LL;
v104 = 0LL;
}
v61 = v11[4];
v103[1] = v60;
v106 = 0LL;
*(_OWORD *)v105 = 0LL;
v62 = (void *)operator new[](v24);
if ( (long long)(v24 - 1) >= 0 )
{
v3 = 0LL;
v62 = memset(v62, 0, v24);
}
v107 = v62;
v108 = v61;
v109 = 0;
*((_QWORD *)&v97 + 1) = v98;
v85 = std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(&v96);
if ( v85 )
{
LABEL_107:
v85 = 1;
}
else
{
v63 = v109;
if ( (v109 & 0x40) == 0 )
{
LOBYTE(v63) = v109 | 0x80;
v109 = v63;
while ( v98 != v99 )
{
*((_QWORD *)&v97 + 1) = ++v98;
if ( (unsigned __int8)std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(&v96) )
goto LABEL_107;
}
}
}
if ( v107 )
operator delete[](v107);
v64 = v105[0];
v81.m128i_i64[0] = (long long)v105[1];
if ( v105[1] != v105[0] )
{
do
{
while ( 1 )
{
v65 = (void *)v64[1];
if ( !v65 )
break;
v66 = v64[3];
v64 += 4;
v3 = (char *)(v66 - (_QWORD)v65);
operator delete(v65, (unsigned long long)v3);
if ( (_QWORD *)v81.m128i_i64[0] == v64 )
goto LABEL_97;
}
v64 += 4;
}
while ( (_QWORD *)v81.m128i_i64[0] != v64 );
LABEL_97:
v64 = v105[0];
}
if ( v64 )
{
v3 = (char *)(v106 - (_QWORD)v64);
operator delete(v64, v106 - (_QWORD)v64);
}
if ( v103[0] )
{
v3 = (char *)(v104 - (char *)v103[0]);
operator delete(v103[0], v104 - (char *)v103[0]);
}
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v96, v3);
if ( !v85 )
goto LABEL_33;
LABEL_47:
v39 = v94;
for ( i = v94.m128i_i64[0]; v39.m128i_i64[1] != i; i += 24LL )
{
if ( !*(_BYTE *)(i + 16) )
{
*(_QWORD *)(i + 8) = v14;
*(_QWORD *)i = v14;
}
}
*(_QWORD *)(v39.m128i_i64[1] - 48) = v12;
v41 = *(_QWORD *)v39.m128i_i64[0];
*(_QWORD *)(v39.m128i_i64[1] - 40) = *(_QWORD *)v39.m128i_i64[0];
v42 = *(_QWORD *)(v39.m128i_i64[0] + 8);
*(_BYTE *)(v39.m128i_i64[1] - 32) = v41 != v12;
*(_QWORD *)(v39.m128i_i64[1] - 24) = v42;
*(_QWORD *)(v39.m128i_i64[1] - 16) = v14;
*(_BYTE *)(v39.m128i_i64[1] - 8) = v42 != v14;
if ( v39.m128i_i64[0] == v39.m128i_i64[1]
|| 0xAAAAAAAAAAAAAAABLL * ((v39.m128i_i64[1] - v39.m128i_i64[0]) >> 3) - 3 <= 1 )
{
v43 = v39.m128i_i64[1] - 72;
if ( !*(_BYTE *)(v39.m128i_i64[1] - 72 + 16) )
{
LABEL_54:
LOBYTE(v112[0]) = 0;
v44 = *(_QWORD *)(a1 + 8);
v110 = v112;
v111 = 0LL;
if ( v44 != *(_QWORD *)(a1 + 16) )
goto LABEL_55;
goto LABEL_67;
}
}
else
{
v43 = v39.m128i_i64[0] + 24;
if ( !*(_BYTE *)(v39.m128i_i64[0] + 40) )
goto LABEL_54;
}
v49 = *(_BYTE **)v43;
v50 = *(_QWORD *)(v43 + 8);
v111 = 0LL;
v110 = v112;
v51 = v50 - (_QWORD)v49;
v96.m128i_i64[0] = v51;
if ( v51 > 0xF )
{
v110 = (void *)std::string::_M_create(v86, &v96, 0LL);
v75 = v110;
v112[0] = v96.m128i_i64[0];
}
else
{
if ( v51 == 1 )
{
LOBYTE(v112[0]) = *v49;
LABEL_65:
v52 = v112;
goto LABEL_66;
}
if ( !v51 )
goto LABEL_65;
v75 = v112;
}
memcpy(v75, v49, v51);
v51 = v96.m128i_i64[0];
v52 = v110;
LABEL_66:
v111 = v51;
*((_BYTE *)v52 + v51) = 0;
v44 = *(_QWORD *)(a1 + 8);
if ( v44 != *(_QWORD *)(a1 + 16) )
{
LABEL_55:
v45 = v44 + 16;
*(_QWORD *)v44 = v44 + 16;
if ( v110 == v112 )
{
v46 = v111;
v67 = v111 + 1;
if ( (unsigned int)(v111 + 1) < 8 )
{
if ( (v67 & 4) != 0 )
{
*(_DWORD *)(v44 + 16) = v112[0];
*(_DWORD *)(v45 + v67 - 4) = *(_DWORD *)((char *)&v111 + v67 + 4);
}
else if ( (_DWORD)v111 != -1 )
{
*(_BYTE *)(v44 + 16) = v112[0];
if ( (v67 & 2) != 0 )
*(_WORD *)(v45 + v67 - 2) = *(_WORD *)((char *)&v111 + v67 + 6);
}
}
else
{
*(_QWORD *)(v44 + 16) = v112[0];
*(_QWORD *)(v45 + v67 - 8) = *(_QWORD *)((char *)&v112[-1] + v67);
v68 = (v44 + 24) & 0xFFFFFFFFFFFFFFF8LL;
v69 = v45 - v68;
v70 = (char *)v112 - v69;
v71 = (v69 + v67) & 0xFFFFFFF8;
if ( v71 >= 8 )
{
v72 = v71 & 0xFFFFFFF8;
v73 = 0;
do
{
v74 = v73;
v73 += 8;
*(_QWORD *)(v68 + v74) = *(_QWORD *)&v70[v74];
}
while ( v73 < v72 );
}
}
}
else
{
*(_QWORD *)v44 = v110;
*(_QWORD *)(v44 + 16) = v112[0];
v46 = v111;
}
*(_QWORD *)(v44 + 8) = v46;
*(_QWORD *)(a1 + 8) += 32LL;
goto LABEL_58;
}
LABEL_67:
std::vector<std::string>::_M_realloc_insert<std::string>(a1, v44, v86);
if ( v110 != v112 )
operator delete(v110, v112[0] + 1LL);
LABEL_58:
v3 = (char *)v94.m128i_i64[1];
v15 = v94.m128i_i64[0];
if ( v94.m128i_i64[1] - v94.m128i_i64[0] <= 0x48uLL )
{
v11 = (_QWORD *)v93.m128i_i64[0];
v12 = *(_QWORD *)(v94.m128i_i64[1] - 72);
v47 = *v82;
v48 = v82[1];
if ( !v93.m128i_i64[0] )
goto LABEL_41;
}
else
{
v12 = *(_QWORD *)(v94.m128i_i64[1] - 24);
v47 = *v82;
v48 = v82[1];
v11 = (_QWORD *)v93.m128i_i64[0];
if ( !v93.m128i_i64[0] )
goto LABEL_41;
}
v14 = v48 + v47;
v16 = v95;
}
v98 = v12;
v99 = v14;
v100 = v84;
v25 = v83;
v101 = v11;
v102 = v83;
v96 = 0LL;
v97 = 0LL;
if ( v23 < 0 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v104 = 0LL;
*(_OWORD *)v103 = 0LL;
if ( v23 )
{
v26 = 0xAAAAAAAAAAAAAAB0LL * (v23 >> 4);
v27 = (char *)operator new(v26);
v28 = &v27[v26];
v103[0] = v27;
v104 = v28;
do
{
*(_QWORD *)v27 = 0LL;
v27 += 16;
*((_DWORD *)v27 - 2) = 0;
}
while ( v27 != v28 );
v11 = v101;
v25 = v102;
}
else
{
v103[0] = 0LL;
v28 = 0LL;
v104 = 0LL;
}
v29 = (void *)v11[4];
v103[1] = v28;
BYTE4(v106) = 0;
v105[0] = v29;
v105[1] = 0LL;
LODWORD(v106) = 0;
*((_QWORD *)&v97 + 1) = v98;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(&v96, v25);
v3 = (_BYTE *)(&dword_0 + 1);
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(
&v96,
1LL,
v105[0]);
if ( BYTE4(v106) )
{
LABEL_44:
if ( v103[0] )
{
v3 = (char *)(v104 - (char *)v103[0]);
operator delete(v103[0], v104 - (char *)v103[0]);
}
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v96, v3);
goto LABEL_47;
}
v30 = v106;
if ( (v106 & 0x40) == 0 )
{
LOBYTE(v30) = v106 | 0x80;
LODWORD(v106) = v30;
while ( v98 != v99 )
{
BYTE4(v106) = 0;
*((_QWORD *)&v97 + 1) = ++v98;
v105[1] = 0LL;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(&v96, v102);
v3 = (_BYTE *)(&dword_0 + 1);
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(
&v96,
1LL,
v105[0]);
if ( BYTE4(v106) )
goto LABEL_44;
}
}
if ( v103[0] )
{
v3 = (char *)(v104 - (char *)v103[0]);
operator delete(v103[0], v104 - (char *)v103[0]);
}
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v96, v3);
LABEL_33:
v31 = v94.m128i_i64[0];
v88 = 0LL;
v32 = _mm_unpacklo_epi64((__m128i)v14, (__m128i)v14);
v81 = v32;
if ( (long long)v95 - v94.m128i_i64[0] <= 0x30uLL )
{
*(_QWORD *)&v97 = 0LL;
v96 = 0LL;
v76 = operator new(0x48uLL);
v77 = v88;
v78 = _mm_load_si128(&v81);
*(_QWORD *)(v76 + 16) = v88;
*(_QWORD *)(v76 + 40) = v77;
*(_QWORD *)(v76 + 64) = v77;
v79 = v95;
*(__m128i *)v76 = v78;
*(__m128i *)(v76 + 24) = v78;
*(__m128i *)(v76 + 48) = v78;
v80 = _mm_load_si128(&v94);
*(_QWORD *)&v97 = v79;
v94.m128i_i64[0] = v76;
v94.m128i_i64[1] = v76 + 72;
*(_QWORD *)&v95 = v76 + 72;
v96 = v80;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v96, v3);
}
else
{
v33 = v94.m128i_i64[1];
v34 = v94.m128i_i64[1] - v94.m128i_i64[0];
if ( v94.m128i_i64[1] - v94.m128i_i64[0] > 0x30uLL )
{
*(_BYTE *)(v94.m128i_i64[0] + 16) = 0;
*(_BYTE *)(v31 + 40) = 0;
*(_BYTE *)(v31 + 64) = 0;
*(__m128i *)v31 = v32;
*(__m128i *)(v31 + 24) = v32;
*(__m128i *)(v31 + 48) = v32;
if ( v33 != v31 + 72 )
v94.m128i_i64[1] = v31 + 72;
}
else
{
if ( v94.m128i_i64[0] != v94.m128i_i64[1] )
{
do
{
v35 = _mm_load_si128(&v81);
*(_BYTE *)(v31 + 16) = 0;
v31 += 24LL;
*(__m128i *)(v31 - 24) = v35;
}
while ( v33 != v31 );
}
v36 = _mm_load_si128(&v81);
v3 = v88;
v37 = 0xAAAAAAAAAAAAAAABLL * (v34 >> 3);
*(_QWORD *)(v33 + 16) = v88;
*(__m128i *)v33 = v36;
if ( v37 != 2 )
{
*(_QWORD *)(v33 + 40) = v3;
*(__m128i *)(v33 + 24) = v36;
if ( !v37 )
{
*(_QWORD *)(v33 + 64) = v3;
*(__m128i *)(v33 + 48) = v36;
}
}
v94.m128i_i64[1] = v33 + 24 * (3 - v37);
}
}
LABEL_41:
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(v83, v3);
if ( v93.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale(v87);
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2f8
MOV qword ptr [RSP + 0x10],RSI
LEA RBX,[RSP + 0x88]
MOV RDI,RBX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2e8],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x38],RBX
CALL 0x00104710
LEA RDX,[0x11a790]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x150]
MOV R8D,0x10
MOV RCX,RBX
LEA RSI,[RDX + -0xc]
MOV qword ptr [RSP + 0x30],RDI
MOVAPS xmmword ptr [RSP + 0x90],XMM0
LAB_00105dd2:
CALL 0x001190e0
MOVDQA XMM0,xmmword ptr [RSP + 0x250]
MOV RDI,qword ptr [RSP + 0x98]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RSP + 0x250],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM0
TEST RDI,RDI
JZ 0x00105e06
CALL 0x00107da0
LAB_00105e06:
MOV RDI,qword ptr [RSP + 0x280]
MOV dword ptr [RSP + 0x80],0x10
TEST RDI,RDI
JZ 0x00105e73
MOV RAX,qword ptr [RSP + 0x2c8]
MOV RBX,qword ptr [RSP + 0x2a8]
LEA RBP,[RAX + 0x8]
CMP RBX,RBP
JNC 0x00105e5e
NOP word ptr [RAX + RAX*0x1]
LAB_00105e40:
MOV RDI,qword ptr [RBX]
MOV ESI,0x1f8
ADD RBX,0x8
CALL 0x00104580
CMP RBX,RBP
JC 0x00105e40
MOV RDI,qword ptr [RSP + 0x280]
LAB_00105e5e:
MOV RAX,qword ptr [RSP + 0x288]
LEA RSI,[RAX*0x8]
CALL 0x00104580
LAB_00105e73:
LEA RDI,[RSP + 0x260]
CALL 0x00104600
MOV RDI,qword ptr [RSP + 0x258]
TEST RDI,RDI
JZ 0x00105e92
CALL 0x00107da0
LAB_00105e92:
LEA RDI,[RSP + 0x220]
CALL 0x00104600
MOV RAX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x90]
PXOR XMM0,XMM0
MOV qword ptr [R13 + 0x10],0x0
MOV R12,qword ptr [RAX]
MOV RBX,qword ptr [RAX + 0x8]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVUPS xmmword ptr [R13],XMM0
TEST RDX,RDX
JZ 0x00106a80
LEA RDI,[RSP + 0x80]
ADD RBX,R12
XOR ESI,ESI
XOR EAX,EAX
MOV qword ptr [RSP + 0x20],RDI
XOR ECX,ECX
LEA RDI,[RSP + 0xa0]
MOV R15,-0x5555555555555555
MOV qword ptr [RSP + 0x18],RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00105f10:
SUB RCX,RAX
MOV RDI,qword ptr [RDX + 0x28]
MOV qword ptr [RSP + 0xb8],R12
SAR RCX,0x3
IMUL RCX,R15
ADD EDI,0x3
CMP RCX,RDI
JC 0x00106580
MOV RCX,RSI
SUB RCX,RAX
SAR RCX,0x3
IMUL RCX,R15
CMP RCX,RDI
JNC 0x00106510
CMP RAX,RSI
JZ 0x00105f65
NOP
LAB_00105f50:
PXOR XMM2,XMM2
MOV byte ptr [RAX + 0x10],0x0
ADD RAX,0x18
MOVUPS xmmword ptr [RAX + -0x18],XMM2
CMP RSI,RAX
JNZ 0x00105f50
LAB_00105f65:
SUB RDI,RCX
MOV RAX,RSI
MOV RCX,RDI
NOP
LAB_00105f70:
PXOR XMM3,XMM3
MOV byte ptr [RAX + 0x10],0x0
ADD RAX,0x18
MOVUPS xmmword ptr [RAX + -0x18],XMM3
SUB RCX,0x1
JNZ 0x00105f70
LEA RAX,[RDI + RDI*0x2]
LEA RAX,[RSI + RAX*0x8]
MOV qword ptr [RSP + 0xa8],RAX
LAB_00105f96:
MOV RCX,qword ptr [RDX + 0x40]
SUB RCX,qword ptr [RDX + 0x38]
MOV RBP,RCX
SAR RBP,0x4
MOV RAX,RBP
IMUL RAX,R15
MOV RBP,RAX
TEST byte ptr [RSP + 0x81],0x4
JNZ 0x00106610
MOV RSI,qword ptr [RSP + 0x20]
PXOR XMM6,XMM6
MOV qword ptr [RSP + 0xe0],R12
MOV qword ptr [RSP + 0xe8],RBX
MOV qword ptr [RSP + 0xf0],RSI
MOV RSI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xf8],RDX
MOV qword ptr [RSP + 0x100],RSI
MOVAPS xmmword ptr [RSP + 0xc0],XMM6
MOVAPS xmmword ptr [RSP + 0xd0],XMM6
TEST RCX,RCX
JS 0x00106ac5
MOV qword ptr [RSP + 0x118],0x0
PXOR XMM7,XMM7
MOVUPS xmmword ptr [RSP + 0x108],XMM7
JZ 0x00106870
SHL RAX,0x4
MOV RDI,RAX
MOV RBP,RAX
LAB_00106034:
CALL 0x00104570
ADD RBP,RAX
MOV qword ptr [RSP + 0x108],RAX
MOV qword ptr [RSP + 0x118],RBP
NOP dword ptr [RAX]
LAB_00106050:
MOV qword ptr [RAX],0x0
ADD RAX,0x10
MOV dword ptr [RAX + -0x8],0x0
CMP RAX,RBP
JNZ 0x00106050
MOV RDX,qword ptr [RSP + 0xf8]
MOV RSI,qword ptr [RSP + 0x100]
LAB_00106077:
MOV RAX,qword ptr [RDX + 0x20]
MOV qword ptr [RSP + 0x110],RBP
LEA RBP,[RSP + 0xc0]
MOV RDI,RBP
MOV byte ptr [RSP + 0x134],0x0
MOV qword ptr [RSP + 0x120],RAX
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x128],0x0
MOV dword ptr [RSP + 0x130],0x0
MOV qword ptr [RSP + 0xd8],RAX
LAB_001060c5:
CALL 0x00105100
MOV RDX,qword ptr [RSP + 0x120]
MOV ESI,0x1
MOV RDI,RBP
CALL 0x0010e320
CMP byte ptr [RSP + 0x134],0x0
JNZ 0x001062b8
MOV EAX,dword ptr [RSP + 0x130]
TEST AL,0x40
JNZ 0x00106175
OR AL,0x80
MOV dword ptr [RSP + 0x130],EAX
JMP 0x00106163
LAB_00106108:
MOV RSI,qword ptr [RSP + 0x100]
ADD RAX,0x1
MOV RDI,RBP
MOV byte ptr [RSP + 0x134],0x0
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xd8],RAX
MOV qword ptr [RSP + 0x128],0x0
CALL 0x00105100
MOV RDX,qword ptr [RSP + 0x120]
MOV ESI,0x1
MOV RDI,RBP
CALL 0x0010e320
CMP byte ptr [RSP + 0x134],0x0
JNZ 0x001062b8
LAB_00106163:
MOV RAX,qword ptr [RSP + 0xe0]
CMP RAX,qword ptr [RSP + 0xe8]
JNZ 0x00106108
LAB_00106175:
MOV RDI,qword ptr [RSP + 0x108]
TEST RDI,RDI
JZ 0x00106192
MOV RSI,qword ptr [RSP + 0x118]
SUB RSI,RDI
CALL 0x00104580
LAB_00106192:
MOV RDI,RBP
CALL 0x00107ed0
LAB_0010619a:
MOV RAX,qword ptr [RSP + 0xa0]
MOVQ XMM1,RBX
MOV RDX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x50],0x0
PUNPCKLQDQ XMM1,XMM1
SUB RDX,RAX
MOVAPS xmmword ptr [RSP],XMM1
CMP RDX,0x30
JBE 0x001069f0
MOV RDX,qword ptr [RSP + 0xa8]
MOV RCX,RDX
SUB RCX,RAX
CMP RCX,0x30
JA 0x00106980
CMP RAX,RDX
JZ 0x00106206
NOP word ptr [RAX + RAX*0x1]
LAB_001061f0:
MOVDQA XMM7,xmmword ptr [RSP]
MOV byte ptr [RAX + 0x10],0x0
ADD RAX,0x18
MOVUPS xmmword ptr [RAX + -0x18],XMM7
CMP RDX,RAX
JNZ 0x001061f0
LAB_00106206:
SAR RCX,0x3
MOVDQA XMM0,xmmword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x50]
MOV RAX,-0x5555555555555555
IMUL RCX,RAX
MOV EAX,0x3
MOV qword ptr [RDX + 0x10],RSI
MOVUPS xmmword ptr [RDX],XMM0
SUB RAX,RCX
CMP RAX,0x1
JZ 0x0010624c
MOV qword ptr [RDX + 0x28],RSI
MOVUPS xmmword ptr [RDX + 0x18],XMM0
TEST RCX,RCX
JNZ 0x0010624c
MOV qword ptr [RDX + 0x40],RSI
MOVUPS xmmword ptr [RDX + 0x30],XMM0
LAB_0010624c:
LEA RAX,[RAX + RAX*0x2]
LEA RAX,[RDX + RAX*0x8]
MOV qword ptr [RSP + 0xa8],RAX
NOP dword ptr [RAX]
LAB_00106260:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00107ed0
MOV RDI,qword ptr [RSP + 0x98]
TEST RDI,RDI
JZ 0x0010627c
CALL 0x00107da0
LAB_0010627c:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00104660
MOV RAX,qword ptr [RSP + 0x2e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106aee
ADD RSP,0x2f8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001062b8:
MOV RDI,qword ptr [RSP + 0x108]
TEST RDI,RDI
JZ 0x001062d5
MOV RSI,qword ptr [RSP + 0x118]
SUB RSI,RDI
CALL 0x00104580
LAB_001062d5:
MOV RDI,RBP
CALL 0x00107ed0
LAB_001062dd:
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
MOV RAX,RDX
CMP RDX,RCX
JZ 0x0010630e
NOP dword ptr [RAX]
LAB_001062f8:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x00106305
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX],RBX
LAB_00106305:
ADD RAX,0x18
CMP RCX,RAX
JNZ 0x001062f8
LAB_0010630e:
MOV qword ptr [RCX + -0x30],R12
MOV R8,qword ptr [RDX]
MOV RDI,RCX
SUB RDI,RDX
MOV qword ptr [RCX + -0x28],R8
MOV RSI,qword ptr [RDX + 0x8]
CMP R8,R12
SETNZ byte ptr [RCX + -0x20]
CMP RSI,RBX
MOV qword ptr [RCX + -0x18],RSI
MOV qword ptr [RCX + -0x10],RBX
SETNZ byte ptr [RCX + -0x8]
CMP RDX,RCX
JZ 0x00106428
MOV RAX,RDI
SAR RAX,0x3
IMUL RAX,R15
SUB RAX,0x3
CMP RAX,0x1
JBE 0x00106428
ADD RDX,0x18
CMP byte ptr [RDX + 0x10],0x0
JNZ 0x00106437
LAB_00106369:
LEA RBX,[RSP + 0x160]
MOV byte ptr [RSP + 0x160],0x0
MOV RSI,qword ptr [R13 + 0x8]
MOV qword ptr [RSP + 0x150],RBX
MOV qword ptr [RSP + 0x158],0x0
CMP RSI,qword ptr [R13 + 0x10]
JZ 0x001064a2
LAB_0010639b:
LEA RDX,[RSI + 0x10]
MOV qword ptr [RSI],RDX
MOV RAX,qword ptr [RSP + 0x150]
CMP RAX,RBX
JZ 0x001068a0
MOV qword ptr [RSI],RAX
MOV RAX,qword ptr [RSP + 0x160]
MOV qword ptr [RSI + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x158]
LAB_001063ca:
MOV qword ptr [RSI + 0x8],RAX
ADD qword ptr [R13 + 0x8],0x20
LAB_001063d3:
MOV RSI,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RSP + 0xa0]
MOV RDX,RSI
SUB RDX,RAX
CMP RDX,0x48
JBE 0x001064e0
MOV RDX,qword ptr [RSP + 0x10]
MOV R12,qword ptr [RSI + -0x18]
MOV RBX,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
MOV RDX,qword ptr [RSP + 0x90]
TEST RDX,RDX
JZ 0x00106260
LAB_00106414:
ADD RBX,RCX
MOV RCX,qword ptr [RSP + 0xb0]
JMP 0x00105f10
LAB_00106428:
LEA RDX,[RDX + RDI*0x1 + -0x48]
CMP byte ptr [RDX + 0x10],0x0
JZ 0x00106369
LAB_00106437:
MOV R14,qword ptr [RDX]
MOV R12,qword ptr [RDX + 0x8]
LEA RBX,[RSP + 0x160]
MOV qword ptr [RSP + 0x158],0x0
MOV qword ptr [RSP + 0x150],RBX
SUB R12,R14
MOV qword ptr [RSP + 0xc0],R12
CMP R12,0xf
JA 0x00106930
CMP R12,0x1
JNZ 0x00106920
MOVZX EAX,byte ptr [R14]
MOV byte ptr [RSP + 0x160],AL
LAB_00106484:
MOV RAX,RBX
LAB_00106487:
MOV qword ptr [RSP + 0x158],R12
MOV byte ptr [RAX + R12*0x1],0x0
MOV RSI,qword ptr [R13 + 0x8]
CMP RSI,qword ptr [R13 + 0x10]
JNZ 0x0010639b
LAB_001064a2:
MOV RDX,qword ptr [RSP + 0x30]
MOV RDI,R13
LAB_001064aa:
CALL 0x001081b0
MOV RDI,qword ptr [RSP + 0x150]
CMP RDI,RBX
JZ 0x001063d3
MOV RAX,qword ptr [RSP + 0x160]
LEA RSI,[RAX + 0x1]
CALL 0x00104580
JMP 0x001063d3
LAB_001064e0:
MOV RCX,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x90]
MOV R12,qword ptr [RSI + -0x48]
MOV RBX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
TEST RDX,RDX
JNZ 0x00106414
JMP 0x00106260
LAB_00106510:
TEST RDI,RDI
JZ 0x00106569
LEA RDI,[RDI + RDI*0x2]
MOV RCX,RAX
SHL RDI,0x3
LEA R8,[RAX + RDI*0x1]
NOP dword ptr [RAX]
LAB_00106528:
PXOR XMM5,XMM5
MOV byte ptr [RCX + 0x10],0x0
ADD RCX,0x18
MOVUPS xmmword ptr [RCX + -0x18],XMM5
CMP R8,RCX
JNZ 0x00106528
MOV RCX,0xaaaaaaaaaaaaaab
SUB RDI,0x18
SHR RDI,0x3
IMUL RDI,RCX
MOV RCX,0x1fffffffffffffff
AND RDI,RCX
LEA RCX,[RDI + RDI*0x2 + 0x3]
LEA RAX,[RAX + RCX*0x8]
LAB_00106569:
CMP RSI,RAX
JZ 0x00105f96
MOV qword ptr [RSP + 0xa8],RAX
JMP 0x00105f96
LAB_00106580:
LEA RBP,[RDI + RDI*0x2]
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0x70],0x0
SHL RBP,0x3
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOV RDI,RBP
LAB_0010659d:
CALL 0x00104570
ADD RBP,RAX
MOV RDX,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001065b0:
PXOR XMM4,XMM4
MOV byte ptr [RDX + 0x10],0x0
ADD RDX,0x18
MOVUPS xmmword ptr [RDX + -0x18],XMM4
CMP RDX,RBP
JNZ 0x001065b0
MOVDQA XMM0,xmmword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xb0]
LEA RDI,[RSP + 0x60]
MOV qword ptr [RSP + 0xa8],RDX
MOV qword ptr [RSP + 0xb0],RDX
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0xa0],RAX
MOVAPS xmmword ptr [RSP + 0x60],XMM0
CALL 0x00107ed0
MOV RDX,qword ptr [RSP + 0x90]
JMP 0x00105f96
LAB_00106610:
MOV RSI,qword ptr [RSP + 0x20]
PXOR XMM1,XMM1
MOV qword ptr [RSP + 0xe0],R12
MOV qword ptr [RSP + 0xe8],RBX
MOV qword ptr [RSP + 0xf0],RSI
MOV RSI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0xf8],RDX
MOV qword ptr [RSP + 0x100],RSI
MOVAPS xmmword ptr [RSP + 0xc0],XMM1
MOVAPS xmmword ptr [RSP + 0xd0],XMM1
TEST RCX,RCX
JS 0x00106aa6
MOV qword ptr [RSP + 0x118],0x0
PXOR XMM7,XMM7
MOVUPS xmmword ptr [RSP + 0x108],XMM7
TEST RAX,RAX
JZ 0x00106900
SHL RAX,0x4
MOV RDI,RAX
MOV RBP,RAX
LAB_0010668a:
CALL 0x00104570
LEA RCX,[RAX + RBP*0x1]
MOV qword ptr [RSP + 0x108],RAX
MOV qword ptr [RSP + 0x118],RCX
NOP dword ptr [RAX + RAX*0x1]
LAB_001066a8:
MOV qword ptr [RAX],0x0
ADD RAX,0x10
MOV dword ptr [RAX + -0x8],0x0
CMP RAX,RCX
JNZ 0x001066a8
MOV RDX,qword ptr [RSP + 0xf8]
MOV RBP,qword ptr [RDX + 0x40]
SUB RBP,qword ptr [RDX + 0x38]
SAR RBP,0x4
IMUL RBP,R15
LAB_001066d7:
PXOR XMM5,XMM5
MOV RDI,RBP
MOV R14,qword ptr [RDX + 0x20]
MOV qword ptr [RSP + 0x110],RCX
MOV qword ptr [RSP + 0x130],0x0
MOVAPS xmmword ptr [RSP + 0x120],XMM5
LAB_001066fe:
CALL 0x001043b0
MOV RCX,RAX
MOV RAX,RBP
SUB RAX,0x1
JS 0x0010671f
MOV RDI,RCX
MOV RDX,RBP
XOR ESI,ESI
CALL 0x001044b0
MOV RCX,RAX
LAB_0010671f:
MOV RAX,qword ptr [RSP + 0xe0]
LEA RBP,[RSP + 0xc0]
MOV qword ptr [RSP + 0x138],RCX
MOV RDI,RBP
MOV qword ptr [RSP + 0x140],R14
MOV dword ptr [RSP + 0x148],0x0
MOV qword ptr [RSP + 0xd8],RAX
LAB_00106755:
CALL 0x00105500
MOV byte ptr [RSP + 0x2f],AL
TEST AL,AL
JNZ 0x00106890
MOV EAX,dword ptr [RSP + 0x148]
TEST AL,0x40
JNZ 0x001067b6
OR AL,0x80
MOV dword ptr [RSP + 0x148],EAX
JMP 0x001067a4
LAB_00106780:
ADD RAX,0x1
MOV RDI,RBP
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xd8],RAX
CALL 0x00105500
TEST AL,AL
JNZ 0x00106890
LAB_001067a4:
MOV RAX,qword ptr [RSP + 0xe0]
CMP RAX,qword ptr [RSP + 0xe8]
JNZ 0x00106780
LAB_001067b6:
MOV RDI,qword ptr [RSP + 0x138]
TEST RDI,RDI
JZ 0x001067c8
CALL 0x00104620
LAB_001067c8:
MOV RAX,qword ptr [RSP + 0x128]
MOV R14,qword ptr [RSP + 0x120]
MOV qword ptr [RSP],RAX
CMP RAX,R14
JZ 0x0010680f
NOP dword ptr [RAX]
LAB_001067e8:
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x00106860
MOV RSI,qword ptr [R14 + 0x18]
ADD R14,0x20
SUB RSI,RDI
CALL 0x00104580
CMP qword ptr [RSP],R14
JNZ 0x001067e8
LAB_00106807:
MOV R14,qword ptr [RSP + 0x120]
LAB_0010680f:
TEST R14,R14
JZ 0x00106827
MOV RSI,qword ptr [RSP + 0x130]
MOV RDI,R14
SUB RSI,R14
CALL 0x00104580
LAB_00106827:
MOV RDI,qword ptr [RSP + 0x108]
TEST RDI,RDI
JZ 0x00106844
MOV RSI,qword ptr [RSP + 0x118]
SUB RSI,RDI
CALL 0x00104580
LAB_00106844:
MOV RDI,RBP
CALL 0x00107ed0
CMP byte ptr [RSP + 0x2f],0x0
JNZ 0x001062dd
JMP 0x0010619a
LAB_00106860:
ADD R14,0x20
CMP qword ptr [RSP],R14
JNZ 0x001067e8
JMP 0x00106807
LAB_00106870:
MOV qword ptr [RSP + 0x108],0x0
XOR EBP,EBP
MOV qword ptr [RSP + 0x118],0x0
JMP 0x00106077
LAB_00106890:
MOV byte ptr [RSP + 0x2f],0x1
JMP 0x001067b6
LAB_001068a0:
MOV RAX,qword ptr [RSP + 0x158]
LEA RCX,[RAX + 0x1]
CMP ECX,0x8
JC 0x001069b8
MOV RDI,qword ptr [RBX]
MOV qword ptr [RSI + 0x10],RDI
MOV EDI,ECX
MOV R8,qword ptr [RBX + 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 RBX,RDX
AND ECX,0xfffffff8
CMP ECX,0x8
JC 0x001063ca
AND ECX,0xfffffff8
XOR EDX,EDX
LAB_001068e9:
MOV R8D,EDX
ADD EDX,0x8
MOV R9,qword ptr [RBX + R8*0x1]
MOV qword ptr [RDI + R8*0x1],R9
CMP EDX,ECX
JC 0x001068e9
JMP 0x001063ca
LAB_00106900:
MOV qword ptr [RSP + 0x108],0x0
XOR ECX,ECX
MOV qword ptr [RSP + 0x118],0x0
JMP 0x001066d7
LAB_00106920:
TEST R12,R12
JZ 0x00106484
MOV RDI,RBX
JMP 0x0010695a
LAB_00106930:
MOV RDI,qword ptr [RSP + 0x30]
XOR EDX,EDX
MOV RSI,RBP
LAB_0010693a:
CALL 0x001046c0
MOV qword ptr [RSP + 0x150],RAX
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x160],RAX
LAB_0010695a:
MOV RDX,R12
MOV RSI,R14
CALL 0x00104550
MOV R12,qword ptr [RSP + 0xc0]
MOV RAX,qword ptr [RSP + 0x150]
JMP 0x00106487
LAB_00106980:
LEA RCX,[RAX + 0x48]
MOV byte ptr [RAX + 0x10],0x0
MOV byte ptr [RAX + 0x28],0x0
MOV byte ptr [RAX + 0x40],0x0
MOVUPS xmmword ptr [RAX],XMM1
MOVUPS xmmword ptr [RAX + 0x18],XMM1
MOVUPS xmmword ptr [RAX + 0x30],XMM1
CMP RDX,RCX
JZ 0x00106260
MOV qword ptr [RSP + 0xa8],RCX
JMP 0x00106260
LAB_001069b8:
TEST CL,0x4
JNZ 0x00106a92
TEST ECX,ECX
JZ 0x001063ca
MOVZX EDI,byte ptr [RBX]
MOV byte ptr [RSI + 0x10],DIL
TEST CL,0x2
JZ 0x001063ca
MOV ECX,ECX
MOVZX EDI,word ptr [RBX + RCX*0x1 + -0x2]
MOV word ptr [RDX + RCX*0x1 + -0x2],DI
JMP 0x001063ca
LAB_001069f0:
PXOR XMM0,XMM0
MOV EDI,0x48
MOV qword ptr [RSP + 0xd0],0x0
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
CALL 0x00104570
MOV RDX,qword ptr [RSP + 0x50]
MOVDQA XMM0,xmmword ptr [RSP]
LEA RCX,[RAX + 0x48]
MOV RDI,RBP
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x28],RDX
MOV qword ptr [RAX + 0x40],RDX
MOV RDX,qword ptr [RSP + 0xb0]
MOVUPS xmmword ptr [RAX],XMM0
MOVUPS xmmword ptr [RAX + 0x18],XMM0
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOVDQA XMM0,xmmword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0xa8],RCX
MOV qword ptr [RSP + 0xb0],RCX
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
CALL 0x00107ed0
JMP 0x00106260
LAB_00106a80:
LEA RAX,[RSP + 0xa0]
MOV qword ptr [RSP + 0x18],RAX
JMP 0x00106260
LAB_00106a92:
MOV EDI,dword ptr [RBX]
MOV ECX,ECX
MOV dword ptr [RSI + 0x10],EDI
MOV EDI,dword ptr [RBX + RCX*0x1 + -0x4]
MOV dword ptr [RDX + RCX*0x1 + -0x4],EDI
JMP 0x001063ca
LAB_00106aa6:
MOV RAX,qword ptr [RSP + 0x2e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106ae4
LEA RDI,[0x11a2e0]
LAB_00106ac0:
CALL 0x00104490
LAB_00106ac5:
MOV RAX,qword ptr [RSP + 0x2e8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106ae9
LEA RDI,[0x11a2e0]
LAB_00106adf:
CALL 0x00104490
LAB_00106ae4:
CALL 0x001045c0
LAB_00106ae9:
CALL 0x001045c0
LAB_00106aee:
CALL 0x001045c0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
int *__src;
int8 uVar1;
void *pvVar2;
int auVar3 [16];
bool bVar4;
int auVar5 [16];
char cVar6;
int8 *puVar7;
long lVar8;
int (*pauVar9) [16];
int (*pauVar10) [16];
int8 *puVar11;
void *pvVar12;
long *plVar13;
uint uVar14;
long lVar15;
uint uVar16;
int (*pauVar17) [16];
long lVar18;
long *in_RSI;
vector *pvVar19;
_Match_mode _Var20;
long lVar21;
ulong uVar22;
long in_FS_OFFSET;
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*local_310;
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_2c8 [16];
int (*local_2b8) [16];
uint local_2a8 [2];
locale local_2a0 [2];
int local_298 [16];
int local_288 [16];
int (*local_278) [16];
long lStack_270;
int local_268 [16];
int local_258 [16];
long local_248;
long local_240;
uint *local_238;
long local_230;
vector *local_228;
int local_220 [16];
int8 *local_210;
int local_208 [16];
int8 local_1f8;
void *local_1f0;
int8 local_1e8;
uint local_1e0;
long *local_1d8;
int8 local_1d0;
long 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);
std::locale::locale(local_2a0);
local_298 = (int [16])0x0;
/* try { // try from 00105dd2 to 00105dd6 has its CatchHandler @ 00106af3 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
((_Compiler<std::regex_traits<char>> *)&local_1d8,"\\\"([^\\\"]*)\\\"","",local_2a0,0x10
);
auVar3 = local_d8._0_16_;
uVar1 = local_298._8_8_;
local_d8._0_16_ = (int [16])0x0;
local_298 = auVar3;
if ((_Sp_counted_base<(_Lock_policy)2> *)uVar1 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release((_Sp_counted_base<(_Lock_policy)2> *)uVar1);
}
local_2a8[0] = 0x10;
if (local_a8 != (void *)0x0) {
for (puVar11 = local_80; puVar11 < (int8 *)(local_60 + 8U); puVar11 = puVar11 + 1) {
operator_delete((void *)*puVar11,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();
*(int8 *)(param_1 + 0x10) = 0;
lVar8 = *in_RSI;
lVar18 = in_RSI[1];
local_288 = (int [16])0x0;
local_278 = (int (*) [16])0x0;
lStack_270 = 0;
*(int (*) [16])param_1 = (int [16])0x0;
if (local_298._0_8_ == 0) {
LAB_00106260:
local_310 = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_288;
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_310);
if ((_Sp_counted_base<(_Lock_policy)2> *)local_298._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_298._8_8_);
}
std::locale::~locale(local_2a0);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
lVar18 = lVar18 + lVar8;
local_288._8_8_ = (int (*) [16])0x0;
pauVar9 = (int (*) [16])0x0;
do {
uVar22 = (ulong)((int)*(int8 *)(local_298._0_8_ + 0x28) + 3);
lStack_270 = lVar8;
if ((ulong)(((long)local_278 - (long)pauVar9 >> 3) * -0x5555555555555555) < uVar22) {
local_2b8 = (int (*) [16])0x0;
local_2c8[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_2c8[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
/* try { // try from 0010659d to 001065a1 has its CatchHandler @ 00106b47 */
pauVar10 = (int (*) [16])operator_new(uVar22 * 0x18);
auVar3 = local_288;
pauVar9 = pauVar10;
do {
pauVar9[1][0] = 0;
pauVar17 = (int (*) [16])(pauVar9[1] + 8);
*pauVar9 = (int [16])0x0;
pauVar9 = pauVar17;
} while (pauVar17 != (int (*) [16])(uVar22 * 0x18 + (long)pauVar10));
local_2b8 = local_278;
local_288._8_8_ = pauVar17;
local_288._0_8_ = pauVar10;
auVar5 = local_288;
local_288[0] = auVar3[0];
local_288[1] = auVar3[1];
local_288[2] = auVar3[2];
local_288[3] = auVar3[3];
local_288[4] = auVar3[4];
local_288[5] = auVar3[5];
local_288[6] = auVar3[6];
local_288[7] = auVar3[7];
local_288[8] = auVar3[8];
local_288[9] = auVar3[9];
local_288[10] = auVar3[10];
local_288[0xb] = auVar3[0xb];
local_288[0xc] = auVar3[0xc];
local_288[0xd] = auVar3[0xd];
local_288[0xe] = auVar3[0xe];
local_288[0xf] = auVar3[0xf];
local_2c8[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0];
local_2c8[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[1];
local_2c8[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[2];
local_2c8[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[3];
local_2c8[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[4];
local_2c8[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[5];
local_2c8[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[6];
local_2c8[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[7];
local_2c8[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[8];
local_2c8[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[9];
local_2c8[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[10];
local_2c8[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0xb];
local_2c8[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0xc];
local_2c8[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0xd];
local_2c8[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0xe];
local_2c8[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)local_288[0xf];
local_288 = auVar5;
local_278 = pauVar17;
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_2c8);
local_230 = local_298._0_8_;
}
else {
lVar15 = local_288._8_8_ - (long)pauVar9 >> 3;
local_230 = local_298._0_8_;
if ((ulong)(lVar15 * -0x5555555555555555) < uVar22) {
for (; pauVar9 != (int (*) [16])local_288._8_8_;
pauVar9 = (int (*) [16])(pauVar9[1] + 8)) {
pauVar9[1][0] = 0;
*pauVar9 = (int [16])0x0;
}
lVar21 = uVar22 + lVar15 * 0x5555555555555555;
pauVar9 = (int (*) [16])local_288._8_8_;
lVar15 = lVar21;
do {
pauVar9[1][0] = 0;
*pauVar9 = (int [16])0x0;
lVar15 = lVar15 + -1;
pauVar9 = (int (*) [16])(pauVar9[1] + 8);
} while (lVar15 != 0);
local_288._8_8_ = local_288._8_8_ + lVar21 * 0x18;
}
else {
if (uVar22 != 0) {
pauVar10 = pauVar9;
do {
pauVar10[1][0] = 0;
pauVar17 = pauVar10 + 1;
*pauVar10 = (int [16])0x0;
pauVar10 = (int (*) [16])(*pauVar17 + 8);
} while ((int (*) [16])((long)pauVar9 + uVar22 * 0x18) !=
(int (*) [16])(*pauVar17 + 8));
pauVar9 = (int (*) [16])
((long)pauVar9 +
(((uVar22 * 0x18 - 0x18 >> 3) * 0xaaaaaaaaaaaaaab & 0x1fffffffffffffff) * 3 + 3)
* 8);
}
if ((int (*) [16])local_288._8_8_ != pauVar9) {
local_288._8_8_ = pauVar9;
}
}
}
lVar15 = *(long *)(local_230 + 0x40) - *(long *)(local_230 + 0x38);
lVar21 = lVar15 >> 4;
local_248 = lVar8;
local_240 = lVar18;
local_238 = local_2a8;
local_228 = (vector *)local_288;
if ((local_2a8[0] & 0x400) == 0) {
local_268 = (int [16])0x0;
local_258 = (int [16])0x0;
local_258._0_8_ = 0;
if (lVar15 < 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 00106adf to 00106ae3 has its CatchHandler @ 00106b3b */
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_210 = (int8 *)0x0;
local_220 = (int [16])0x0;
if (lVar15 == 0) {
local_220._0_8_ = (int8 *)0x0;
local_210 = (int8 *)0x0;
}
else {
/* try { // try from 00106034 to 00106038 has its CatchHandler @ 00106b3b */
local_220._0_8_ = operator_new(lVar21 * -0x5555555555555550);
local_210 = (int8 *)(local_220._0_8_ + lVar21 * -0xaaaaaaaaaaaaaaa * 8);
puVar11 = (int8 *)local_220._0_8_;
do {
*puVar11 = 0;
puVar7 = puVar11 + 2;
*(int4 *)(puVar11 + 1) = 0;
puVar11 = puVar7;
} while (puVar7 != local_210);
}
local_220._8_8_ = local_210;
local_1f8 = local_1f8 & 0xffffff0000000000;
local_208._8_8_ = 0;
local_208._0_8_ = *(ulong *)(local_230 + 0x20);
local_258._8_8_ = local_248;
/* try { // try from 001060c5 to 00106154 has its CatchHandler @ 00106b2f */
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_268,local_228);
std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
::_M_dfs((_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
*)local_268,1,local_208._0_8_);
if (local_1f8._4_1_ == '\0') {
if ((local_1f8 & 0x40) != 0) {
LAB_00106175:
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_8_);
}
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_268);
goto LAB_0010619a;
}
local_1f8 = local_1f8 | 0x80;
do {
if (local_248 == local_240) goto LAB_00106175;
local_248 = local_248 + 1;
local_1f8._0_5_ = (uint5)(uint)local_1f8;
local_258._8_8_ = local_248;
local_208._8_8_ = 0;
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_268,local_228);
std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
::_M_dfs((_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
*)local_268,1,local_208._0_8_);
} while (local_1f8._4_1_ == '\0');
}
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_8_);
}
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_268);
}
else {
local_268 = (int [16])0x0;
local_258 = (int [16])0x0;
if (lVar15 < 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 00106ac0 to 00106ac4 has its CatchHandler @ 00106b0b */
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_210 = (int8 *)0x0;
local_220 = (int [16])0x0;
pvVar19 = (vector *)local_288;
if (lVar21 * -0x5555555555555555 == 0) {
local_220._0_8_ = (int8 *)0x0;
local_210 = (int8 *)0x0;
uVar22 = 0;
}
else {
/* try { // try from 0010668a to 0010668e has its CatchHandler @ 00106b0b */
local_220._0_8_ = operator_new(lVar21 * -0x5555555555555550);
local_210 = (int8 *)(local_220._0_8_ + lVar21 * -0xaaaaaaaaaaaaaaa * 8);
puVar11 = (int8 *)local_220._0_8_;
do {
*puVar11 = 0;
puVar7 = puVar11 + 2;
*(int4 *)(puVar11 + 1) = 0;
puVar11 = puVar7;
} while (puVar7 != local_210);
uVar22 = (*(long *)(local_230 + 0x40) - *(long *)(local_230 + 0x38) >> 4) *
-0x5555555555555555;
}
uVar1 = *(int8 *)(local_230 + 0x20);
local_220._8_8_ = local_210;
local_1f8 = 0;
local_208 = (int [16])0x0;
/* try { // try from 001066fe to 00106702 has its CatchHandler @ 00106b23 */
pvVar12 = operator_new__(uVar22);
if (-1 < (long)(uVar22 - 1)) {
pvVar19 = (vector *)0x0;
pvVar12 = memset(pvVar12,0,uVar22);
}
local_1e0 = 0;
local_258._8_8_ = local_248;
_Var20 = (_Match_mode)
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_268;
local_1f0 = pvVar12;
local_1e8 = uVar1;
/* try { // try from 00106755 to 0010679b has its CatchHandler @ 00106b17 */
cVar6 = std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,false>
::_M_main_dispatch(_Var20,(integral_constant)pvVar19);
if (cVar6 == '\0') {
bVar4 = false;
if ((local_1e0 & 0x40) == 0) {
local_1e0 = local_1e0 | 0x80;
do {
if (local_248 == local_240) goto LAB_001067b6;
local_248 = local_248 + 1;
local_258._8_8_ = local_248;
cVar6 = std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,false>
::_M_main_dispatch(_Var20,(integral_constant)pvVar19);
} while (cVar6 == '\0');
goto LAB_00106890;
}
}
else {
LAB_00106890:
bVar4 = true;
}
LAB_001067b6:
if (local_1f0 != (void *)0x0) {
operator_delete__(local_1f0);
}
uVar1 = local_208._8_8_;
pvVar12 = (void *)local_208._0_8_;
if (local_208._8_8_ != local_208._0_8_) {
do {
while (pvVar2 = *(void **)((long)pvVar12 + 8), pvVar2 != (void *)0x0) {
plVar13 = (long *)((long)pvVar12 + 0x18);
pvVar12 = (void *)((long)pvVar12 + 0x20);
operator_delete(pvVar2,*plVar13 - (long)pvVar2);
if ((void *)uVar1 == pvVar12) goto LAB_00106807;
}
pvVar12 = (void *)((long)pvVar12 + 0x20);
} while ((void *)uVar1 != pvVar12);
LAB_00106807:
}
if ((void *)local_208._0_8_ != (void *)0x0) {
operator_delete((void *)local_208._0_8_,local_1f8 - local_208._0_8_);
}
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_8_);
}
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_268);
if (!bVar4) {
LAB_0010619a:
if ((ulong)((long)local_278 - local_288._0_8_) < 0x31) {
auVar3._8_8_ = 0;
auVar3._0_8_ = local_258._8_8_;
local_258 = auVar3 << 0x40;
local_268 = (int [16])0x0;
plVar13 = (long *)operator_new(0x48);
local_268 = local_288;
plVar13[2] = 0;
plVar13[5] = 0;
plVar13[8] = 0;
*plVar13 = lVar18;
plVar13[1] = lVar18;
plVar13[3] = lVar18;
plVar13[4] = lVar18;
plVar13[6] = lVar18;
plVar13[7] = lVar18;
local_258._0_8_ = local_278;
local_288._8_8_ = (int (*) [16])(plVar13 + 9);
local_288._0_8_ = plVar13;
local_278 = (int (*) [16])(plVar13 + 9);
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_268);
}
else {
plVar13 = (long *)local_288._0_8_;
if ((ulong)(local_288._8_8_ - local_288._0_8_) < 0x31) {
for (; plVar13 != (long *)local_288._8_8_; plVar13 = plVar13 + 3) {
*(int *)(plVar13 + 2) = 0;
*plVar13 = lVar18;
plVar13[1] = lVar18;
}
lVar15 = (long)(local_288._8_8_ - local_288._0_8_) >> 3;
*(long *)(local_288._8_8_ + 0x10) = 0;
*(long *)local_288._8_8_ = lVar18;
*(long *)(local_288._8_8_ + 8) = lVar18;
lVar8 = lVar15 * 0x5555555555555555 + 3;
if (lVar8 != 1) {
*(long *)(local_288._8_8_ + 0x28) = 0;
*(long *)(local_288._8_8_ + 0x18) = lVar18;
*(long *)(local_288._8_8_ + 0x20) = lVar18;
if (lVar15 * -0x5555555555555555 == 0) {
*(long *)(local_288._8_8_ + 0x40) = 0;
*(long *)(local_288._8_8_ + 0x30) = lVar18;
*(long *)(local_288._8_8_ + 0x38) = lVar18;
}
}
local_288._8_8_ = (long *)(local_288._8_8_ + lVar8 * 3 * 8);
}
else {
*(int *)(local_288._0_8_ + 0x10) = 0;
*(int *)(local_288._0_8_ + 0x28) = 0;
*(int *)(local_288._0_8_ + 0x40) = 0;
*(long *)local_288._0_8_ = lVar18;
*(long *)(local_288._0_8_ + 8) = lVar18;
*(long *)(local_288._0_8_ + 0x18) = lVar18;
*(long *)(local_288._0_8_ + 0x20) = lVar18;
*(long *)(local_288._0_8_ + 0x30) = lVar18;
*(long *)(local_288._0_8_ + 0x38) = lVar18;
if ((long *)local_288._8_8_ != (long *)(local_288._0_8_ + 0x48)) {
local_288._8_8_ = (long *)(local_288._0_8_ + 0x48);
}
}
}
goto LAB_00106260;
}
}
for (plVar13 = (long *)local_288._0_8_; plVar13 != (long *)local_288._8_8_;
plVar13 = plVar13 + 3) {
if (*(char *)(plVar13 + 2) == '\0') {
plVar13[1] = lVar18;
*plVar13 = lVar18;
}
}
*(long *)(local_288._8_8_ + -0x30) = lVar8;
lVar15 = *(long *)local_288._0_8_;
*(long *)(local_288._8_8_ + -0x28) = lVar15;
lVar21 = *(long *)(local_288._0_8_ + 8);
*(bool *)(local_288._8_8_ + -0x20) = lVar15 != lVar8;
*(long *)(local_288._8_8_ + -0x18) = lVar21;
*(long *)(local_288._8_8_ + -0x10) = lVar18;
*(bool *)(local_288._8_8_ + -8) = lVar21 != lVar18;
if ((local_288._0_8_ == local_288._8_8_) ||
(((long)(local_288._8_8_ - local_288._0_8_) >> 3) * -0x5555555555555555 - 3U < 2)) {
plVar13 = (long *)(local_288._0_8_ + (local_288._8_8_ - local_288._0_8_) + -0x48);
if (*(char *)(plVar13 + 2) != '\0') goto LAB_00106437;
LAB_00106369:
local_1d8 = local_1c8;
local_1c8[0] = (ulong)local_1c8[0]._1_7_ << 8;
plVar13 = *(long **)(param_1 + 8);
local_1d0 = 0;
if (plVar13 != *(long **)(param_1 + 0x10)) goto LAB_0010639b;
LAB_001064a2:
/* try { // try from 001064aa to 001064ae has its CatchHandler @ 00106aff */
std::vector<std::string,std::allocator<std::string>>::_M_realloc_insert<std::string>
((vector<std::string,std::allocator<std::string>> *)param_1,
(__normal_iterator)plVar13,(string *)&local_1d8);
if (local_1d8 != local_1c8) {
operator_delete(local_1d8,local_1c8[0] + 1);
}
}
else {
plVar13 = (long *)(local_288._0_8_ + 0x18);
if (*(char *)(local_288._0_8_ + 0x28) == '\0') goto LAB_00106369;
LAB_00106437:
__src = (int *)*plVar13;
local_1d8 = local_1c8;
local_1d0 = 0;
uVar22 = plVar13[1] - (long)__src;
local_268._0_8_ = uVar22;
if (uVar22 < 0x10) {
if (uVar22 == 1) {
local_1c8[0] = CONCAT71(local_1c8[0]._1_7_,*__src);
}
else if (uVar22 != 0) goto LAB_0010695a;
}
else {
/* try { // try from 0010693a to 00106a11 has its CatchHandler @ 00106b47 */
local_1d8 = (long *)std::string::_M_create((ulong *)&local_1d8,(ulong)local_268);
local_1c8[0] = local_268._0_8_;
LAB_0010695a:
memcpy(local_1d8,__src,uVar22);
uVar22 = local_268._0_8_;
}
local_1d0 = uVar22;
*(int *)((long)local_1d8 + uVar22) = 0;
plVar13 = *(long **)(param_1 + 8);
if (plVar13 == *(long **)(param_1 + 0x10)) goto LAB_001064a2;
LAB_0010639b:
*plVar13 = (long)(plVar13 + 2);
if (local_1d8 == local_1c8) {
uVar22 = local_1d0 + 1;
uVar14 = (uint)uVar22;
if (uVar14 < 8) {
if ((uVar22 & 4) == 0) {
if (uVar14 != 0) {
*(int *)(plVar13 + 2) = (int)local_1c8[0];
if ((uVar22 & 2) != 0) {
*(int2 *)((long)plVar13 + (uVar22 & 0xffffffff) + 0xe) =
*(int2 *)((long)local_1c8 + ((uVar22 & 0xffffffff) - 2));
}
}
}
else {
*(int4 *)(plVar13 + 2) = (int4)local_1c8[0];
*(int4 *)((long)plVar13 + (uVar22 & 0xffffffff) + 0xc) =
*(int4 *)((long)local_1c8 + ((uVar22 & 0xffffffff) - 4));
}
}
else {
plVar13[2] = local_1c8[0];
*(int8 *)((long)plVar13 + (uVar22 & 0xffffffff) + 8) =
*(int8 *)((long)local_1c8 + ((uVar22 & 0xffffffff) - 8));
lVar8 = (long)(plVar13 + 2) - ((ulong)(plVar13 + 3) & 0xfffffffffffffff8);
uVar14 = uVar14 + (int)lVar8 & 0xfffffff8;
if (7 < uVar14) {
uVar16 = 0;
do {
uVar22 = (ulong)uVar16;
uVar16 = uVar16 + 8;
*(int8 *)(((ulong)(plVar13 + 3) & 0xfffffffffffffff8) + uVar22) =
*(int8 *)((long)local_1c8 + (uVar22 - lVar8));
} while (uVar16 < uVar14);
}
}
}
else {
*plVar13 = (long)local_1d8;
plVar13[2] = local_1c8[0];
}
plVar13[1] = local_1d0;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 0x20;
}
if ((ulong)(local_288._8_8_ - local_288._0_8_) < 0x49) {
lVar8 = *(long *)(*(int (*) [16])(local_288._8_8_ + -0x50) + 8);
lVar18 = *in_RSI;
lVar15 = in_RSI[1];
}
else {
lVar8 = *(long *)(*(int (*) [16])(local_288._8_8_ + -0x20) + 8);
lVar18 = *in_RSI;
lVar15 = in_RSI[1];
}
if (local_298._0_8_ == 0) goto LAB_00106260;
lVar18 = lVar18 + lVar15;
pauVar9 = (int (*) [16])local_288._0_8_;
} while( true );
} |
2,900 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int, int>& test_tup) {
int first, second, third, fourth, fifth;
std::tie(first, second, third, fourth, fifth) = test_tup;
return std::make_tuple(first*second, second*third, third*fourth, fourth*fifth);
}
| int main() {
assert(func0(std::make_tuple(1, 5, 7, 8, 10)) == std::make_tuple(5, 35, 56, 80));
assert(func0(std::make_tuple(2, 4, 5, 6, 7)) == std::make_tuple(8, 20, 30, 42));
assert(func0(std::make_tuple(12, 13, 14, 9, 15)) == std::make_tuple(156, 182, 126, 135));
return 0;
}
| O0 | cpp | func0(std::tuple<int, int, int, int, int> const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x30(%rbp),%rax
lea -0x40(%rbp),%r8
lea -0x44(%rbp),%rdi
lea -0x48(%rbp),%rcx
lea -0x4c(%rbp),%rdx
lea -0x50(%rbp),%rsi
mov %r8,%r9
mov %rdi,%r8
mov %rax,%rdi
callq 1523 <_ZSt3tieIJiiiiiEESt5tupleIJDpRT_EES3_>
mov -0x60(%rbp),%rdx
lea -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1574 <_ZNSt5tupleIJRiS0_S0_S0_S0_EEaSIJiiiiiEEENSt9enable_ifIXcl12__assignableIDpRKT_EEERS1_E4typeERKS_IJDpS4_EE>
mov -0x44(%rbp),%edx
mov -0x40(%rbp),%eax
imul %edx,%eax
mov %eax,-0x30(%rbp)
mov -0x48(%rbp),%edx
mov -0x44(%rbp),%eax
imul %edx,%eax
mov %eax,-0x34(%rbp)
mov -0x4c(%rbp),%edx
mov -0x48(%rbp),%eax
imul %edx,%eax
mov %eax,-0x38(%rbp)
mov -0x50(%rbp),%edx
mov -0x4c(%rbp),%eax
imul %edx,%eax
mov %eax,-0x3c(%rbp)
mov -0x58(%rbp),%rax
lea -0x30(%rbp),%rdi
lea -0x34(%rbp),%rcx
lea -0x38(%rbp),%rdx
lea -0x3c(%rbp),%rsi
mov %rdi,%r8
mov %rax,%rdi
callq 15a1 <_ZSt10make_tupleIJiiiiEESt5tupleIJDpNSt17__decay_and_stripIT_E6__typeEEEDpOS2_>
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 1248 <_Z5func0RKSt5tupleIJiiiiiEE+0xbf>
callq 1080 <__stack_chk_fail@plt>
mov -0x58(%rbp),%rax
leaveq
retq
| _Z5func0RKSt5tupleIJiiiiiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+var_30]
lea r8, [rbp+var_40]
lea rdi, [rbp+var_44]
lea rcx, [rbp+var_48]
lea rdx, [rbp+var_4C]
lea rsi, [rbp+var_50]
mov r9, r8
mov r8, rdi
mov rdi, rax
call _ZSt3tieIJiiiiiEESt5tupleIJDpRT_EES3_; std::tie<int,int,int,int,int>(int,int,int,int,int &)
mov rdx, [rbp+var_60]
lea rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNSt5tupleIJRiS0_S0_S0_S0_EEaSIJiiiiiEEENSt9enable_ifIXcl12__assignableIDpRKT_EEERS1_E4typeERKS_IJDpS4_EE; std::tuple<int &,int &,int &,int &,int &>::operator=<int,int,int,int,int>(std::tuple const&<int,int,int,int,int>)
mov edx, [rbp+var_44]
mov eax, [rbp+var_40]
imul eax, edx
mov [rbp+var_30], eax
mov edx, [rbp+var_48]
mov eax, [rbp+var_44]
imul eax, edx
mov [rbp+var_34], eax
mov edx, [rbp+var_4C]
mov eax, [rbp+var_48]
imul eax, edx
mov [rbp+var_38], eax
mov edx, [rbp+var_50]
mov eax, [rbp+var_4C]
imul eax, edx
mov [rbp+var_3C], eax
mov rax, [rbp+var_58]
lea rdi, [rbp+var_30]
lea rcx, [rbp+var_34]
lea rdx, [rbp+var_38]
lea rsi, [rbp+var_3C]
mov r8, rdi
mov rdi, rax
call _ZSt10make_tupleIJiiiiEESt5tupleIJDpNSt25__strip_reference_wrapperINSt5decayIT_E4typeEE6__typeEEEDpOS3_; std::make_tuple<int,int,int,int>(int,int,int,int&&)
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short loc_1228
call ___stack_chk_fail
loc_1228:
mov rax, [rbp+var_58]
leave
retn | long long func0(long long a1, long long a2)
{
int v3; // [rsp+10h] [rbp-50h] BYREF
int v4; // [rsp+14h] [rbp-4Ch] BYREF
int v5; // [rsp+18h] [rbp-48h] BYREF
int v6; // [rsp+1Ch] [rbp-44h] BYREF
int v7; // [rsp+20h] [rbp-40h] BYREF
int v8; // [rsp+24h] [rbp-3Ch] BYREF
int v9; // [rsp+28h] [rbp-38h] BYREF
int v10; // [rsp+2Ch] [rbp-34h] BYREF
_DWORD v11[10]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v12; // [rsp+58h] [rbp-8h]
v12 = __readfsqword(0x28u);
std::tie<int,int,int,int,int>(v11, &v3, &v4, &v5, &v6, &v7);
std::tuple<int &,int &,int &,int &,int &>::operator=<int,int,int,int,int>(v11, a2);
v11[0] = v6 * v7;
v10 = v5 * v6;
v9 = v4 * v5;
v8 = v3 * v4;
std::make_tuple<int,int,int,int>(a1, &v8, &v9, &v10, v11);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x30]
LEA R8,[RBP + -0x40]
LEA RDI,[RBP + -0x44]
LEA RCX,[RBP + -0x48]
LEA RDX,[RBP + -0x4c]
LEA RSI,[RBP + -0x50]
MOV R9,R8
MOV R8,RDI
MOV RDI,RAX
CALL 0x001014e6
MOV RDX,qword ptr [RBP + -0x60]
LEA RAX,[RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101536
MOV EDX,dword ptr [RBP + -0x44]
MOV EAX,dword ptr [RBP + -0x40]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x30],EAX
MOV EDX,dword ptr [RBP + -0x48]
MOV EAX,dword ptr [RBP + -0x44]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x34],EAX
MOV EDX,dword ptr [RBP + -0x4c]
MOV EAX,dword ptr [RBP + -0x48]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x38],EAX
MOV EDX,dword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x4c]
IMUL EAX,EDX
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x58]
LEA RDI,[RBP + -0x30]
LEA RCX,[RBP + -0x34]
LEA RDX,[RBP + -0x38]
LEA RSI,[RBP + -0x3c]
MOV R8,RDI
MOV RDI,RAX
CALL 0x00101563
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101228
CALL 0x00101070
LAB_00101228:
MOV RAX,qword ptr [RBP + -0x58]
LEAVE
RET | /* func0(std::tuple<int, int, int, int, int> const&) */
tuple * func0(tuple *param_1)
{
tuple *in_RSI;
long in_FS_OFFSET;
int local_58;
int local_54;
int local_50;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
int local_38 [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
std::tie<int,int,int,int,int>(local_38,&local_58,&local_54,&local_50,&local_4c,&local_48);
std::tuple<int&,int&,int&,int&,int&>::operator=
((tuple<int&,int&,int&,int&,int&> *)local_38,in_RSI);
local_38[0] = local_48 * local_4c;
local_3c = local_4c * local_50;
local_40 = local_50 * local_54;
local_44 = local_54 * local_58;
std::make_tuple<int,int,int,int>(param_1,&local_44,&local_40,&local_3c,local_38);
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,901 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int, int>& test_tup) {
int first, second, third, fourth, fifth;
std::tie(first, second, third, fourth, fifth) = test_tup;
return std::make_tuple(first*second, second*third, third*fourth, fourth*fifth);
}
| int main() {
assert(func0(std::make_tuple(1, 5, 7, 8, 10)) == std::make_tuple(5, 35, 56, 80));
assert(func0(std::make_tuple(2, 4, 5, 6, 7)) == std::make_tuple(8, 20, 30, 42));
assert(func0(std::make_tuple(12, 13, 14, 9, 15)) == std::make_tuple(156, 182, 126, 135));
return 0;
}
| O1 | cpp | func0(std::tuple<int, int, int, int, int> const&):
endbr64
mov %rdi,%rax
mov 0xc(%rsi),%edx
mov 0x8(%rsi),%edi
mov 0x4(%rsi),%ecx
mov %edx,%r8d
imul 0x10(%rsi),%r8d
mov %ecx,%r9d
imul (%rsi),%r9d
mov %r9d,(%rax)
imul %edi,%ecx
mov %ecx,0x4(%rax)
imul %edi,%edx
mov %edx,0x8(%rax)
mov %r8d,0xc(%rax)
retq
| _Z5func0RKSt5tupleIJiiiiiEE:
endbr64
mov rax, rdi
mov edx, [rsi+0Ch]
mov edi, [rsi+8]
mov ecx, [rsi+4]
mov r8d, edx
imul r8d, [rsi+10h]
mov r9d, ecx
imul r9d, [rsi]
mov [rax], r9d
imul ecx, edi
mov [rax+4], ecx
imul edx, edi
mov [rax+8], edx
mov [rax+0Ch], r8d
retn | _DWORD * func0(_DWORD *a1, _DWORD *a2)
{
_DWORD *result; // rax
int v3; // edx
int v4; // edi
int v5; // ecx
int v6; // r8d
result = a1;
v3 = a2[3];
v4 = a2[2];
v5 = a2[1];
v6 = a2[4] * v3;
*result = *a2 * v5;
result[1] = v4 * v5;
result[2] = v4 * v3;
result[3] = v6;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV EDX,dword ptr [RSI + 0xc]
MOV EDI,dword ptr [RSI + 0x8]
MOV ECX,dword ptr [RSI + 0x4]
MOV R8D,EDX
IMUL R8D,dword ptr [RSI + 0x10]
MOV R9D,ECX
IMUL R9D,dword ptr [RSI]
MOV dword ptr [RAX],R9D
IMUL ECX,EDI
MOV dword ptr [RAX + 0x4],ECX
IMUL EDX,EDI
MOV dword ptr [RAX + 0x8],EDX
MOV dword ptr [RAX + 0xc],R8D
RET | /* func0(std::tuple<int, int, int, int, int> const&) */
void func0(tuple *param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int *in_RSI;
iVar1 = in_RSI[3];
iVar2 = in_RSI[2];
iVar3 = in_RSI[1];
iVar4 = in_RSI[4];
*(int *)param_1 = iVar3 * *in_RSI;
*(int *)(param_1 + 4) = iVar3 * iVar2;
*(int *)(param_1 + 8) = iVar1 * iVar2;
*(int *)(param_1 + 0xc) = iVar1 * iVar4;
return;
} |
2,902 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int, int>& test_tup) {
int first, second, third, fourth, fifth;
std::tie(first, second, third, fourth, fifth) = test_tup;
return std::make_tuple(first*second, second*third, third*fourth, fourth*fifth);
}
| int main() {
assert(func0(std::make_tuple(1, 5, 7, 8, 10)) == std::make_tuple(5, 35, 56, 80));
assert(func0(std::make_tuple(2, 4, 5, 6, 7)) == std::make_tuple(8, 20, 30, 42));
assert(func0(std::make_tuple(12, 13, 14, 9, 15)) == std::make_tuple(156, 182, 126, 135));
return 0;
}
| O2 | cpp | func0(std::tuple<int, int, int, int, int> const&):
endbr64
mov 0xc(%rsi),%edx
mov 0x4(%rsi),%ecx
mov %rdi,%rax
mov 0x10(%rsi),%r8d
mov 0x8(%rsi),%edi
mov (%rsi),%r9d
imul %edx,%r8d
imul %ecx,%r9d
imul %edi,%edx
imul %edi,%ecx
mov %r8d,0xc(%rax)
mov %r9d,(%rax)
mov %edx,0x8(%rax)
mov %ecx,0x4(%rax)
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt5tupleIJiiiiiEE:
endbr64
movdqu xmm0, xmmword ptr [rsi+4]
movdqu xmm2, xmmword ptr [rsi]
mov rax, rdi
movdqa xmm1, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm1, xmm2
psrlq xmm2, 20h ; ' '
pmuludq xmm0, xmm2
pshufd xmm1, xmm1, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movups xmmword ptr [rdi], xmm1
retn | __m128i * func0(__m128i *a1, long long a2)
{
__m128i v2; // xmm2
__m128i *result; // rax
__m128i v4; // xmm1
v2 = _mm_loadu_si128((const __m128i *)a2);
result = a1;
v4 = _mm_loadu_si128((const __m128i *)(a2 + 4));
*a1 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v4, v2), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v4, 0x20u), _mm_srli_epi64(v2, 0x20u)), 8));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI + 0x4]
MOVDQU XMM2,xmmword ptr [RSI]
MOV RAX,RDI
MOVDQA XMM1,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM1,XMM2
PSRLQ XMM2,0x20
PMULUDQ XMM0,XMM2
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVUPS xmmword ptr [RDI],XMM1
RET | /* func0(std::tuple<int, int, int, int, int> const&) */
tuple * func0(tuple *param_1)
{
ulong uVar1;
ulong uVar2;
ulong *in_RSI;
uVar1 = *(ulong *)((long)in_RSI + 0xc);
uVar2 = in_RSI[1];
*(ulong *)param_1 =
CONCAT44((int)((*(ulong *)((long)in_RSI + 4) >> 0x20) * (*in_RSI >> 0x20)),
(int)((*(ulong *)((long)in_RSI + 4) & 0xffffffff) * (*in_RSI & 0xffffffff)));
*(int *)(param_1 + 0x10) = (int)((uVar1 & 0xffffffff) * (uVar2 & 0xffffffff));
*(int *)(param_1 + 0x14) = (int)((uVar1 >> 0x20) * (uVar2 >> 0x20));
return param_1;
} |
2,903 | func0 |
#include <vector>
#include <tuple>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int, int>& test_tup) {
int first, second, third, fourth, fifth;
std::tie(first, second, third, fourth, fifth) = test_tup;
return std::make_tuple(first*second, second*third, third*fourth, fourth*fifth);
}
| int main() {
assert(func0(std::make_tuple(1, 5, 7, 8, 10)) == std::make_tuple(5, 35, 56, 80));
assert(func0(std::make_tuple(2, 4, 5, 6, 7)) == std::make_tuple(8, 20, 30, 42));
assert(func0(std::make_tuple(12, 13, 14, 9, 15)) == std::make_tuple(156, 182, 126, 135));
return 0;
}
| O3 | cpp | func0(std::tuple<int, int, int, int, int> const&):
endbr64
movdqu 0x4(%rsi),%xmm0
movdqu (%rsi),%xmm2
mov %rdi,%rax
movdqa %xmm0,%xmm1
psrlq $0x20,%xmm0
pmuludq %xmm2,%xmm1
psrlq $0x20,%xmm2
pmuludq %xmm2,%xmm0
pshufd $0x8,%xmm1,%xmm1
pshufd $0x8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
movups %xmm1,(%rdi)
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt5tupleIJiiiiiEE:
endbr64
movdqu xmm0, xmmword ptr [rsi+4]
movdqu xmm2, xmmword ptr [rsi]
mov rax, rdi
movdqa xmm1, xmm0
psrlq xmm0, 20h ; ' '
pmuludq xmm1, xmm2
psrlq xmm2, 20h ; ' '
pmuludq xmm0, xmm2
pshufd xmm1, xmm1, 8
pshufd xmm0, xmm0, 8
punpckldq xmm1, xmm0
movups xmmword ptr [rdi], xmm1
retn | __m128i * func0(__m128i *a1, long long a2)
{
__m128i v2; // xmm2
__m128i *result; // rax
__m128i v4; // xmm1
v2 = _mm_loadu_si128((const __m128i *)a2);
result = a1;
v4 = _mm_loadu_si128((const __m128i *)(a2 + 4));
*a1 = _mm_unpacklo_epi32(
_mm_shuffle_epi32(_mm_mul_epu32(v4, v2), 8),
_mm_shuffle_epi32(_mm_mul_epu32(_mm_srli_epi64(v4, 0x20u), _mm_srli_epi64(v2, 0x20u)), 8));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI + 0x4]
MOVDQU XMM2,xmmword ptr [RSI]
MOV RAX,RDI
MOVDQA XMM1,XMM0
PSRLQ XMM0,0x20
PMULUDQ XMM1,XMM2
PSRLQ XMM2,0x20
PMULUDQ XMM0,XMM2
PSHUFD XMM1,XMM1,0x8
PSHUFD XMM0,XMM0,0x8
PUNPCKLDQ XMM1,XMM0
MOVUPS xmmword ptr [RDI],XMM1
RET | /* func0(std::tuple<int, int, int, int, int> const&) */
tuple * func0(tuple *param_1)
{
ulong uVar1;
ulong uVar2;
ulong *in_RSI;
uVar1 = *(ulong *)((long)in_RSI + 0xc);
uVar2 = in_RSI[1];
*(ulong *)param_1 =
CONCAT44((int)((*(ulong *)((long)in_RSI + 4) >> 0x20) * (*in_RSI >> 0x20)),
(int)((*(ulong *)((long)in_RSI + 4) & 0xffffffff) * (*in_RSI & 0xffffffff)));
*(int *)(param_1 + 0x10) = (int)((uVar1 & 0xffffffff) * (uVar2 & 0xffffffff));
*(int *)(param_1 + 0x14) = (int)((uVar1 >> 0x20) * (uVar2 >> 0x20));
return param_1;
} |
2,904 | func0 | #include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& S) {
std::regex pattern("[\\W_]+");
return std::regex_replace(S, pattern, "");
}
| int main() {
assert(func0("123abcjw:, .@! eiw") == "123abcjweiw");
assert(func0("Hello1234:, ! Howare33u") == "Hello1234Howare33u");
assert(func0("Cool543Triks@:, Make@987Trips") == "Cool543TriksMake987Trips");
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 $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2d3cc(%rip),%rsi
mov %rax,%rdi
callq 712c <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1EPKcNSt15regex_constants18syntax_option_typeE>
mov -0x48(%rbp),%rax
lea -0x40(%rbp),%rdx
mov -0x50(%rbp),%rsi
mov $0x0,%r8d
lea 0x2d3b2(%rip),%rcx
mov %rax,%rdi
callq 71e9 <_ZSt13regex_replaceINSt7__cxx1112regex_traitsIcEEcSt11char_traitsIcESaIcEENS0_12basic_stringIT0_T1_T2_EERKSA_RKNS0_11basic_regexIS7_T_EEPKS7_NSt15regex_constants15match_flag_typeE>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71b6 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5d28 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9f>
jmp 5d23 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9a>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71b6 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5b00 <_Unwind_Resume@plt>
callq 5960 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aW; "[\\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_48]
lea rdx, [rbp+var_40]
mov rsi, [rbp+var_50]
mov r8d, 0
lea rcx, unk_34058
mov rdi, rax
call _ZSt13regex_replaceINSt7__cxx1112regex_traitsIcEEcSt11char_traitsIcESaIcEENS0_12basic_stringIT0_T1_T2_EERKSA_RKNS0_11basic_regexIS7_T_EEPKS7_NSt15regex_constants15match_flag_typeE; std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>(std::string const&,std::basic_regex<char,std::regex_traits<char>> const&,char const*,std::regex_constants::match_flag_type)
nop
lea rax, [rbp+var_40]
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 short loc_4BDF
jmp short loc_4BDA
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4BD2
call ___stack_chk_fail
loc_4BD2:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4BDA:
call ___stack_chk_fail
loc_4BDF:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v3, "[\\W_]+", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>(
a1,
a2,
v3,
&unk_34058,
0LL);
std::basic_regex<char,std::regex_traits<char>>::~basic_regex(v3);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106152
MOV RAX,qword ptr [RBP + -0x48]
LEA RDX,[RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x50]
MOV R8D,0x0
LEA RCX,[0x134058]
MOV RDI,RAX
LAB_00104b84:
CALL 0x00106223
NOP
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001061f0
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104bdf
JMP 0x00104bda
LAB_00104bda:
CALL 0x00104860
LAB_00104bdf:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 in_RSI;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"[\\W_]+",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchHandler @ 00104ba8 */
std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>
(param_1,in_RSI,local_48,&DAT_00134058,0);
std::regex::~basic_regex(local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,905 | func0 | #include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& S) {
std::regex pattern("[\\W_]+");
return std::regex_replace(S, pattern, "");
}
| int main() {
assert(func0("123abcjw:, .@! eiw") == "123abcjweiw");
assert(func0("Hello1234:, ! Howare33u") == "Hello1234Howare33u");
assert(func0("Cool543Triks@:, Make@987Trips") == "Cool543TriksMake987Trips");
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 $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%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 0x20(%rsp),%rdi
mov 0x10(%rsp),%r8d
mov %r12,%rcx
lea 0x15e2f(%rip),%rdx
lea -0x6(%rdx),%rsi
callq 19187 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
jmp 48b4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x8b>
endbr64
mov %rax,%rbx
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov %rbx,%rdi
callq 46c0 <_Unwind_Resume@plt>
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x10(%rbx),%r12
mov %r12,(%rbx)
movq $0x0,0x8(%rbx)
movb $0x0,0x10(%rbx)
mov 0x0(%rbp),%rsi
mov %rsi,%rdx
add 0x8(%rbp),%rdx
lea 0x10(%rsp),%rcx
mov $0x0,%r9d
lea 0x159ab(%rip),%r8
mov %rbx,%rdi
callq ee37 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
cmpq $0x0,0x1c6c0(%rip)
je 4967 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x13e>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4972 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x149>
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 49af <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x186>
mov %rbx,%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
cmp %rdi,%r12
je 4955 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x12c>
callq 4570 <_ZdlPv@plt>
lea 0x10(%rsp),%rdi
callq 5776 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbp,%rdi
callq 46c0 <_Unwind_Resume@plt>
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmp 4914 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xeb>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1c644(%rip)
je 49a4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x17b>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x167>
callq 45d0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_50]
lea rdi, [rbp+var_48]; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov ecx, 10h
lea rdx, aW+6; ""
lea rsi, [rdx-6]
mov rdi, r12
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
jmp short loc_48A0
endbr64
mov rbx, rax
mov rdi, [rbp+var_38]
test rdi, rdi
jz short loc_487B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_487B:
lea rdi, [rbp+var_48]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4898
call ___stack_chk_fail
loc_4898:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_48A0:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, [r14]
mov rdx, rsi
add rdx, [r14+8]
lea rcx, [rbp+var_50]
sub rsp, 8
push 0
mov r9d, 0
lea r8, asc_195F9+7; ""
mov rdi, rbx
call _ZSt15__regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_mNSt15regex_constants15match_flag_typeE; std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(std::back_insert_iterator<std::string>,__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&,char const*,ulong,std::regex_constants::match_flag_type)
add rsp, 10h
mov rax, [rbp+var_38]
mov rdi, rax
test rax, rax
jz short loc_4922
lea rcx, [rax+8]
mov rdx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_497C
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_499F
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4919:
cmp eax, 1
jz loc_49AD
loc_4922:
lea rdi, [rbp+var_48]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_49B7
mov rax, rbx
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r14
pop rbp
retn
endbr64
mov r14, rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
lea rdi, [rbp+var_50]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4974
call ___stack_chk_fail
loc_4974:
mov rdi, r14; struct _Unwind_Exception *
call __Unwind_Resume
loc_497C:
mov r12, rdi
mov dword ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 0
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, r12
mov rax, [r12]
call qword ptr [rax+18h]
jmp short loc_4922
loc_499F:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4919
loc_49AD:
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_4922
loc_49B7:
call ___stack_chk_fail | long long func0(long long a1, long long *a2)
{
long long v4; // rsi
_DWORD *v5; // rdi
volatile signed __int32 *v6; // rcx
long long v7; // rdx
signed __int32 v8; // eax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
long long v12; // [rsp+10h] [rbp-40h]
long long v13; // [rsp+18h] [rbp-38h]
unsigned long long v14; // [rsp+28h] [rbp-28h]
v14 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v11);
v12 = 0LL;
v13 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v10, "[\\W_]+", "", 16LL);
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = *a2;
std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(
a1,
*a2,
*((_DWORD *)a2 + 2) + *(_DWORD *)a2,
(unsigned int)v10,
(unsigned int)"",
0,
0);
v5 = (_DWORD *)v13;
if ( v13 )
{
v6 = (volatile signed __int32 *)(v13 + 8);
v7 = *(_QWORD *)(v13 + 8);
if ( v7 == 0x100000001LL )
{
*(_DWORD *)(v13 + 8) = 0;
v5[3] = 0;
(*(void ( **)(_DWORD *, long long, long long, volatile signed __int32 *))(*(_QWORD *)v5 + 16LL))(
v5,
v4,
0x100000001LL,
v6);
(*(void ( **)(_DWORD *))(*(_QWORD *)v5 + 24LL))(v5);
}
else
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v13 + 8);
v7 = (unsigned int)(v8 - 1);
*(_DWORD *)(v13 + 8) = v7;
}
else
{
v8 = _InterlockedExchangeAdd(v6, 0xFFFFFFFF);
}
if ( v8 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v5, v4, v7, v6);
}
}
std::locale::~locale((std::locale *)v11);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL 0x00104710
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV ECX,0x10
LEA RDX,[0x119695]
LEA RSI,[RDX + -0x6]
MOV RDI,R12
LAB_0010485f:
CALL 0x00117714
JMP 0x001048a0
LAB_001048a0:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RSI,qword ptr [R14]
MOV RDX,RSI
ADD RDX,qword ptr [R14 + 0x8]
LEA RCX,[RBP + -0x50]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x0
LEA R8,[0x119600]
MOV RDI,RBX
LAB_001048d7:
CALL 0x0010edca
ADD RSP,0x10
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00104922
LEA RCX,[RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x0010497c
CMP byte ptr [0x0011f460],0x0
JZ 0x0010499f
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104919:
CMP EAX,0x1
JZ 0x001049ad
LAB_00104922:
LEA RDI,[RBP + -0x48]
CALL 0x00104650
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001049b7
MOV RAX,RBX
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R14
POP RBP
RET
LAB_0010497c:
MOV R12,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RDI,R12
MOV RAX,qword ptr [R12]
CALL qword ptr [RAX + 0x18]
JMP 0x00104922
LAB_0010499f:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104919
LAB_001049ad:
CALL 0x0010588a
JMP 0x00104922
LAB_001049b7:
CALL 0x001045a0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 local_48;
_Sp_counted_base<(_Lock_policy)2> *local_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_50);
local_48 = 0;
local_40 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 0010485f to 00104863 has its CatchHandler @ 00104866 */
std::regex::_M_compile(local_58,"[\\W_]+","",0x10);
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
/* try { // try from 001048d7 to 001048db has its CatchHandler @ 00104948 */
std::
__regex_replace<std::back_insert_iterator<std::string>,__normal_iterator<char_const*,std::string>,std::regex_traits<char>,char>
((back_insert_iterator)param_1,(__normal_iterator)*in_RSI,
(__normal_iterator)*in_RSI + (int)in_RSI[1],local_58,"",0,0);
p_Var2 = local_40;
if (local_40 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_40 + 8;
if (*(long *)(local_40 + 8) == 0x100000001) {
*(int4 *)(local_40 + 8) = 0;
*(int4 *)(local_40 + 0xc) = 0;
(**(code **)(*(long *)local_40 + 0x10))();
(**(code **)(*(long *)p_Var2 + 0x18))(p_Var2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar3 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)(local_40 + 8);
*(int *)(local_40 + 8) = iVar3 + -1;
}
if (iVar3 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_40);
}
}
}
std::locale::~locale(local_50);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,906 | func0 | #include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& S) {
std::regex pattern("[\\W_]+");
return std::regex_replace(S, pattern, "");
}
| int main() {
assert(func0("123abcjw:, .@! eiw") == "123abcjweiw");
assert(func0("Hello1234:, ! Howare33u") == "Hello1234Howare33u");
assert(func0("Cool543Triks@:, Make@987Trips") == "Cool543TriksMake987Trips");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13
mov %rbp,%rdi
callq 4770 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x10(%rsp)
callq 4500 <_ZNSt6localeC1ERKS_@plt>
lea 0x16ae3(%rip),%rdx
mov 0x10(%rsp),%r8d
mov %r13,%rcx
lea 0x20(%rsp),%rdi
lea -0x6(%rdx),%rsi
callq 1a620 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %rbp,%rdi
lea 0x10(%r12),%r14
lea 0x10(%rsp),%rbp
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov %r14,(%r12)
xor %r9d,%r9d
mov %rbp,%rcx
movb $0x0,0x10(%r12)
mov (%rbx),%rsi
lea 0x16685(%rip),%r8
mov %r12,%rdi
movq $0x0,0x8(%r12)
mov 0x8(%rbx),%rdx
add %rsi,%rdx
callq e770 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x1d37b(%rip),%rbx
test %rbx,%rbx
je 4c80 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4c8e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10e>
nopl 0x0(%rax)
mov %r13,%rdi
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 4ccb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14b>
add $0x40,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 4cc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x140>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
nopl 0x0(%rax,%rax,1)
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4ca7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
callq 4610 <__stack_chk_fail@plt>
endbr64
mov %rax,%r13
jmpq 47e3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 4801 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1e>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_50]
push r12
lea r12, [rbp+var_48]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, aW+6; ""
pxor xmm0, xmm0
mov rdi, r13
mov ecx, 10h
lea rsi, [rdx-6]
movaps [rbp+var_40], xmm0
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
lea rax, [rbx+10h]
sub rsp, 8
mov byte ptr [rbx+10h], 0
xor r9d, r9d
mov [rbx], rax
mov rsi, [r14]
lea r8, asc_1A5F9+7; ""
mov rcx, r13
mov qword ptr [rbx+8], 0
mov rdx, [r14+8]
mov rdi, rbx; int
push 0
add rdx, rsi
call _ZSt15__regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_mNSt15regex_constants15match_flag_typeE; std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(std::back_insert_iterator<std::string>,__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&,char const*,ulong,std::regex_constants::match_flag_type)
pop rax
mov rax, qword ptr [rbp+var_40+8]
pop rdx
mov rdi, rax
test rax, rax
jz short loc_612C
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_6158
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz short loc_6178
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_6127:
cmp eax, 1
jz short loc_6188
loc_612C:
mov rdi, r12; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_618F
lea rsp, [rbp-20h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_6158:
mov rax, [rdi]
mov r13, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+18h]
jmp short loc_612C
loc_6178:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp short loc_6127
loc_6188:
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 short loc_612C
loc_618F:
call ___stack_chk_fail
endbr64
mov r14, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
jmp loc_486C | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdi
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v9; // rax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v12; // [rsp+10h] [rbp-40h]
unsigned long long v13; // [rsp+28h] [rbp-28h]
v13 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v11);
v12 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v10, "[\\W_]+", "", 16LL);
*(_BYTE *)(a1 + 16) = 0;
*(_QWORD *)a1 = a1 + 16;
v3 = *a2;
*(_QWORD *)(a1 + 8) = 0LL;
std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(a1);
v4 = *((_QWORD *)&v12 + 1);
if ( *((_QWORD *)&v12 + 1) )
{
v5 = *(_QWORD *)(*((_QWORD *)&v12 + 1) + 8LL);
v6 = (volatile signed __int32 *)(*((_QWORD *)&v12 + 1) + 8LL);
if ( v5 == 0x100000001LL )
{
v9 = **((_QWORD **)&v12 + 1);
*(_QWORD *)(*((_QWORD *)&v12 + 1) + 8LL) = 0LL;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(v9 + 16))(
v4,
v3,
0x100000001LL,
v6);
(*(void ( **)(long long))(*(_QWORD *)v4 + 24LL))(v4);
}
else
{
if ( _libc_single_threaded )
{
v7 = *(_DWORD *)(*((_QWORD *)&v12 + 1) + 8LL);
v5 = (unsigned int)(v7 - 1);
*(_DWORD *)(*((_QWORD *)&v12 + 1) + 8LL) = v5;
}
else
{
v7 = _InterlockedExchangeAdd(v6, 0xFFFFFFFF);
}
if ( v7 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v4, v3, v5, v6);
}
}
std::locale::~locale((std::locale *)v11);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x50]
PUSH R12
LEA R12,[RBP + -0x48]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001046f0
LEA RDX,[0x11a695]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,[RDX + -0x6]
MOVAPS xmmword ptr [RBP + -0x40],XMM0
LAB_001060b3:
CALL 0x001194c0
LEA RAX,[RBX + 0x10]
SUB RSP,0x8
MOV byte ptr [RBX + 0x10],0x0
XOR R9D,R9D
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
LEA R8,[0x11a600]
MOV RCX,R13
MOV qword ptr [RBX + 0x8],0x0
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
PUSH 0x0
ADD RDX,RSI
LAB_001060eb:
CALL 0x00112130
POP RAX
MOV RAX,qword ptr [RBP + -0x38]
POP RDX
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010612c
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00106158
CMP byte ptr [0x00120460],0x0
JZ 0x00106178
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00106127:
CMP EAX,0x1
JZ 0x00106188
LAB_0010612c:
MOV RDI,R12
CALL 0x00104640
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010618f
LEA RSP,[RBP + -0x20]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00106158:
MOV RAX,qword ptr [RDI]
MOV R13,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x0010612c
LAB_00106178:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00106127
LAB_00106188:
CALL 0x001073b0
JMP 0x0010612c
LAB_0010618f:
CALL 0x001045a0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_50);
local_48._0_16_ = (int [16])0x0;
/* try { // try from 001060b3 to 001060b7 has its CatchHandler @ 001061a0 */
std::regex::_M_compile(local_58,"[\\W_]+","",0x10);
param_1[0x10] = (string)0x0;
*(string **)param_1 = param_1 + 0x10;
uVar2 = *in_RSI;
*(int8 *)(param_1 + 8) = 0;
/* try { // try from 001060eb to 001060ef has its CatchHandler @ 00106194 */
std::
__regex_replace<std::back_insert_iterator<std::string>,__normal_iterator<char_const*,std::string>,std::regex_traits<char>,char>
((back_insert_iterator)param_1,(__normal_iterator)uVar2,
(int)in_RSI[1] + (__normal_iterator)uVar2,local_58,"",0,0);
uVar2 = local_48._8_8_;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_48._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_48._8_8_ + 8);
if (*(long *)(local_48._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_48._8_8_ + 8) = 0;
(**(code **)(*(long *)local_48._8_8_ + 0x10))();
(**(code **)(*(long *)uVar2 + 0x18))(uVar2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar3 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)(local_48._8_8_ + 8);
*(int *)(local_48._8_8_ + 8) = iVar3 + -1;
}
if (iVar3 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_48._8_8_);
}
}
}
std::locale::~locale(local_50);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,907 | func0 | #include <iostream>
#include <string>
#include <regex>
#include <cassert>
| std::string func0(const std::string& S) {
std::regex pattern("[\\W_]+");
return std::regex_replace(S, pattern, "");
}
| int main() {
assert(func0("123abcjw:, .@! eiw") == "123abcjweiw");
assert(func0("Hello1234:, ! Howare33u") == "Hello1234Howare33u");
assert(func0("Cool543Triks@:, Make@987Trips") == "Cool543TriksMake987Trips");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13
mov %rbp,%rdi
callq 47b0 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x10(%rsp)
callq 4530 <_ZNSt6localeC1ERKS_@plt>
lea 0x171cb(%rip),%rdx
mov 0x10(%rsp),%r8d
mov %r13,%rcx
lea 0x20(%rsp),%rdi
lea -0x6(%rdx),%rsi
callq 1ac90 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %rbp,%rdi
lea 0x10(%r12),%r14
lea 0x10(%rsp),%rbp
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov %r14,(%r12)
xor %r9d,%r9d
mov %rbp,%rcx
movb $0x0,0x10(%r12)
mov (%rbx),%rsi
lea 0x16d35(%rip),%r8
mov %r12,%rdi
movq $0x0,0x8(%r12)
mov 0x8(%rbx),%rdx
add %rsi,%rdx
callq 10d00 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x1da3b(%rip),%rbx
test %rbx,%rbx
je 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 55de <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10e>
nopl 0x0(%rax)
mov %r13,%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 561b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14b>
add $0x40,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5610 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x140>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
nopl 0x0(%rax,%rax,1)
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 55f7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
callq 4640 <__stack_chk_fail@plt>
endbr64
mov %rax,%r13
jmpq 4836 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 4854 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1e>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r14, [rbp+var_E0]
push r13
push r12
mov r12, rsi
push rbx
mov rbx, rdi
sub rsp, 108h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_D8]
mov [rbp+var_130], r14
mov rdi, rax; this
mov [rbp+var_128], rax
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, aW+6; ""
pxor xmm0, xmm0
mov rdi, r14
mov ecx, 10h
lea rsi, [rdx-6]
movaps xmmword ptr [rbp-0D0h], xmm0
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
lea rax, [rbx+10h]
mov byte ptr [rbx+10h], 0
sub rsp, 8
xor r9d, r9d
mov [rbx], rax
mov rcx, [rbp+var_130]
xor r8d, r8d
mov [rbp+var_100], rax
mov rax, [r12]
mov qword ptr [rbx+8], 0
mov r13, [r12+8]
movq xmm0, rax
mov r15, rax
mov [rbp+var_B0], rcx
mov [rbp+var_A8], 0
lea r12, [rax+r13]
lea rax, [rbp+var_A0]
movq xmm1, r12
mov [rbp+var_120], rax
mov rdx, rax
punpcklqdq xmm0, xmm1
movaps [rbp+var_C0], xmm0
movq rdi, xmm0
pxor xmm0, xmm0
mov rsi, qword ptr [rbp+var_C0+8]
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], 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_65D3
loc_6217:
lea rax, [rbp+var_C0]
pxor xmm0, xmm0
lea rsi, [rbp+var_80]
mov qword ptr [rbp+var_70], 0
mov rdi, rax
mov dword ptr [rbp+var_70+8], 0
mov [rbp+var_118], rsi
mov [rbp+var_110], rax
movaps [rbp+var_80], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_50], xmm0
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
jz loc_6312
test r13, r13
jle short loc_6283
nop dword ptr [rax+00h]
loc_6268:
movsx esi, byte ptr [r15]
mov rdi, rbx
mov r14, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r14, 1
mov r15, r14
cmp r12, r14
jnz short loc_6268
loc_6283:
lea rdi, [rbp+var_60]
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, [rbp+var_120]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rax, [rbp+var_C8]
mov rdi, rax
test rax, rax
jz short loc_62E1
mov rcx, [rax+8]
lea rdx, [rax+8]
mov rax, 100000001h
cmp rcx, rax
jz loc_6641
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_6660
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_62D8:
cmp eax, 1
jz loc_666E
loc_62E1:
mov rdi, [rbp+var_128]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_6678
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6312:
lea rdi, [rbp+var_F0]
xor r13d, r13d
xor r15d, r15d
mov [rbp+var_108], rdi
test al, al
jnz loc_6508
xchg ax, ax
loc_6330:
mov rdx, qword ptr [rbp+var_A0]
mov rax, qword ptr [rbp+var_A0+8]
sub rax, rdx
lea rcx, [rdx+rax-30h]
cmp rax, 49h ; 'I'
lea rdx, [rdx+rax-48h]
mov rax, rcx
cmovb rax, rdx
mov r15, [rax+8]
mov r12, [rax]
mov rax, r15
sub rax, r12
test rax, rax
jg short loc_6390
jmp short loc_63DB
loc_6370:
mov rcx, [rbp+var_F8]
add r12, 1
mov [rax+rcx], r14b
mov rax, [rbx]
mov [rbx+8], r13
mov byte ptr [rax+rcx+1], 0
cmp r15, r12
jz short loc_63DB
loc_6390:
mov rax, [rbx+8]
movzx r14d, byte ptr [r12]
mov [rbp+var_F8], rax
lea r13, [rax+1]
mov rax, [rbx]
cmp [rbp+var_100], rax
jz loc_6540
mov rdx, [rbx+10h]
loc_63B8:
cmp rdx, r13
jnb short loc_6370
mov rsi, [rbp+var_F8]
xor ecx, ecx
xor edx, edx
mov rdi, rbx
mov r8d, 1
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rbx]
jmp short loc_6370
loc_63DB:
mov r15, [rbp+var_108]
mov rdi, r15; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rax, [rbp+var_E8]
mov rsi, r15; std::locale *
mov rdi, rax; this
mov r14, rax
call __ZNSt6localeC1ERKS_; std::locale::locale(std::locale const&)
lea rdi, _ZNSt5ctypeIcE2idE@GLIBCXX_3_4; this
call __ZNKSt6locale2id5_M_idEv; std::locale::id::_M_id(void)
mov rdx, rax
mov rax, [rbp+var_E8]
mov rax, [rax+8]
cmp qword ptr [rax+rdx*8], 0
jz loc_667D
mov rdi, r14; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, [rbp+var_108]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rsi, qword ptr [rbp+var_A0+8]
mov rax, qword ptr [rbp+var_A0]
mov rcx, rsi
sub rcx, rax
cmp rcx, 48h ; 'H'
jbe loc_6550
lea rdx, [rax+rcx-18h]
cmp rsi, rax
mov r15, [rdx]
mov r13, [rdx+8]
lea rdx, [rsi+rcx-48h]
cmovnz rdx, rax
loc_646E:
cmp byte ptr [rdx+10h], 0
jz short loc_64ED
cmp rsi, rax
jz loc_65C9
loc_647D:
mov r12, [rax+8]
mov rdi, r12
cmp r12, [rax]
jz loc_657E
loc_648D:
mov r8d, [rbp+var_A8]
sub rsp, 8
mov rcx, [rbp+var_B0]
xor r9d, r9d
mov rdx, [rbp+var_120]
mov rsi, qword ptr [rbp+var_C0+8]
or r8b, 80h
mov [rbp+var_A8], 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_656E
loc_64CC:
mov rax, qword ptr [rbp+var_A0+8]
cmp [rax-28h], r12
mov [rax-30h], r12
setnz byte ptr [rax-20h]
mov rax, qword ptr [rbp+var_C0]
mov qword ptr [rbp+var_90+8], rax
loc_64ED:
mov rsi, [rbp+var_118]
mov rdi, [rbp+var_110]
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
jz loc_6330
loc_6508:
mov rax, r13
sub rax, r15
test rax, rax
jle loc_6283
nop word ptr [rax+rax+00000000h]
loc_6520:
movsx esi, byte ptr [r15]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r15, 1
cmp r13, r15
jnz short loc_6520
jmp loc_6283
loc_6540:
mov edx, 0Fh
jmp loc_63B8
loc_6550:
lea rdx, [rax+rcx-48h]
mov r15, [rdx]
mov r13, [rdx+8]
jz loc_646E
cmp rsi, rax
cmovnz rdx, rax
jmp loc_646E
loc_656E:
mov [rbp+var_B0], 0
jmp loc_64ED
loc_657E:
cmp r12, qword ptr [rbp+var_C0+8]
jz short loc_656E
sub rsp, 8
mov r8d, [rbp+var_A8]
mov rcx, [rbp+var_B0]
xor r9d, r9d
mov rdx, [rbp+var_120]
mov rsi, qword ptr [rbp+var_C0+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_648D
jmp loc_64CC
loc_65C9:
lea rax, [rax+rcx-48h]
jmp loc_647D
loc_65D3:
pxor xmm0, xmm0
lea r14, [rbp+var_60]
mov rdi, [rbp+var_120]
mov qword ptr [rbp+var_C0], 0
movaps [rbp+var_70], xmm0
mov rsi, r14
pxor xmm0, xmm0
mov qword ptr [rbp+var_C0+8], 0
mov [rbp+var_B0], 0
mov [rbp+var_A8], 0
movaps [rbp+var_80], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_50], 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_50+8]
mov rdi, r14
mov qword ptr [rbp+var_90+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_6217
loc_6641:
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_62E1
loc_6660:
mov eax, 0FFFFFFFFh
lock xadd [rdx], eax
jmp loc_62D8
loc_666E:
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_62E1
loc_6678:
call ___stack_chk_fail
loc_667D:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz short loc_6691
call __ZSt16__throw_bad_castv; std::__throw_bad_cast(void)
loc_6691:
call ___stack_chk_fail
endbr64
mov r12, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov r14, rax
jmp loc_488C
endbr64
mov r15, rax
jmp loc_48C8
endbr64
mov r14, rax
jmp loc_4883
endbr64
mov rbx, rax
jmp loc_48D5 | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v3; // rax
long long v4; // r13
char *v5; // r15
char *v6; // r12
char v7; // al
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
unsigned long long v12; // rsi
long long v13; // rdi
volatile signed __int32 *v14; // rdx
signed __int32 v15; // eax
long long v17; // rax
char *v18; // r15
char *v19; // r12
long long v20; // rax
char v21; // r14
unsigned long long v22; // r13
long long v23; // rax
unsigned long long v24; // rdx
long long v25; // rax
long long v26; // r8
long long v27; // r9
_QWORD *v28; // rax
long long v29; // rcx
char *v30; // r15
char *v31; // r13
long long v32; // rdx
long long v33; // r12
int v34; // edi
int v35; // r8d
char v36; // al
long long v37; // rax
bool v38; // zf
long long v39; // rax
long long v40; // [rsp-10h] [rbp-140h]
long long v41; // [rsp-10h] [rbp-140h]
long long v42; // [rsp-8h] [rbp-138h]
_QWORD *v43; // [rsp+30h] [rbp-100h]
long long v44; // [rsp+38h] [rbp-F8h]
char v45[8]; // [rsp+40h] [rbp-F0h] BYREF
long long v46; // [rsp+48h] [rbp-E8h] BYREF
char v47[8]; // [rsp+50h] [rbp-E0h] BYREF
char v48[8]; // [rsp+58h] [rbp-D8h] BYREF
__int128 v49; // [rsp+60h] [rbp-D0h]
__m128i v50; // [rsp+70h] [rbp-C0h] BYREF
char *v51; // [rsp+80h] [rbp-B0h]
int v52; // [rsp+88h] [rbp-A8h]
__int128 v53; // [rsp+90h] [rbp-A0h] BYREF
__int128 v54; // [rsp+A0h] [rbp-90h]
__int128 v55; // [rsp+B0h] [rbp-80h] BYREF
__int128 v56; // [rsp+C0h] [rbp-70h]
__int128 v57; // [rsp+D0h] [rbp-60h] BYREF
__int128 v58; // [rsp+E0h] [rbp-50h]
unsigned long long v59; // [rsp+F8h] [rbp-38h]
v59 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v48);
v49 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v47, "[\\W_]+", "", 16LL);
*((_BYTE *)a1 + 16) = 0;
*a1 = a1 + 2;
v43 = a1 + 2;
v3 = *a2;
a1[1] = 0LL;
v4 = (long long)a2[1];
v5 = v3;
v51 = v47;
v52 = 0;
v6 = &v3[v4];
v50 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v3, (__m128i)(unsigned long long)&v3[v4]);
v53 = 0LL;
v54 = 0LL;
v7 = 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>>(
v50.m128i_i32[0],
v50.m128i_i32[2],
(unsigned int)&v53,
(unsigned int)v47,
0,
0,
0);
v10 = v40;
v11 = v42;
if ( !v7 )
{
v50 = 0uLL;
v56 = 0LL;
v51 = 0LL;
v52 = 0;
v55 = 0LL;
v57 = 0LL;
v58 = 0LL;
((void ( *)(__int128 *, __int128 *, long long, long long, long long))std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=)(
&v53,
&v57,
v8,
v9,
v40);
*((_QWORD *)&v54 + 1) = *((_QWORD *)&v58 + 1);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v57);
}
v12 = (unsigned long long)&v55;
*(_QWORD *)&v56 = 0LL;
DWORD2(v56) = 0;
v55 = 0LL;
v57 = 0LL;
v58 = 0LL;
if ( (unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(
&v50,
&v55,
v8,
v9,
v10,
v11) )
{
if ( v4 > 0 )
{
do
{
v12 = (unsigned int)*v5;
std::string::push_back(a1, v12);
++v5;
}
while ( v6 != v5 );
}
goto LABEL_6;
}
do
{
v17 = *((_QWORD *)&v53 + 1) - 48LL;
if ( *((_QWORD *)&v53 + 1) - (_QWORD)v53 < 0x49uLL )
v17 = *((_QWORD *)&v53 + 1) - 72LL;
v18 = *(char **)(v17 + 8);
v19 = *(char **)v17;
if ( (long long)&v18[-*(_QWORD *)v17] > 0 )
{
do
{
v21 = *v19;
v44 = a1[1];
v22 = v44 + 1;
v23 = *a1;
if ( v43 == (_QWORD *)*a1 )
v24 = 15LL;
else
v24 = a1[2];
if ( v24 < v22 )
{
std::string::_M_mutate(a1, v44, 0LL, 0LL, 1LL);
v23 = *a1;
}
++v19;
*(_BYTE *)(v23 + v44) = v21;
v20 = *a1;
a1[1] = v22;
*(_BYTE *)(v20 + v44 + 1) = 0;
}
while ( v18 != v19 );
}
std::locale::locale((std::locale *)v45);
std::locale::locale((std::locale *)&v46, (const std::locale *)v45);
v25 = std::locale::id::_M_id((std::locale::id *)&std::ctype<char>::id);
if ( !*(_QWORD *)(*(_QWORD *)(v46 + 8) + 8 * v25) )
std::__throw_bad_cast();
std::locale::~locale((std::locale *)&v46);
std::locale::~locale((std::locale *)v45);
v28 = (_QWORD *)v53;
v29 = *((_QWORD *)&v53 + 1) - v53;
if ( *((_QWORD *)&v53 + 1) - (_QWORD)v53 <= 0x48uLL )
{
v32 = *((_QWORD *)&v53 + 1) - 72LL;
v30 = *(char **)(*((_QWORD *)&v53 + 1) - 72LL);
v31 = *(char **)(*((_QWORD *)&v53 + 1) - 72LL + 8);
if ( *((_QWORD *)&v53 + 1) - (_QWORD)v53 != 72LL && *((_QWORD *)&v53 + 1) != (_QWORD)v53 )
v32 = v53;
}
else
{
v30 = *(char **)(*((_QWORD *)&v53 + 1) - 24LL);
v31 = *(char **)(*((_QWORD *)&v53 + 1) - 24LL + 8);
v32 = *((_QWORD *)&v53 + 1) + v29 - 72;
if ( *((_QWORD *)&v53 + 1) != (_QWORD)v53 )
v32 = v53;
}
if ( *(_BYTE *)(v32 + 16) )
{
if ( *((_QWORD *)&v53 + 1) == (_QWORD)v53 )
v28 = (_QWORD *)(*((_QWORD *)&v53 + 1) - 72LL);
v33 = v28[1];
v34 = v33;
if ( v33 == *v28 )
{
if ( v33 == v50.m128i_i64[1] )
{
LABEL_41:
v51 = 0LL;
goto LABEL_32;
}
v34 = v33 + 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>>(
v33,
v50.m128i_i32[2],
(unsigned int)&v53,
(_DWORD)v51,
v52 | 0x60u,
0,
0) )
{
LABEL_31:
v37 = *((_QWORD *)&v53 + 1);
v38 = *(_QWORD *)(*((_QWORD *)&v53 + 1) - 40LL) == v33;
*(_QWORD *)(*((_QWORD *)&v53 + 1) - 48LL) = v33;
*(_BYTE *)(v37 - 32) = !v38;
*((_QWORD *)&v54 + 1) = v50.m128i_i64[0];
goto LABEL_32;
}
}
v35 = v52;
LOBYTE(v35) = v52 | 0x80;
v52 = v35;
v36 = 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>>(
v34,
v50.m128i_i32[2],
(unsigned int)&v53,
(_DWORD)v51,
v35,
0,
0);
v32 = v41;
v29 = v42;
if ( v36 )
goto LABEL_31;
goto LABEL_41;
}
LABEL_32:
v12 = (unsigned long long)&v55;
}
while ( !(unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(
&v50,
&v55,
v32,
v29,
v26,
v27) );
if ( v31 - v30 > 0 )
{
do
{
v12 = (unsigned int)*v30;
std::string::push_back(a1, v12);
++v30;
}
while ( v31 != v30 );
}
LABEL_6:
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v57);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v53);
v13 = *((_QWORD *)&v49 + 1);
if ( *((_QWORD *)&v49 + 1) )
{
v14 = (volatile signed __int32 *)(*((_QWORD *)&v49 + 1) + 8LL);
if ( *(_QWORD *)(*((_QWORD *)&v49 + 1) + 8LL) == 0x100000001LL )
{
v39 = **((_QWORD **)&v49 + 1);
*(_QWORD *)(*((_QWORD *)&v49 + 1) + 8LL) = 0LL;
(*(void ( **)(long long, unsigned long long, volatile signed __int32 *))(v39 + 16))(v13, v12, v14);
(*(void ( **)(long long))(*(_QWORD *)v13 + 24LL))(v13);
}
else
{
if ( _libc_single_threaded )
{
v15 = *(_DWORD *)(*((_QWORD *)&v49 + 1) + 8LL);
*(_DWORD *)(*((_QWORD *)&v49 + 1) + 8LL) = v15 - 1;
}
else
{
v15 = _InterlockedExchangeAdd(v14, 0xFFFFFFFF);
}
if ( v15 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v13);
}
}
std::locale::~locale((std::locale *)v48);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R14,[RBP + -0xe0]
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x130],R14
MOV RDI,RAX
MOV qword ptr [RBP + -0x128],RAX
CALL 0x00104730
LEA RDX,[0x11b6da]
PXOR XMM0,XMM0
MOV RDI,R14
MOV ECX,0x10
LEA RSI,[RDX + -0x6]
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
LAB_0010616f:
CALL 0x00119bf0
LEA RAX,[RBX + 0x10]
MOV byte ptr [RBX + 0x10],0x0
SUB RSP,0x8
XOR R9D,R9D
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [RBP + -0x130]
XOR R8D,R8D
MOV qword ptr [RBP + -0x100],RAX
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX + 0x8],0x0
MOV R13,qword ptr [R12 + 0x8]
MOVQ XMM0,RAX
MOV R15,RAX
MOV qword ptr [RBP + -0xb0],RCX
MOV dword ptr [RBP + -0xa8],0x0
LEA R12,[RAX + R13*0x1]
LEA RAX,[RBP + -0xa0]
MOVQ XMM1,R12
MOV qword ptr [RBP + -0x120],RAX
MOV RDX,RAX
PUNPCKLQDQ XMM0,XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVQ RDI,XMM0
PXOR XMM0,XMM0
MOV RSI,qword ptr [RBP + -0xb8]
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM0
PUSH 0x0
LAB_00106206:
CALL 0x00113120
POP R8
POP R9
TEST AL,AL
JZ 0x001065d3
LAB_00106217:
LEA RAX,[RBP + -0xc0]
PXOR XMM0,XMM0
LEA RSI,[RBP + -0x80]
MOV qword ptr [RBP + -0x70],0x0
MOV RDI,RAX
MOV dword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x118],RSI
MOV qword ptr [RBP + -0x110],RAX
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
CALL 0x00107c90
TEST AL,AL
JZ 0x00106312
TEST R13,R13
JLE 0x00106283
NOP dword ptr [RAX]
LAB_00106268:
MOVSX ESI,byte ptr [R15]
MOV RDI,RBX
MOV R14,R15
LAB_00106272:
CALL 0x00104580
ADD R14,0x1
MOV R15,R14
CMP R12,R14
JNZ 0x00106268
LAB_00106283:
LEA RDI,[RBP + -0x60]
CALL 0x00107c60
MOV RDI,qword ptr [RBP + -0x120]
CALL 0x00107c60
MOV RAX,qword ptr [RBP + -0xc8]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001062e1
MOV RCX,qword ptr [RAX + 0x8]
LEA RDX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RCX,RAX
JZ 0x00106641
CMP byte ptr [0x00121460],0x0
JZ 0x00106660
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_001062d8:
CMP EAX,0x1
JZ 0x0010666e
LAB_001062e1:
MOV RDI,qword ptr [RBP + -0x128]
CALL 0x00104680
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106678
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00106312:
LEA RDI,[RBP + -0xf0]
XOR R13D,R13D
XOR R15D,R15D
MOV qword ptr [RBP + -0x108],RDI
TEST AL,AL
JNZ 0x00106508
NOP
LAB_00106330:
MOV RDX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RBP + -0x98]
SUB RAX,RDX
LEA RCX,[RDX + RAX*0x1 + -0x30]
CMP RAX,0x49
LEA RDX,[RDX + RAX*0x1 + -0x48]
MOV RAX,RCX
CMOVC RAX,RDX
MOV R15,qword ptr [RAX + 0x8]
MOV R12,qword ptr [RAX]
MOV RAX,R15
SUB RAX,R12
TEST RAX,RAX
JG 0x00106390
JMP 0x001063db
LAB_00106370:
MOV RCX,qword ptr [RBP + -0xf8]
ADD R12,0x1
MOV byte ptr [RAX + RCX*0x1],R14B
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBX + 0x8],R13
MOV byte ptr [RAX + RCX*0x1 + 0x1],0x0
CMP R15,R12
JZ 0x001063db
LAB_00106390:
MOV RAX,qword ptr [RBX + 0x8]
MOVZX R14D,byte ptr [R12]
MOV qword ptr [RBP + -0xf8],RAX
LEA R13,[RAX + 0x1]
MOV RAX,qword ptr [RBX]
CMP qword ptr [RBP + -0x100],RAX
JZ 0x00106540
MOV RDX,qword ptr [RBX + 0x10]
LAB_001063b8:
CMP RDX,R13
JNC 0x00106370
MOV RSI,qword ptr [RBP + -0xf8]
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,RBX
MOV R8D,0x1
CALL 0x001046f0
MOV RAX,qword ptr [RBX]
JMP 0x00106370
LAB_001063db:
MOV R15,qword ptr [RBP + -0x108]
MOV RDI,R15
CALL 0x00104730
LEA RAX,[RBP + -0xe8]
MOV RSI,R15
MOV RDI,RAX
MOV R14,RAX
CALL 0x001044f0
LEA RDI,[0x121480]
CALL 0x001044a0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + RDX*0x8],0x0
JZ 0x0010667d
MOV RDI,R14
CALL 0x00104680
MOV RDI,qword ptr [RBP + -0x108]
CALL 0x00104680
MOV RSI,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,RSI
SUB RCX,RAX
CMP RCX,0x48
JBE 0x00106550
LEA RDX,[RAX + RCX*0x1 + -0x18]
CMP RSI,RAX
MOV R15,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
LEA RDX,[RSI + RCX*0x1 + -0x48]
CMOVNZ RDX,RAX
LAB_0010646e:
CMP byte ptr [RDX + 0x10],0x0
JZ 0x001064ed
CMP RSI,RAX
JZ 0x001065c9
LAB_0010647d:
MOV R12,qword ptr [RAX + 0x8]
MOV RDI,R12
CMP R12,qword ptr [RAX]
JZ 0x0010657e
LAB_0010648d:
MOV R8D,dword ptr [RBP + -0xa8]
SUB RSP,0x8
MOV RCX,qword ptr [RBP + -0xb0]
XOR R9D,R9D
MOV RDX,qword ptr [RBP + -0x120]
MOV RSI,qword ptr [RBP + -0xb8]
OR R8B,0x80
MOV dword ptr [RBP + -0xa8],R8D
PUSH 0x0
CALL 0x00113120
POP RDX
POP RCX
TEST AL,AL
JZ 0x0010656e
LAB_001064cc:
MOV RAX,qword ptr [RBP + -0x98]
CMP qword ptr [RAX + -0x28],R12
MOV qword ptr [RAX + -0x30],R12
SETNZ byte ptr [RAX + -0x20]
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x88],RAX
LAB_001064ed:
MOV RSI,qword ptr [RBP + -0x118]
MOV RDI,qword ptr [RBP + -0x110]
CALL 0x00107c90
TEST AL,AL
JZ 0x00106330
LAB_00106508:
MOV RAX,R13
SUB RAX,R15
TEST RAX,RAX
JLE 0x00106283
NOP word ptr [RAX + RAX*0x1]
LAB_00106520:
MOVSX ESI,byte ptr [R15]
MOV RDI,RBX
CALL 0x00104580
ADD R15,0x1
CMP R13,R15
JNZ 0x00106520
JMP 0x00106283
LAB_00106540:
MOV EDX,0xf
JMP 0x001063b8
LAB_00106550:
LEA RDX,[RAX + RCX*0x1 + -0x48]
MOV R15,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
JZ 0x0010646e
CMP RSI,RAX
CMOVNZ RDX,RAX
JMP 0x0010646e
LAB_0010656e:
MOV qword ptr [RBP + -0xb0],0x0
JMP 0x001064ed
LAB_0010657e:
CMP R12,qword ptr [RBP + -0xb8]
JZ 0x0010656e
SUB RSP,0x8
MOV R8D,dword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RBP + -0xb0]
XOR R9D,R9D
MOV RDX,qword ptr [RBP + -0x120]
MOV RSI,qword ptr [RBP + -0xb8]
PUSH 0x0
OR R8D,0x60
CALL 0x00113120
POP RSI
POP RDI
LEA RDI,[R12 + 0x1]
TEST AL,AL
JZ 0x0010648d
JMP 0x001064cc
LAB_001065c9:
LEA RAX,[RAX + RCX*0x1 + -0x48]
JMP 0x0010647d
LAB_001065d3:
PXOR XMM0,XMM0
LEA R14,[RBP + -0x60]
MOV RDI,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0xc0],0x0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV RSI,R14
PXOR XMM0,XMM0
MOV qword ptr [RBP + -0xb8],0x0
MOV qword ptr [RBP + -0xb0],0x0
MOV dword ptr [RBP + -0xa8],0x0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
LAB_00106624:
CALL 0x001050a0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,R14
MOV qword ptr [RBP + -0x88],RAX
CALL 0x00107c60
JMP 0x00106217
LAB_00106641:
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 0x001062e1
LAB_00106660:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDX],EAX
JMP 0x001062d8
LAB_0010666e:
CALL 0x001078d0
JMP 0x001062e1
LAB_00106678:
CALL 0x001045e0
LAB_0010667d:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106691
LAB_0010668c:
CALL 0x00104630
LAB_00106691:
CALL 0x001045e0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
string sVar2;
string *psVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
string *psVar10;
long lVar11;
long *plVar12;
ulong uVar13;
ulong uVar14;
long *in_RSI;
long lVar15;
string *psVar16;
long lVar17;
long in_FS_OFFSET;
locale local_f8 [2];
long local_f0;
regex local_e8 [8];
int local_e0 [8];
int local_d8 [16];
long local_c8;
long lStack_c0;
regex *local_b8;
uint local_b0;
int local_a8 [16];
int local_98 [16];
regex_iterator local_88 [16];
int local_78 [16];
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_68 [16];
int local_58 [16];
long local_40;
local_78._12_4_ = SUB84(local_78._0_8_,4);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_e0);
local_d8 = (int [16])0x0;
/* try { // try from 0010616f to 00106173 has its CatchHandler @ 001066c6 */
std::regex::_M_compile(local_e8,"[\\W_]+","",0x10);
param_1[0x10] = (string)0x0;
*(string **)param_1 = param_1 + 0x10;
lVar17 = *in_RSI;
*(int8 *)(param_1 + 8) = 0;
lVar15 = in_RSI[1];
local_b0 = 0;
lVar11 = lVar17 + lVar15;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_c8 = lVar17;
lStack_c0 = lVar11;
local_b8 = local_e8;
/* try { // try from 00106206 to 0010620a has its CatchHandler @ 001066a2 */
bVar6 = 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)lVar17,(__normal_iterator)lVar11,(match_results *)local_a8,
local_e8,0,0,false);
if (!bVar6) {
local_c8 = 0;
local_78 = (int [16])0x0;
lStack_c0 = 0;
local_b8 = (regex *)0x0;
local_b0 = 0;
local_88[0] = (regex_iterator)0x0;
local_88[1] = (regex_iterator)0x0;
local_88[2] = (regex_iterator)0x0;
local_88[3] = (regex_iterator)0x0;
local_88[4] = (regex_iterator)0x0;
local_88[5] = (regex_iterator)0x0;
local_88[6] = (regex_iterator)0x0;
local_88[7] = (regex_iterator)0x0;
local_88[8] = (regex_iterator)0x0;
local_88[9] = (regex_iterator)0x0;
local_88[10] = (regex_iterator)0x0;
local_88[0xb] = (regex_iterator)0x0;
local_88[0xc] = (regex_iterator)0x0;
local_88[0xd] = (regex_iterator)0x0;
local_88[0xe] = (regex_iterator)0x0;
local_88[0xf] = (regex_iterator)0x0;
local_68[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[10] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_58 = (int [16])0x0;
/* try { // try from 00106624 to 00106628 has its CatchHandler @ 001066ae */
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_a8,(vector *)local_68);
local_98._8_8_ = local_58._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_68);
}
local_78._0_12_ = ZEXT812(0);
local_88[0] = (regex_iterator)0x0;
local_88[1] = (regex_iterator)0x0;
local_88[2] = (regex_iterator)0x0;
local_88[3] = (regex_iterator)0x0;
local_88[4] = (regex_iterator)0x0;
local_88[5] = (regex_iterator)0x0;
local_88[6] = (regex_iterator)0x0;
local_88[7] = (regex_iterator)0x0;
local_88[8] = (regex_iterator)0x0;
local_88[9] = (regex_iterator)0x0;
local_88[10] = (regex_iterator)0x0;
local_88[0xb] = (regex_iterator)0x0;
local_88[0xc] = (regex_iterator)0x0;
local_88[0xd] = (regex_iterator)0x0;
local_88[0xe] = (regex_iterator)0x0;
local_88[0xf] = (regex_iterator)0x0;
local_68[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[10] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_58 = (int [16])0x0;
cVar7 = 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_c8,local_88);
if (cVar7 == '\0') {
do {
lVar11 = local_a8._0_8_ + -0x30;
if ((ulong)(local_a8._8_8_ - local_a8._0_8_) < 0x49) {
lVar11 = local_a8._0_8_ + -0x48;
}
puVar9 = (int8 *)(lVar11 + (local_a8._8_8_ - local_a8._0_8_));
psVar3 = (string *)puVar9[1];
psVar16 = (string *)*puVar9;
if (psVar3 != psVar16 && -1 < (long)psVar3 - (long)psVar16) {
do {
uVar13 = *(ulong *)(param_1 + 8);
sVar2 = *psVar16;
psVar10 = *(string **)param_1;
if (param_1 + 0x10 == psVar10) {
uVar14 = 0xf;
}
else {
uVar14 = *(ulong *)(param_1 + 0x10);
}
if (uVar14 < uVar13 + 1) {
std::string::_M_mutate((ulong)param_1,uVar13,(char *)0x0,0);
psVar10 = *(string **)param_1;
}
psVar16 = psVar16 + 1;
psVar10[uVar13] = sVar2;
*(ulong *)(param_1 + 8) = uVar13 + 1;
*(int *)(*(long *)param_1 + 1 + uVar13) = 0;
} while (psVar3 != psVar16);
}
std::locale::locale(local_f8);
std::locale::locale(&local_f0,local_f8);
lVar11 = std::locale::id::_M_id();
if (*(long *)(*(long *)(local_f0 + 8) + lVar11 * 8) == 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 0010668c to 00106690 has its CatchHandler @ 00106696 */
std::__throw_bad_cast();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
std::locale::~locale(&local_f0);
std::locale::~locale(local_f8);
uVar13 = local_a8._8_8_ - local_a8._0_8_;
if (uVar13 < 0x49) {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x48));
lVar11 = *plVar12;
lVar17 = plVar12[1];
if ((uVar13 != 0x48) && (local_a8._8_8_ != local_a8._0_8_)) {
plVar12 = (long *)local_a8._0_8_;
}
}
else {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x18));
lVar11 = *plVar12;
lVar17 = plVar12[1];
plVar12 = (long *)(local_a8._8_8_ + (uVar13 - 0x48));
if (local_a8._8_8_ != local_a8._0_8_) {
plVar12 = (long *)local_a8._0_8_;
}
}
if (*(char *)(plVar12 + 2) != '\0') {
plVar12 = (long *)local_a8._0_8_;
if (local_a8._8_8_ == local_a8._0_8_) {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x48));
}
lVar4 = plVar12[1];
lVar15 = lVar4;
if (lVar4 == *plVar12) {
if (lVar4 == lStack_c0) goto LAB_0010656e;
bVar6 = 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)lVar4,(__normal_iterator)lStack_c0,
(match_results *)local_a8,local_b8,local_b0 | 0x60,0,false);
lVar15 = lVar4 + 1;
if (!bVar6) goto LAB_0010648d;
}
else {
LAB_0010648d:
local_b0 = local_b0 | 0x80;
bVar6 = 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)lVar15,(__normal_iterator)lStack_c0,
(match_results *)local_a8,local_b8,local_b0,0,false);
if (!bVar6) {
LAB_0010656e:
local_b8 = (regex *)0x0;
goto LAB_001064ed;
}
}
*(long *)(local_a8._8_8_ + -0x30) = lVar4;
*(bool *)(local_a8._8_8_ + -0x20) = *(long *)(local_a8._8_8_ + -0x28) != lVar4;
local_98._8_8_ = local_c8;
}
LAB_001064ed:
cVar7 = 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_c8,local_88);
} while (cVar7 == '\0');
if (lVar17 != lVar11 && -1 < lVar17 - lVar11) {
do {
std::string::push_back((char)param_1);
lVar11 = lVar11 + 1;
} while (lVar17 != lVar11);
}
}
else if (0 < lVar15) {
do {
/* try { // try from 00106272 to 001065b4 has its CatchHandler @ 001066ba */
std::string::push_back((char)param_1);
lVar17 = lVar17 + 1;
} while (lVar11 != lVar17);
}
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_68);
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_a8);
uVar5 = 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))();
(**(code **)(*(long *)uVar5 + 0x18))(uVar5);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar8 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar8 = *(int *)(local_d8._8_8_ + 8);
*(int *)(local_d8._8_8_ + 8) = iVar8 + -1;
}
if (iVar8 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
}
}
std::locale::~locale(local_e0);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,908 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& lst1, const std::vector<int>& lst2) {
std::vector<int> res_list;
for (int i = 0; i < lst1.size(); i++) {
res_list.push_back(lst1[i] + lst2[i]);
}
return res_list;
}
| int main() {
assert(func0({10,20,30}, {15,25,35}) == std::vector<int>({25,45,65}));
assert(func0({1,2,3}, {5,6,7}) == std::vector<int>({6,8,10}));
assert(func0({15,20,30}, {15,45,75}) == std::vector<int>({30,65,105}));
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 $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 -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b96 <_ZNSt6vectorIiSaIiEEC1Ev>
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1c9c <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,%rbx
setb %al
test %al,%al
je 130a <_Z5func0RKSt6vectorIiSaIiEES3_+0xc1>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cc4 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cc4 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add %ebx,%eax
mov %eax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1ce8 <_ZNSt6vectorIiSaIiEE9push_backEOi>
addl $0x1,-0x1c(%rbp)
jmp 1284 <_Z5func0RKSt6vectorIiSaIiEES3_+0x3b>
endbr64
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1c54 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 131f <_Z5func0RKSt6vectorIiSaIiEES3_+0xd6>
callq 1130 <__stack_chk_fail@plt>
mov -0x28(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov [rbp+var_1C], 0
jmp short loc_12F0
loc_12A6:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
add eax, ebx
mov [rbp+var_20], eax
lea rdx, [rbp+var_20]
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
add [rbp+var_1C], 1
loc_12F0:
mov eax, [rbp+var_1C]
movsxd rbx, eax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp rbx, rax
setb al
test al, al
jnz short loc_12A6
jmp short loc_1340
endbr64
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1338
call ___stack_chk_fail
loc_1338:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1340:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_1354
call ___stack_chk_fail
loc_1354:
mov rax, [rbp+var_28]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
unsigned long long v4; // rbx
int v7; // [rsp+20h] [rbp-20h] BYREF
int i; // [rsp+24h] [rbp-1Ch]
unsigned long long v9; // [rsp+28h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0; ; ++i )
{
v4 = i;
if ( v4 >= std::vector<int>::size(a2) )
break;
v3 = *(_DWORD *)std::vector<int>::operator[](a2, i);
v7 = v3 + *(_DWORD *)std::vector<int>::operator[](a3, i);
std::vector<int>::push_back(a1, &v7);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101c34
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001012f0
LAB_001012a6:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d5a
MOV EBX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d5a
MOV EAX,dword ptr [RAX]
ADD EAX,EBX
MOV dword ptr [RBP + -0x20],EAX
LEA RDX,[RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
LAB_001012e7:
CALL 0x00101d7e
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012f0:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101d32
CMP RBX,RAX
SETC AL
TEST AL,AL
JNZ 0x001012a6
JMP 0x00101340
LAB_00101340:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101354
CALL 0x00101150
LAB_00101354:
MOV RAX,qword ptr [RBP + -0x28]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
ulong uVar4;
long in_FS_OFFSET;
int local_28;
int local_24;
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_24 = 0;
while( true ) {
uVar4 = (ulong)local_24;
uVar3 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_2);
if (uVar3 <= uVar4) break;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,(long)local_24);
iVar1 = *piVar2;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](in_RDX,(long)local_24);
local_28 = *piVar2 + iVar1;
/* try { // try from 001012e7 to 001012eb has its CatchHandler @ 0010130e */
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_28);
local_24 = local_24 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,909 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& lst1, const std::vector<int>& lst2) {
std::vector<int> res_list;
for (int i = 0; i < lst1.size(); i++) {
res_list.push_back(lst1[i] + lst2[i]);
}
return res_list;
}
| int main() {
assert(func0({10,20,30}, {15,25,35}) == std::vector<int>({25,45,65}));
assert(func0({1,2,3}, {5,6,7}) == std::vector<int>({6,8,10}));
assert(func0({15,20,30}, {15,45,75}) == std::vector<int>({30,65,105}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 1300 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb7>
mov %rsi,%r12
mov $0x0,%ebx
lea 0x4(%rsp),%r14
jmp 12c2 <_Z5func0RKSt6vectorIiSaIiEES3_+0x79>
mov %r14,%rdx
mov %rbp,%rdi
callq 190e <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov (%r12),%rdx
add $0x1,%rbx
mov 0x8(%r12),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 1300 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb7>
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 129e <_Z5func0RKSt6vectorIiSaIiEES3_+0x55>
mov %eax,(%rsi)
addq $0x4,0x8(%rbp)
jmp 12a9 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 12f8 <_Z5func0RKSt6vectorIiSaIiEES3_+0xaf>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1320 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd7>
mov %rbp,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp [rsi+8], rdx
jz loc_1313
mov r12, rsi
mov ebx, 0
lea r14, [rsp+38h+var_34]
jmp short loc_12C6
loc_12A2:
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
loc_12AD:
mov rdx, [r12]
add rbx, 1
mov rax, [r12+8]
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_1313
loc_12C6:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_12A2
mov [rsi], eax
add qword ptr [rbp+8], 4
jmp short loc_12AD
endbr64
mov rbx, rax
mov rdi, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_130B
call ___stack_chk_fail
loc_130B:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1313:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1333
mov rax, rbp
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1333:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // eax
int *v8; // rsi
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( a2[1] != *a2 )
{
v6 = 0LL;
do
{
v7 = *(_DWORD *)(*a3 + 4 * v6) + *(_DWORD *)(v4 + 4 * v6);
v10 = v7;
v8 = (int *)a1[1];
if ( v8 == (int *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v10);
}
else
{
*v8 = v7;
a1[1] += 4LL;
}
v4 = *a2;
++v6;
}
while ( v6 < (a2[1] - *a2) >> 2 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101313
MOV R12,RSI
MOV EBX,0x0
LEA R14,[RSP + 0x4]
JMP 0x001012c6
LAB_001012a2:
MOV RDX,R14
MOV RDI,RBP
LAB_001012a8:
CALL 0x0010193e
LAB_001012ad:
MOV RDX,qword ptr [R12]
ADD RBX,0x1
MOV RAX,qword ptr [R12 + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101313
LAB_001012c6:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x001012a2
MOV dword ptr [RSI],EAX
ADD qword ptr [RBP + 0x8],0x4
JMP 0x001012ad
LAB_00101313:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101333
MOV RAX,RBP
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101333:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar2 = *(long *)param_2;
if (*(long *)(param_2 + 8) != lVar2) {
uVar3 = 0;
do {
local_34 = *(int *)(lVar2 + uVar3 * 4) + *(int *)(*in_RDX + uVar3 * 4);
piVar1 = *(int **)(param_1 + 8);
if (piVar1 == *(int **)(param_1 + 0x10)) {
/* try { // try from 001012a8 to 001012ac has its CatchHandler @ 001012e7 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar1,&local_34);
}
else {
*piVar1 = local_34;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
lVar2 = *(long *)param_2;
uVar3 = uVar3 + 1;
} while (uVar3 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,910 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& lst1, const std::vector<int>& lst2) {
std::vector<int> res_list;
for (int i = 0; i < lst1.size(); i++) {
res_list.push_back(lst1[i] + lst2[i]);
}
return res_list;
}
| int main() {
assert(func0({10,20,30}, {15,25,35}) == std::vector<int>({25,45,65}));
assert(func0({1,2,3}, {5,6,7}) == std::vector<int>({6,8,10}));
assert(func0({15,20,30}, {15,45,75}) == std::vector<int>({30,65,105}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 17e0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov %rsi,%rbp
xor %ebx,%ebx
xor %edi,%edi
xor %esi,%esi
lea 0x4(%rsp),%r14
jmp 17bd <_Z5func0RKSt6vectorIiSaIiEES3_+0x8d>
nopw %cs:0x0(%rax,%rax,1)
mov %eax,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 17e0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
cmp %rdi,%rsi
jne 1790 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
mov %r14,%rdx
mov %r12,%rdi
callq 1930 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 179b <_Z5func0RKSt6vectorIiSaIiEES3_+0x6b>
nopl (%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1800 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_17D0
mov r12, rsi
xor ebx, ebx
xor edi, edi
xor esi, esi
lea r14, [rsp+38h+var_34]
jmp short loc_17A7
loc_1780:
mov [rsi], eax
add rsi, 4
mov [rbp+8], rsi
loc_178A:
mov rax, [r12+8]
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_17D0
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_17A7:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
cmp rsi, rdi
jnz short loc_1780
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rdx, [r12]
jmp short loc_178A
loc_17D0:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17F0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17F0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
long long v7; // rbx
int *v8; // rdi
int *v9; // rsi
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v5 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(*a3 + 4 * v7) + *(_DWORD *)(v5 + 4 * v7);
v12 = v10;
if ( v9 == v8 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v9, &v12);
v5 = *a2;
}
else
{
*v9 = v10;
*(_QWORD *)(a1 + 8) = v9 + 1;
}
if ( ++v7 >= (unsigned long long)((a2[1] - v5) >> 2) )
break;
v9 = *(int **)(a1 + 8);
v8 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017d0
MOV R12,RSI
XOR EBX,EBX
XOR EDI,EDI
XOR ESI,ESI
LEA R14,[RSP + 0x4]
JMP 0x001017a7
LAB_00101780:
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010178a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x001017d0
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_001017a7:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x00101780
MOV RDX,R14
MOV RDI,RBP
LAB_001017c0:
CALL 0x00101920
MOV RDX,qword ptr [R12]
JMP 0x0010178a
LAB_001017d0:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017f0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017f0:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long *in_RDX;
long lVar1;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
uVar2 = 0;
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) + *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 001017c0 to 001017c4 has its CatchHandler @ 001017f5 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,911 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& lst1, const std::vector<int>& lst2) {
std::vector<int> res_list;
for (int i = 0; i < lst1.size(); i++) {
res_list.push_back(lst1[i] + lst2[i]);
}
return res_list;
}
| int main() {
assert(func0({10,20,30}, {15,25,35}) == std::vector<int>({25,45,65}));
assert(func0({1,2,3}, {5,6,7}) == std::vector<int>({6,8,10}));
assert(func0({15,20,30}, {15,45,75}) == std::vector<int>({30,65,105}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 1830 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov %rsi,%rbp
xor %ebx,%ebx
xor %edi,%edi
xor %esi,%esi
lea 0x4(%rsp),%r14
jmp 180d <_Z5func0RKSt6vectorIiSaIiEES3_+0x7d>
xchg %ax,%ax
mov %eax,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rbx,%rax
jbe 1830 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
cmp %rdi,%rsi
jne 17e0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 18c0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 17eb <_Z5func0RKSt6vectorIiSaIiEES3_+0x5b>
nopl (%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1850 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_17D0
mov r12, rsi
xor ebx, ebx
xor edi, edi
xor esi, esi
lea r14, [rsp+38h+var_34]
jmp short loc_17A7
loc_1780:
mov [rsi], eax
add rsi, 4
mov [rbp+8], rsi
loc_178A:
mov rax, [r12+8]
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_17D0
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_17A7:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
cmp rsi, rdi
jnz short loc_1780
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rdx, [r12]
jmp short loc_178A
loc_17D0:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17F0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17F0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
long long v7; // rbx
int *v8; // rdi
int *v9; // rsi
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v5 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(*a3 + 4 * v7) + *(_DWORD *)(v5 + 4 * v7);
v12 = v10;
if ( v9 == v8 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v9, &v12);
v5 = *a2;
}
else
{
*v9 = v10;
*(_QWORD *)(a1 + 8) = v9 + 1;
}
if ( ++v7 >= (unsigned long long)((a2[1] - v5) >> 2) )
break;
v9 = *(int **)(a1 + 8);
v8 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017d0
MOV R12,RSI
XOR EBX,EBX
XOR EDI,EDI
XOR ESI,ESI
LEA R14,[RSP + 0x4]
JMP 0x001017a7
LAB_00101780:
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010178a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x001017d0
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_001017a7:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x00101780
MOV RDX,R14
MOV RDI,RBP
LAB_001017c0:
CALL 0x00101920
MOV RDX,qword ptr [R12]
JMP 0x0010178a
LAB_001017d0:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017f0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017f0:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long *in_RDX;
long lVar1;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
uVar2 = 0;
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) + *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 001017c0 to 001017c4 has its CatchHandler @ 001017f5 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,912 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] + nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({5, 7, 9}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({4, 6}));
assert(func0({10, 20}, {50, 70}) == std::vector<int>({60, 90}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1b66 <_ZNSt6vectorIiSaIiEEC1Ev>
movq $0x0,-0x20(%rbp)
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1c6c <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x20(%rbp)
setb %al
test %al,%al
je 1303 <_Z5func0RKSt6vectorIiSaIiEES3_+0xba>
mov -0x20(%rbp),%rdx
mov -0x40(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c94 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x20(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c94 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
add %ebx,%eax
mov %eax,-0x24(%rbp)
lea -0x24(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1cb8 <_ZNSt6vectorIiSaIiEE9push_backEOi>
addq $0x1,-0x20(%rbp)
jmp 1285 <_Z5func0RKSt6vectorIiSaIiEES3_+0x3c>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1c24 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1150 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1318 <_Z5func0RKSt6vectorIiSaIiEES3_+0xcf>
callq 1130 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov [rbp+var_20], 0
jmp short loc_12EE
loc_12A7:
mov rdx, [rbp+var_20]
mov rax, [rbp+var_40]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_48]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
add eax, ebx
mov [rbp+var_24], eax
lea rdx, [rbp+var_24]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backEOi; std::vector<int>::push_back(int &&)
add [rbp+var_20], 1
loc_12EE:
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_20], rax
setb al
test al, al
jnz short loc_12A7
jmp short loc_1339
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1331
call ___stack_chk_fail
loc_1331:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1339:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_134D
call ___stack_chk_fail
loc_134D:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
unsigned long long v4; // rax
int v7; // [rsp+2Ch] [rbp-24h] BYREF
unsigned long long i; // [rsp+30h] [rbp-20h]
unsigned long long v9; // [rsp+38h] [rbp-18h]
v9 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = 0LL; ; ++i )
{
v4 = std::vector<int>::size(a2);
if ( i >= v4 )
break;
v3 = *(_DWORD *)std::vector<int>::operator[](a2, i);
v7 = v3 + *(_DWORD *)std::vector<int>::operator[](a3, i);
std::vector<int>::push_back(a1, &v7);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c02
MOV qword ptr [RBP + -0x20],0x0
JMP 0x001012ee
LAB_001012a7:
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x40]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d28
MOV EBX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101d28
MOV EAX,dword ptr [RAX]
ADD EAX,EBX
MOV dword ptr [RBP + -0x24],EAX
LEA RDX,[RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
LAB_001012e4:
CALL 0x00101d4c
ADD qword ptr [RBP + -0x20],0x1
LAB_001012ee:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101d00
CMP qword ptr [RBP + -0x20],RAX
SETC AL
TEST AL,AL
JNZ 0x001012a7
JMP 0x00101339
LAB_00101339:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010134d
CALL 0x00101150
LAB_0010134d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
long in_FS_OFFSET;
int local_2c;
ulong local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)param_1);
local_28 = 0;
while( true ) {
uVar3 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_2);
if (uVar3 <= local_28) break;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_2,local_28);
iVar1 = *piVar2;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[](in_RDX,local_28);
local_2c = *piVar2 + iVar1;
/* try { // try from 001012e4 to 001012e8 has its CatchHandler @ 00101307 */
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_2c);
local_28 = local_28 + 1;
}
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,913 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] + nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({5, 7, 9}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({4, 6}));
assert(func0({10, 20}, {50, 70}) == std::vector<int>({60, 90}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 1300 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb7>
mov %rsi,%r12
mov $0x0,%ebx
lea 0x4(%rsp),%r14
jmp 12c2 <_Z5func0RKSt6vectorIiSaIiEES3_+0x79>
mov %r14,%rdx
mov %rbp,%rdi
callq 18cc <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x1,%rbx
mov (%r12),%rdx
mov 0x8(%r12),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1300 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb7>
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 129e <_Z5func0RKSt6vectorIiSaIiEES3_+0x55>
mov %eax,(%rsi)
addq $0x4,0x8(%rbp)
jmp 12a9 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 12f8 <_Z5func0RKSt6vectorIiSaIiEES3_+0xaf>
callq 1110 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1150 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1320 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd7>
mov %rbp,%rax
add $0x10,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi]
cmp rdx, [rsi+8]
jz loc_1313
mov r12, rsi
mov ebx, 0
lea r14, [rsp+38h+var_34]
jmp short loc_12C6
loc_12A2:
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
loc_12AD:
add rbx, 1
mov rdx, [r12]
mov rax, [r12+8]
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_1313
loc_12C6:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_12A2
mov [rsi], eax
add qword ptr [rbp+8], 4
jmp short loc_12AD
endbr64
mov rbx, rax
mov rdi, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_0]
sub rax, fs:28h
jz short loc_130B
call ___stack_chk_fail
loc_130B:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1313:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1333
mov rax, rbp
add rsp, 10h
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1333:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // eax
int *v8; // rsi
int v10; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v11; // [rsp+8h] [rbp-30h]
v11 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v4 = *a2;
if ( *a2 != a2[1] )
{
v6 = 0LL;
do
{
v7 = *(_DWORD *)(*a3 + 4 * v6) + *(_DWORD *)(v4 + 4 * v6);
v10 = v7;
v8 = (int *)a1[1];
if ( v8 == (int *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v10);
}
else
{
*v8 = v7;
a1[1] += 4LL;
}
++v6;
v4 = *a2;
}
while ( v6 < (a2[1] - *a2) >> 2 );
}
return a1;
} | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x00101313
MOV R12,RSI
MOV EBX,0x0
LEA R14,[RSP + 0x4]
JMP 0x001012c6
LAB_001012a2:
MOV RDX,R14
MOV RDI,RBP
LAB_001012a8:
CALL 0x001018fc
LAB_001012ad:
ADD RBX,0x1
MOV RDX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x00101313
LAB_001012c6:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x001012a2
MOV dword ptr [RSI],EAX
ADD qword ptr [RBP + 0x8],0x4
JMP 0x001012ad
LAB_00101313:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101333
MOV RAX,RBP
ADD RSP,0x10
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101333:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar2 = *(long *)param_2;
if (lVar2 != *(long *)(param_2 + 8)) {
uVar3 = 0;
do {
local_34 = *(int *)(lVar2 + uVar3 * 4) + *(int *)(*in_RDX + uVar3 * 4);
piVar1 = *(int **)(param_1 + 8);
if (piVar1 == *(int **)(param_1 + 0x10)) {
/* try { // try from 001012a8 to 001012ac has its CatchHandler @ 001012e7 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar1,&local_34);
}
else {
*piVar1 = local_34;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
uVar3 = uVar3 + 1;
lVar2 = *(long *)param_2;
} while (uVar3 < (ulong)(*(long *)(param_2 + 8) - lVar2 >> 2));
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,914 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] + nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({5, 7, 9}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({4, 6}));
assert(func0({10, 20}, {50, 70}) == std::vector<int>({60, 90}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 17a0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov %rsi,%rbp
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
lea 0x4(%rsp),%r14
jmp 177d <_Z5func0RKSt6vectorIiSaIiEES3_+0x8d>
nopw %cs:0x0(%rax,%rax,1)
mov %eax,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 17a0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xb0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
cmp %rdi,%rsi
jne 1750 <_Z5func0RKSt6vectorIiSaIiEES3_+0x60>
mov %r14,%rdx
mov %r12,%rdi
callq 18f0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 175b <_Z5func0RKSt6vectorIiSaIiEES3_+0x6b>
nopl (%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 17c0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xd0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_17A0
mov r12, rsi
xor edi, edi
xor esi, esi
xor ebx, ebx
lea r14, [rsp+38h+var_34]
jmp short loc_1777
loc_1750:
mov [rsi], eax
add rsi, 4
mov [rbp+8], rsi
loc_175A:
mov rax, [r12+8]
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_17A0
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_1777:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
cmp rsi, rdi
jnz short loc_1750
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rdx, [r12]
jmp short loc_175A
loc_17A0:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17C0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17C0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v5 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(*a3 + 4 * v9) + *(_DWORD *)(v5 + 4 * v9);
v12 = v10;
if ( v8 == v7 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v12);
v5 = *a2;
}
else
{
*v8 = v10;
*(_QWORD *)(a1 + 8) = v8 + 1;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v5) >> 2) )
break;
v8 = *(int **)(a1 + 8);
v7 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017a0
MOV R12,RSI
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
LEA R14,[RSP + 0x4]
JMP 0x00101777
LAB_00101750:
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010175a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x001017a0
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_00101777:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x00101750
MOV RDX,R14
MOV RDI,RBP
LAB_00101790:
CALL 0x001018f0
MOV RDX,qword ptr [R12]
JMP 0x0010175a
LAB_001017a0:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017c0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017c0:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long *in_RDX;
long lVar1;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
uVar2 = 0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) + *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 00101790 to 00101794 has its CatchHandler @ 001017c5 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,915 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& nums1, const std::vector<int>& nums2) {
std::vector<int> result;
for (size_t i = 0; i < nums1.size(); ++i) {
result.push_back(nums1[i] + nums2[i]);
}
return result;
}
| int main() {
assert(func0({1, 2, 3}, {4, 5, 6}) == std::vector<int>({5, 7, 9}));
assert(func0({1, 2}, {3, 4}) == std::vector<int>({4, 6}));
assert(func0({10, 20}, {50, 70}) == std::vector<int>({60, 90}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
mov %rdx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rdx
cmp 0x8(%rsi),%rdx
je 17f0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov %rsi,%rbp
xor %edi,%edi
xor %esi,%esi
xor %ebx,%ebx
lea 0x4(%rsp),%r14
jmp 17cd <_Z5func0RKSt6vectorIiSaIiEES3_+0x7d>
xchg %ax,%ax
mov %eax,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x0(%rbp),%rdx
mov 0x8(%rbp),%rax
add $0x1,%rbx
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 17f0 <_Z5func0RKSt6vectorIiSaIiEES3_+0xa0>
mov 0x8(%r12),%rsi
mov 0x10(%r12),%rdi
mov 0x0(%r13),%rcx
mov (%rdx,%rbx,4),%eax
add (%rcx,%rbx,4),%eax
mov %eax,0x4(%rsp)
cmp %rdi,%rsi
jne 17a0 <_Z5func0RKSt6vectorIiSaIiEES3_+0x50>
mov %r14,%rdx
mov %r12,%rdi
callq 1880 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 17ab <_Z5func0RKSt6vectorIiSaIiEES3_+0x5b>
nopl (%rax)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1810 <_Z5func0RKSt6vectorIiSaIiEES3_+0xc0>
add $0x10,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
callq 1130 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1175 <_Z5func0RKSt6vectorIiSaIiEES3_.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rdx
jz short loc_17A0
mov r12, rsi
xor edi, edi
xor esi, esi
xor ebx, ebx
lea r14, [rsp+38h+var_34]
jmp short loc_1777
loc_1750:
mov [rsi], eax
add rsi, 4
mov [rbp+8], rsi
loc_175A:
mov rax, [r12+8]
add rbx, 1
sub rax, rdx
sar rax, 2
cmp rbx, rax
jnb short loc_17A0
mov rsi, [rbp+8]
mov rdi, [rbp+10h]
loc_1777:
mov rcx, [r13+0]
mov eax, [rdx+rbx*4]
add eax, [rcx+rbx*4]
mov [rsp+38h+var_34], eax
cmp rsi, rdi
jnz short loc_1750
mov rdx, r14
mov rdi, rbp
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int &&)
mov rdx, [r12]
jmp short loc_175A
loc_17A0:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_17C0
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_17C0:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEES3__cold; func0(std::vector<int> const&,std::vector<int> const&) [clone] | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v5; // rdx
int *v7; // rdi
int *v8; // rsi
long long v9; // rbx
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v5 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
if ( a2[1] != v5 )
{
v7 = 0LL;
v8 = 0LL;
v9 = 0LL;
while ( 1 )
{
v10 = *(_DWORD *)(*a3 + 4 * v9) + *(_DWORD *)(v5 + 4 * v9);
v12 = v10;
if ( v8 == v7 )
{
std::vector<int>::_M_realloc_insert<int>(a1, v8, &v12);
v5 = *a2;
}
else
{
*v8 = v10;
*(_QWORD *)(a1 + 8) = v8 + 1;
}
if ( ++v9 >= (unsigned long long)((a2[1] - v5) >> 2) )
break;
v8 = *(int **)(a1 + 8);
v7 = *(int **)(a1 + 16);
}
}
return a1;
} | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017a0
MOV R12,RSI
XOR EDI,EDI
XOR ESI,ESI
XOR EBX,EBX
LEA R14,[RSP + 0x4]
JMP 0x00101777
LAB_00101750:
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_0010175a:
MOV RAX,qword ptr [R12 + 0x8]
ADD RBX,0x1
SUB RAX,RDX
SAR RAX,0x2
CMP RBX,RAX
JNC 0x001017a0
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,qword ptr [RBP + 0x10]
LAB_00101777:
MOV RCX,qword ptr [R13]
MOV EAX,dword ptr [RDX + RBX*0x4]
ADD EAX,dword ptr [RCX + RBX*0x4]
MOV dword ptr [RSP + 0x4],EAX
CMP RSI,RDI
JNZ 0x00101750
MOV RDX,R14
MOV RDI,RBP
LAB_00101790:
CALL 0x001018f0
MOV RDX,qword ptr [R12]
JMP 0x0010175a
LAB_001017a0:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001017c0
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001017c0:
CALL 0x00101130 | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
vector * func0(vector *param_1,vector *param_2)
{
long *in_RDX;
long lVar1;
ulong uVar2;
int *piVar3;
int *piVar4;
long in_FS_OFFSET;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
*(int (*) [16])param_1 = (int [16])0x0;
lVar1 = *(long *)param_2;
*(int8 *)(param_1 + 0x10) = 0;
if (*(long *)(param_2 + 8) != lVar1) {
piVar4 = (int *)0x0;
piVar3 = (int *)0x0;
uVar2 = 0;
while( true ) {
local_34 = *(int *)(lVar1 + uVar2 * 4) + *(int *)(*in_RDX + uVar2 * 4);
if (piVar3 == piVar4) {
/* try { // try from 00101790 to 00101794 has its CatchHandler @ 001017c5 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int>
((vector<int,std::allocator<int>> *)param_1,(__normal_iterator)piVar3,&local_34);
lVar1 = *(long *)param_2;
}
else {
*piVar3 = local_34;
*(int **)(param_1 + 8) = piVar3 + 1;
}
uVar2 = uVar2 + 1;
if ((ulong)(*(long *)(param_2 + 8) - lVar1 >> 2) <= uVar2) break;
piVar3 = *(int **)(param_1 + 8);
piVar4 = *(int **)(param_1 + 0x10);
}
}
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,916 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
template <typename T>
| std::vector<T> func0(std::vector<T> nums) {
std::vector<T> result;
if (!nums.empty()) {
typename std::vector<T>::iterator it = nums.begin();
T last = *it;
result.push_back(last);
++it;
for (; it != nums.end(); ++it) {
if (*it != last) {
last = *it;
result.push_back(last);
}
}
}
return result;
}
| int main() {
assert((func0(std::vector<int>{0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}) == std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4}));
assert((func0(std::vector<int>{10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10}) == std::vector<int>{10, 15, 19, 18, 17, 26, 17, 18, 10}));
assert((func0(std::vector<char>{'a', 'a', 'b', 'c', 'd', 'd'}) == std::vector<char>{'a', 'b', 'c', 'd'}));
return 0;
}
| O0 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1caa <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 23ec <_ZNKSt6vectorIiSaIiEE5emptyEv>
xor $0x1,%eax
test %al,%al
je 1de1 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x118>
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 2454 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x28(%rbp)
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 24a0 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x2c(%rbp)
lea -0x2c(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 24b6 <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 2536 <_ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv>
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 255a <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 25aa <_ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_>
test %al,%al
je 1de1 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x118>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 24a0 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%edx
mov -0x2c(%rbp),%eax
cmp %eax,%edx
setne %al
test %al,%al
je 1db5 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xec>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 24a0 <_ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv>
mov (%rax),%eax
mov %eax,-0x2c(%rbp)
lea -0x2c(%rbp),%rdx
mov -0x38(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 24b6 <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 2536 <_ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv>
jmp 1d50 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x87>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1c22 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1240 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 1df6 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x12d>
callq 11f0 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5emptyEv; std::vector<int>::empty(void)
xor eax, 1
test al, al
jz loc_1CE5
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_28], rax
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_2C], eax
lea rdx, [rbp+var_2C]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
lea rax, [rbp+var_28]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(void)
jmp short loc_1C8A
loc_1C40:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov edx, [rax]
mov eax, [rbp+var_2C]
cmp edx, eax
setnz al
test al, al
jz short loc_1C7E
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEdeEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(void)
mov eax, [rax]
mov [rbp+var_2C], eax
lea rdx, [rbp+var_2C]
mov rax, [rbp+var_38]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
loc_1C7E:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPiSt6vectorIiSaIiEEEppEv; __gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(void)
loc_1C8A:
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_20], rax
lea rdx, [rbp+var_20]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPiSt6vectorIiSaIiEEEEbRKNS_17__normal_iteratorIT_T0_EESA_; __gnu_cxx::operator!=<int *,std::vector<int>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&,__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
test al, al
jnz short loc_1C40
jmp short loc_1CE5
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_1CDD
call ___stack_chk_fail
loc_1CDD:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1CE5:
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_1CFA
call ___stack_chk_fail
loc_1CFA:
mov rax, [rbp+var_38]
mov rbx, [rbp+var_8]
leave
retn | long long func0<int>(long long a1, long long a2)
{
_DWORD *v2; // rax
int v4; // [rsp+14h] [rbp-2Ch] BYREF
long long v5; // [rsp+18h] [rbp-28h] BYREF
_QWORD v6[3]; // [rsp+20h] [rbp-20h] BYREF
v6[1] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
if ( (unsigned __int8)std::vector<int>::empty(a2) != 1 )
{
v5 = std::vector<int>::begin(a2);
v4 = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v5);
std::vector<int>::push_back(a1, &v4);
__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v5);
while ( 1 )
{
v6[0] = std::vector<int>::end(a2);
if ( !(unsigned __int8)__gnu_cxx::operator!=<int *,std::vector<int>>(&v5, v6) )
break;
v2 = (_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v5);
if ( *v2 != v4 )
{
v4 = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v5);
std::vector<int>::push_back(a1, &v4);
}
__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator++(&v5);
}
}
return a1;
} | func0<int>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101b98
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x0010230e
XOR EAX,0x1
TEST AL,AL
JZ 0x00101ce5
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00102376
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001023c2
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
LEA RDX,[RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101c2d:
CALL 0x001023d8
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001024a4
JMP 0x00101c8a
LAB_00101c40:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001023c2
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x2c]
CMP EDX,EAX
SETNZ AL
TEST AL,AL
JZ 0x00101c7e
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001023c2
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x2c],EAX
LEA RDX,[RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001023d8
LAB_00101c7e:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001024a4
LAB_00101c8a:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001024c8
MOV qword ptr [RBP + -0x20],RAX
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00102518
TEST AL,AL
JNZ 0x00101c40
JMP 0x00101ce5
LAB_00101ce5:
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00101cfa
CALL 0x00101150
LAB_00101cfa:
MOV RAX,qword ptr [RBP + -0x38]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector func0<int>(vector param_1)
{
char cVar1;
bool bVar2;
int *piVar3;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_34;
int8 local_30;
int8 local_28;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector(this);
cVar1 = std::vector<int,std::allocator<int>>::empty(in_RSI);
if (cVar1 != '\x01') {
local_30 = std::vector<int,std::allocator<int>>::begin(in_RSI);
piVar3 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_30);
local_34 = *piVar3;
/* try { // try from 00101c2d to 00101c7d has its CatchHandler @ 00101cb3 */
std::vector<int,std::allocator<int>>::push_back(this,&local_34);
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_30);
while( true ) {
local_28 = std::vector<int,std::allocator<int>>::end(in_RSI);
bVar2 = operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_28);
if (!bVar2) break;
piVar3 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_30);
if (*piVar3 != local_34) {
piVar3 = (int *)__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator*
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)
&local_30);
local_34 = *piVar3;
std::vector<int,std::allocator<int>>::push_back(this,&local_34);
}
__normal_iterator<int*,std::vector<int,std::allocator<int>>>::operator++
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_30);
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,917 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
template <typename T>
| std::vector<T> func0(std::vector<T> nums) {
std::vector<T> result;
if (!nums.empty()) {
typename std::vector<T>::iterator it = nums.begin();
T last = *it;
result.push_back(last);
++it;
for (; it != nums.end(); ++it) {
if (*it != last) {
last = *it;
result.push_back(last);
}
}
}
return result;
}
| int main() {
assert((func0(std::vector<int>{0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}) == std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4}));
assert((func0(std::vector<int>{10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10}) == std::vector<int>{10, 15, 19, 18, 17, 26, 17, 18, 10}));
assert((func0(std::vector<char>{'a', 'a', 'b', 'c', 'd', 'd'}) == std::vector<char>{'a', 'b', 'c', 'd'}));
return 0;
}
| O1 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
cmp 0x8(%rsi),%rbx
je 1c42 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xbd>
mov %rsi,%r12
mov (%rbx),%eax
mov %eax,0x4(%rsp)
lea 0x4(%rsp),%rdx
mov $0x0,%esi
callq 1a56 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x4,%rbx
cmp 0x8(%r12),%rbx
je 1c42 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xbd>
lea 0x4(%rsp),%r13
jmp 1c06 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x81>
mov %r13,%rdx
mov %rbp,%rdi
callq 1a56 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
add $0x4,%rbx
cmp %rbx,0x8(%r12)
je 1c42 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xbd>
mov (%rbx),%eax
cmp 0x4(%rsp),%eax
je 1bfb <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x76>
mov %eax,0x4(%rsp)
mov 0x8(%rbp),%rsi
cmp 0x10(%rbp),%rsi
je 1bf0 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x6b>
mov %eax,(%rsi)
addq $0x4,0x8(%rbp)
jmp 1bfb <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x76>
endbr64
mov %rax,%rbx
mov 0x0(%rbp),%rdi
test %rdi,%rdi
je 1c3a <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xb5>
callq 1140 <_ZdlPv@plt>
mov %rbx,%rdi
callq 1190 <_Unwind_Resume@plt>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1c60 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xdb>
mov %rbp,%rax
add $0x18,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
callq 1160 <__stack_chk_fail@plt>
| _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
cmp [rsi+8], rbx
jz short loc_1BFD
mov r12, rsi
mov eax, [rbx]
mov [rsp+28h+var_24], eax
lea rdx, [rsp+28h+var_24]
mov esi, 0
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
add rbx, 4
cmp rbx, [r12+8]
jnz short loc_1C31
loc_1BFD:
mov rax, [rsp+28h+var_20]
sub rax, fs:28h
jnz short loc_1C7C
mov rax, rbp
add rsp, 10h
pop rbx
pop rbp
pop r12
retn
loc_1C19:
lea rdx, [rsp+28h+var_24]
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&)
loc_1C26:
add rbx, 4
cmp [r12+8], rbx
jz short loc_1BFD
loc_1C31:
mov eax, [rbx]
cmp eax, [rsp+28h+var_24]
jz short loc_1C26
mov [rsp+28h+var_24], eax
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_1C19
mov [rsi], eax
add qword ptr [rbp+8], 4
jmp short loc_1C26
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_1C74
call ___stack_chk_fail
loc_1C74:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_1C7C:
call ___stack_chk_fail | _QWORD * func0<int>(_QWORD *a1, int **a2)
{
int *v2; // rbx
int *i; // rbx
int v6; // eax
_DWORD *v7; // rsi
int v8; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v9; // [rsp+8h] [rbp-20h]
v9 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *a2;
if ( a2[1] != *a2 )
{
v8 = *v2;
std::vector<int>::_M_realloc_insert<int const&>(a1, 0LL, &v8);
for ( i = v2 + 1; a2[1] != i; ++i )
{
v6 = *i;
if ( *i != v8 )
{
v8 = *i;
v7 = (_DWORD *)a1[1];
if ( v7 == (_DWORD *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v7, &v8);
}
else
{
*v7 = v6;
a1[1] += 4LL;
}
}
}
}
return a1;
} | func0<int>:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RBX
JZ 0x00101bfd
MOV R12,RSI
MOV EAX,dword ptr [RBX]
MOV dword ptr [RSP + 0x4],EAX
LEA RDX,[RSP + 0x4]
MOV ESI,0x0
LAB_00101bed:
CALL 0x00101a6a
ADD RBX,0x4
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x00101c31
LAB_00101bfd:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101c7c
MOV RAX,RBP
ADD RSP,0x10
POP RBX
POP RBP
POP R12
RET
LAB_00101c19:
LEA RDX,[RSP + 0x4]
MOV RDI,RBP
CALL 0x00101a6a
LAB_00101c26:
ADD RBX,0x4
CMP qword ptr [R12 + 0x8],RBX
JZ 0x00101bfd
LAB_00101c31:
MOV EAX,dword ptr [RBX]
CMP EAX,dword ptr [RSP + 0x4]
JZ 0x00101c26
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x00101c19
MOV dword ptr [RSI],EAX
ADD qword ptr [RBP + 0x8],0x4
JMP 0x00101c26
LAB_00101c7c:
CALL 0x00101130 | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0<int>(vector<int,std::allocator<int>> *param_1,int8 *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
long in_FS_OFFSET;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
piVar3 = (int *)*param_2;
if ((int *)param_2[1] != piVar3) {
local_24 = *piVar3;
/* try { // try from 00101bed to 00101c25 has its CatchHandler @ 00101c50 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>(param_1,0,&local_24);
piVar3 = piVar3 + 1;
if (piVar3 != (int *)param_2[1]) {
do {
iVar1 = *piVar3;
if (iVar1 != local_24) {
piVar2 = *(int **)(param_1 + 8);
local_24 = iVar1;
if (piVar2 == *(int **)(param_1 + 0x10)) {
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(param_1,(__normal_iterator)piVar2,&local_24);
}
else {
*piVar2 = iVar1;
*(long *)(param_1 + 8) = *(long *)(param_1 + 8) + 4;
}
}
piVar3 = piVar3 + 1;
} while ((int *)param_2[1] != piVar3);
}
}
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,918 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
template <typename T>
| std::vector<T> func0(std::vector<T> nums) {
std::vector<T> result;
if (!nums.empty()) {
typename std::vector<T>::iterator it = nums.begin();
T last = *it;
result.push_back(last);
++it;
for (; it != nums.end(); ++it) {
if (*it != last) {
last = *it;
result.push_back(last);
}
}
}
return result;
}
| int main() {
assert((func0(std::vector<int>{0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}) == std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4}));
assert((func0(std::vector<int>{10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10}) == std::vector<int>{10, 15, 19, 18, 17, 26, 17, 18, 10}));
assert((func0(std::vector<char>{'a', 'a', 'b', 'c', 'd', 'd'}) == std::vector<char>{'a', 'b', 'c', 'd'}));
return 0;
}
| O2 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
cmp 0x8(%rsi),%rbx
je 1c00 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xa0>
mov (%rbx),%eax
lea 0x4(%rsp),%r13
mov %rsi,%rbp
xor %esi,%esi
mov %r13,%rdx
mov %eax,0x4(%rsp)
callq 1a00 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
nopl 0x0(%rax)
add $0x4,%rbx
cmp %rbx,0x8(%rbp)
je 1c00 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xa0>
mov (%rbx),%eax
cmp 0x4(%rsp),%eax
je 1bc0 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x60>
mov %eax,0x4(%rsp)
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1c20 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xc0>
mov %eax,(%rsi)
add $0x4,%rsi
add $0x4,%rbx
mov %rsi,0x8(%r12)
cmp %rbx,0x8(%rbp)
jne 1bca <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x6a>
nopw 0x0(%rax,%rax,1)
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1c2d <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xcd>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xchg %ax,%ax
mov %r13,%rdx
mov %r12,%rdi
callq 1a00 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 1bc0 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x60>
callq 1160 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
mov (%r12),%rdi
test %rdi,%rdi
je 1c47 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xe7>
callq 1140 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1190 <_Unwind_Resume@plt>
| _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
cmp [rsi+8], rbx
jz short loc_1B20
mov r14d, [rbx]
lea r13, [rsp+38h+var_34]
mov r12, rsi
xor esi, esi
mov rdx, r13
mov [rsp+38h+var_34], r14d
call _ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_; std::vector<int>::_M_realloc_insert<int const&>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,int const&)
add rbx, 4
cmp rbx, [r12+8]
jnz short loc_1B45
loc_1B20:
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jnz short loc_1B9D
add rsp, 10h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_1B40:
mov r14d, [rsp+38h+var_34]
loc_1B45:
mov eax, [rbx]
cmp eax, r14d
jz short loc_1B64
mov [rsp+38h+var_34], eax
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz short loc_1B78
mov [rsi], eax
add rsi, 4
mov [rbp+8], rsi
loc_1B64:
add rbx, 4
cmp [r12+8], rbx
jnz short loc_1B40
jmp short loc_1B20
loc_1B78:
mov rdx, r13
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 short loc_1B64
loc_1B85:
mov rdi, rbp
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+38h+var_30]
sub rax, fs:28h
jz short loc_1BAB
loc_1B9D:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_1B85
loc_1BAB:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<int>(long long a1, int **a2)
{
int *v2; // rbx
int v3; // r14d
int *v5; // rbx
int v7; // eax
_DWORD *v8; // rsi
int v9; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v10; // [rsp+4h] [rbp-30h]
v10 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *a2;
if ( a2[1] != *a2 )
{
v3 = *v2;
v9 = *v2;
std::vector<int>::_M_realloc_insert<int const&>(a1, 0LL, &v9);
v5 = v2 + 1;
if ( v5 != a2[1] )
{
while ( 1 )
{
v7 = *v5;
if ( *v5 != v3 )
{
v9 = *v5;
v8 = *(_DWORD **)(a1 + 8);
if ( v8 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v8, &v9);
}
else
{
*v8 = v7;
*(_QWORD *)(a1 + 8) = v8 + 1;
}
}
if ( a2[1] == ++v5 )
break;
v3 = v9;
}
}
}
return a1;
} | func0<int>:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RBX
JZ 0x00101b20
MOV R14D,dword ptr [RBX]
LEA R13,[RSP + 0x4]
MOV R12,RSI
XOR ESI,ESI
MOV RDX,R13
MOV dword ptr [RSP + 0x4],R14D
LAB_00101b10:
CALL 0x00101930
ADD RBX,0x4
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x00101b45
LAB_00101b20:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101b9d
ADD RSP,0x10
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_00101b40:
MOV R14D,dword ptr [RSP + 0x4]
LAB_00101b45:
MOV EAX,dword ptr [RBX]
CMP EAX,R14D
JZ 0x00101b64
MOV dword ptr [RSP + 0x4],EAX
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x00101b78
MOV dword ptr [RSI],EAX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
LAB_00101b64:
ADD RBX,0x4
CMP qword ptr [R12 + 0x8],RBX
JNZ 0x00101b40
JMP 0x00101b20
LAB_00101b78:
MOV RDX,R13
MOV RDI,RBP
CALL 0x00101930
JMP 0x00101b64
LAB_00101b9d:
CALL 0x00101130 | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0<int>(vector<int,std::allocator<int>> *param_1,int8 *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
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;
piVar3 = (int *)*param_2;
if ((int *)param_2[1] != piVar3) {
iVar4 = *piVar3;
local_34 = iVar4;
/* try { // try from 00101b10 to 00101b82 has its CatchHandler @ 00101ba2 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>(param_1,0,&local_34);
piVar3 = piVar3 + 1;
if (piVar3 != (int *)param_2[1]) {
do {
iVar1 = *piVar3;
if (iVar1 != iVar4) {
piVar2 = *(int **)(param_1 + 8);
local_34 = iVar1;
if (piVar2 == *(int **)(param_1 + 0x10)) {
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(param_1,(__normal_iterator)piVar2,&local_34);
}
else {
*piVar2 = iVar1;
*(int **)(param_1 + 8) = piVar2 + 1;
}
}
piVar3 = piVar3 + 1;
iVar4 = local_34;
} while ((int *)param_2[1] != piVar3);
}
}
if (local_30 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,919 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
template <typename T>
| std::vector<T> func0(std::vector<T> nums) {
std::vector<T> result;
if (!nums.empty()) {
typename std::vector<T>::iterator it = nums.begin();
T last = *it;
result.push_back(last);
++it;
for (; it != nums.end(); ++it) {
if (*it != last) {
last = *it;
result.push_back(last);
}
}
}
return result;
}
| int main() {
assert((func0(std::vector<int>{0, 0, 1, 2, 3, 4, 4, 5, 6, 6, 6, 7, 8, 9, 4, 4}) == std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 4}));
assert((func0(std::vector<int>{10, 10, 15, 19, 18, 18, 17, 26, 26, 17, 18, 10}) == std::vector<int>{10, 15, 19, 18, 17, 26, 17, 18, 10}));
assert((func0(std::vector<char>{'a', 'a', 'b', 'c', 'd', 'd'}) == std::vector<char>{'a', 'b', 'c', 'd'}));
return 0;
}
| O3 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (%rsi),%rbx
cmp 0x8(%rsi),%rbx
je 1b30 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x90>
mov (%rbx),%eax
lea 0x4(%rsp),%r13
mov %rsi,%rbp
xor %esi,%esi
mov %r13,%rdx
mov %eax,0x4(%rsp)
callq 1940 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x8(%rbp),%rdx
add $0x4,%rbx
cmp %rbx,%rdx
je 1b30 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x90>
xchg %ax,%ax
mov (%rbx),%eax
cmp 0x4(%rsp),%eax
je 1b27 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x87>
mov %eax,0x4(%rsp)
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1b50 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xb0>
mov %eax,(%rsi)
add $0x4,%rsi
mov %rsi,0x8(%r12)
mov 0x8(%rbp),%rdx
add $0x4,%rbx
cmp %rbx,%rdx
jne 1b00 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x60>
mov 0x8(%rsp),%rax
xor %fs:0x28,%rax
jne 1b61 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xc1>
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
xchg %ax,%ax
mov %r13,%rdx
mov %r12,%rdi
callq 1940 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x8(%rbp),%rdx
jmp 1b27 <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0x87>
callq 1160 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
mov (%r12),%rdi
test %rdi,%rdi
je 1b7b <_Z5func0IiESt6vectorIT_SaIS1_EES3_+0xdb>
callq 1140 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1190 <_Unwind_Resume@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0IiESt6vectorIT_SaIS1_EES3_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
cmp [rsi+8], rbx
jz short loc_1B6A
mov r15d, [rbx]
lea r14, [rsp+48h+var_44]
mov r13, rsi
xor esi, esi
mov rdx, r14
mov [rsp+48h+var_44], r15d
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 rax, [r13+8]
add rbx, 4
cmp rbx, rax
jz short loc_1B6A
nop dword ptr [rax+00h]
loc_1B38:
mov ebp, [rbx]
cmp ebp, r15d
jz short loc_1B61
mov [rsp+48h+var_44], ebp
mov rsi, [r12+8]
cmp rsi, [r12+10h]
jz short loc_1B90
mov [rsi], ebp
add rsi, 4
mov r15d, ebp
mov [r12+8], rsi
mov rax, [r13+8]
loc_1B61:
add rbx, 4
cmp rax, rbx
jnz short loc_1B38
loc_1B6A:
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jnz short loc_1BBC
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1B90:
mov rdx, r14
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&)
mov rax, [r13+8]
mov r15d, ebp
jmp short loc_1B61
loc_1BA4:
mov rdi, r12
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+48h+var_40]
sub rax, fs:28h
jz short loc_1BCA
loc_1BBC:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp short loc_1BA4
loc_1BCA:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume | long long func0<int>(long long a1, int **a2)
{
int *v2; // rbx
int v3; // r15d
int *v5; // rax
int *i; // rbx
int v7; // ebp
_DWORD *v8; // rsi
int v10; // [rsp+0h] [rbp-44h] BYREF
unsigned long long v11; // [rsp+4h] [rbp-40h]
v11 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = *a2;
if ( a2[1] != *a2 )
{
v3 = *v2;
v10 = *v2;
std::vector<int>::_M_realloc_insert<int const&>(a1, 0LL, &v10);
v5 = a2[1];
for ( i = v2 + 1; v5 != i; ++i )
{
v7 = *i;
if ( *i != v3 )
{
v10 = *i;
v8 = *(_DWORD **)(a1 + 8);
if ( v8 == *(_DWORD **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v8, &v10);
v5 = a2[1];
v3 = v7;
}
else
{
*v8 = v7;
v3 = v7;
*(_QWORD *)(a1 + 8) = v8 + 1;
v5 = a2[1];
}
}
}
}
return a1;
} | func0<int>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
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 RBX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RBX
JZ 0x00101b6a
MOV R15D,dword ptr [RBX]
LEA R14,[RSP + 0x4]
MOV R13,RSI
XOR ESI,ESI
MOV RDX,R14
MOV dword ptr [RSP + 0x4],R15D
LAB_00101b22:
CALL 0x00101940
MOV RAX,qword ptr [R13 + 0x8]
ADD RBX,0x4
CMP RBX,RAX
JZ 0x00101b6a
NOP dword ptr [RAX]
LAB_00101b38:
MOV EBP,dword ptr [RBX]
CMP EBP,R15D
JZ 0x00101b61
MOV dword ptr [RSP + 0x4],EBP
MOV RSI,qword ptr [R12 + 0x8]
CMP RSI,qword ptr [R12 + 0x10]
JZ 0x00101b90
MOV dword ptr [RSI],EBP
ADD RSI,0x4
MOV R15D,EBP
MOV qword ptr [R12 + 0x8],RSI
MOV RAX,qword ptr [R13 + 0x8]
LAB_00101b61:
ADD RBX,0x4
CMP RAX,RBX
JNZ 0x00101b38
LAB_00101b6a:
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101bbc
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101b90:
MOV RDX,R14
MOV RDI,R12
CALL 0x00101940
MOV RAX,qword ptr [R13 + 0x8]
MOV R15D,EBP
JMP 0x00101b61
LAB_00101bbc:
CALL 0x00101130 | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> *
func0<int>(vector<int,std::allocator<int>> *param_1,int8 *param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
int iVar4;
long in_FS_OFFSET;
int local_44;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
piVar3 = (int *)*param_2;
if ((int *)param_2[1] != piVar3) {
iVar4 = *piVar3;
local_44 = iVar4;
/* try { // try from 00101b22 to 00101b9a has its CatchHandler @ 00101bc1 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>(param_1,0,&local_44);
piVar2 = (int *)param_2[1];
piVar3 = piVar3 + 1;
if (piVar3 != piVar2) {
do {
iVar1 = *piVar3;
if (iVar1 != iVar4) {
piVar2 = *(int **)(param_1 + 8);
iVar4 = iVar1;
local_44 = iVar1;
if (piVar2 == *(int **)(param_1 + 0x10)) {
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(param_1,(__normal_iterator)piVar2,&local_44);
piVar2 = (int *)param_2[1];
}
else {
*piVar2 = iVar1;
*(int **)(param_1 + 8) = piVar2 + 1;
piVar2 = (int *)param_2[1];
}
}
piVar3 = piVar3 + 1;
} while (piVar2 != piVar3);
}
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,920 | func0 |
#include <cmath>
#include <cassert>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(fabs(func0(5, 12) - 204.20352248333654) < 0.0001);
assert(fabs(func0(10, 15) - 566.3586699569488) < 0.0001);
assert(fabs(func0(19, 17) - 1521.8090132193388) < 0.0001);
return 0;
}
| O0 | cpp | func0(double, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm0
movapd %xmm0,%xmm1
mulsd %xmm0,%xmm1
movsd -0x20(%rbp),%xmm0
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
callq 1070 <sqrt@plt>
movq %xmm0,%rax
mov %rax,-0x10(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf5c(%rip),%xmm0
mulsd %xmm1,%xmm0
movsd -0x10(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| _Z5func0dd:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm0, [rbp+var_18]
movapd xmm1, xmm0
mulsd xmm1, xmm0
movsd xmm0, [rbp+var_20]
mulsd xmm0, xmm0
addsd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
mov [rbp+var_10], rax
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20F0
mulsd xmm0, xmm1
movsd xmm1, [rbp+var_10]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(double a1, double a2)
{
return 3.141592653589793 * a1 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM0,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MULSD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
MULSD XMM0,XMM0
ADDSD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x10],RAX
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020f0]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [RBP + -0x10]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(double, double) */
double func0(double param_1,double param_2)
{
double dVar1;
dVar1 = sqrt(param_1 * param_1 + param_2 * param_2);
return DAT_001020f0 * param_1 * dVar1;
} |
2,921 | func0 |
#include <cmath>
#include <cassert>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(fabs(func0(5, 12) - 204.20352248333654) < 0.0001);
assert(fabs(func0(10, 15) - 566.3586699569488) < 0.0001);
assert(fabs(func0(19, 17) - 1521.8090132193388) < 0.0001);
return 0;
}
| O1 | cpp | func0(double, double):
endbr64
sub $0x18,%rsp
movsd %xmm0,0x8(%rsp)
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm1
addsd %xmm1,%xmm0
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
movsd %xmm3,(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 1192 <_Z5func0dd+0x49>
movsd 0x8(%rsp),%xmm0
mulsd 0xe80(%rip),%xmm0
mulsd (%rsp),%xmm0
add $0x18,%rsp
retq
callq 1050 <sqrt@plt>
jmp 117a <_Z5func0dd+0x31>
| _Z5func0dd:
endbr64
movapd xmm2, xmm0
mulsd xmm2, xmm0
mulsd xmm1, xmm1
addsd xmm2, xmm1
sqrtsd xmm2, xmm2
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * 3.141592653589793 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MULSD XMM1,XMM1
ADDSD XMM2,XMM1
SQRTSD XMM2,XMM2
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * SQRT(param_1 * param_1 + param_2 * param_2);
} |
2,922 | func0 |
#include <cmath>
#include <cassert>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(fabs(func0(5, 12) - 204.20352248333654) < 0.0001);
assert(fabs(func0(10, 15) - 566.3586699569488) < 0.0001);
assert(fabs(func0(19, 17) - 1521.8090132193388) < 0.0001);
return 0;
}
| O2 | cpp | func0(double, double):
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 1197 <_Z5func0dd+0x37>
mulsd 0xe7a(%rip),%xmm2
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
mulsd 0xe4a(%rip),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
mulsd xmm2, xmm0
mulsd xmm0, cs:qword_2008
addsd xmm2, xmm1
sqrtsd xmm2, xmm2
mulsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * 3.141592653589793 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MULSD XMM0,qword ptr [0x00102008]
ADDSD XMM2,XMM1
SQRTSD XMM2,XMM2
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * SQRT(param_1 * param_1 + param_2 * param_2);
} |
2,923 | func0 |
#include <cmath>
#include <cassert>
| double func0(double r, double h) {
double l = sqrt(r * r + h * h);
double LSA = M_PI * r * l;
return LSA;
}
| int main() {
assert(fabs(func0(5, 12) - 204.20352248333654) < 0.0001);
assert(fabs(func0(10, 15) - 566.3586699569488) < 0.0001);
assert(fabs(func0(19, 17) - 1521.8090132193388) < 0.0001);
return 0;
}
| O3 | cpp | func0(double, double):
endbr64
mulsd %xmm1,%xmm1
movapd %xmm0,%xmm2
mulsd %xmm0,%xmm0
addsd %xmm1,%xmm0
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm0,%xmm3
sqrtsd %xmm3,%xmm3
ja 1197 <_Z5func0dd+0x37>
mulsd 0xe7a(%rip),%xmm2
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
sub $0x18,%rsp
movsd %xmm2,0x8(%rsp)
movsd %xmm3,(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm2
movsd (%rsp),%xmm3
mulsd 0xe4a(%rip),%xmm2
add $0x18,%rsp
movapd %xmm2,%xmm0
mulsd %xmm3,%xmm0
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0dd:
endbr64
mulsd xmm1, xmm1
movapd xmm2, xmm0
mulsd xmm2, xmm0
mulsd xmm0, cs:qword_2008
addsd xmm2, xmm1
sqrtsd xmm2, xmm2
mulsd xmm0, xmm2
retn | double func0(double a1, double a2)
{
return a1 * 3.141592653589793 * sqrt(a1 * a1 + a2 * a2);
} | func0:
ENDBR64
MULSD XMM1,XMM1
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
MULSD XMM0,qword ptr [0x00102008]
ADDSD XMM2,XMM1
SQRTSD XMM2,XMM2
MULSD XMM0,XMM2
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * SQRT(param_1 * param_1 + param_2 * param_2);
} |
2,924 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &text) {
std::regex pattern("[ ,.]");
return std::regex_replace(text, pattern, ":");
}
| int main() {
assert(func0("Python language, Programming language.") == "Python:language::Programming:language:");
assert(func0("a b c,d e f") == "a:b:c:d:e:f");
assert(func0("ram reshma,ram rahim") == "ram:reshma:ram:rahim");
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 $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2d3cc(%rip),%rsi
mov %rax,%rdi
callq 712c <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1EPKcNSt15regex_constants18syntax_option_typeE>
mov -0x48(%rbp),%rax
lea -0x40(%rbp),%rdx
mov -0x50(%rbp),%rsi
mov $0x0,%r8d
lea 0x2d3b1(%rip),%rcx
mov %rax,%rdi
callq 71e9 <_ZSt13regex_replaceINSt7__cxx1112regex_traitsIcEEcSt11char_traitsIcESaIcEENS0_12basic_stringIT0_T1_T2_EERKSA_RKNS0_11basic_regexIS7_T_EEPKS7_NSt15regex_constants15match_flag_typeE>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71b6 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5d28 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9f>
jmp 5d23 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x9a>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71b6 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5b00 <_Unwind_Resume@plt>
callq 5960 <__stack_chk_fail@plt>
mov -0x48(%rbp),%rax
add $0x48,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, asc_34051; "[ ,.]"
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_48]
lea rdx, [rbp+var_40]
mov rsi, [rbp+var_50]
mov r8d, 0
lea rcx, asc_34057; ":"
mov rdi, rax
call _ZSt13regex_replaceINSt7__cxx1112regex_traitsIcEEcSt11char_traitsIcESaIcEENS0_12basic_stringIT0_T1_T2_EERKSA_RKNS0_11basic_regexIS7_T_EEPKS7_NSt15regex_constants15match_flag_typeE; std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>(std::string const&,std::basic_regex<char,std::regex_traits<char>> const&,char const*,std::regex_constants::match_flag_type)
nop
lea rax, [rbp+var_40]
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 short loc_4BDF
jmp short loc_4BDA
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4BD2
call ___stack_chk_fail
loc_4BD2:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4BDA:
call ___stack_chk_fail
loc_4BDF:
mov rax, [rbp+var_48]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v3, "[ ,.]", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>(a1, a2, v3, ":", 0LL);
std::basic_regex<char,std::regex_traits<char>>::~basic_regex(v3);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b63:
CALL 0x00106152
MOV RAX,qword ptr [RBP + -0x48]
LEA RDX,[RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x50]
MOV R8D,0x0
LEA RCX,[0x134057]
MOV RDI,RAX
LAB_00104b84:
CALL 0x00106223
NOP
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x001061f0
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104bdf
JMP 0x00104bda
LAB_00104bda:
CALL 0x00104860
LAB_00104bdf:
MOV RAX,qword ptr [RBP + -0x48]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 in_RSI;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"[ ,.]",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchHandler @ 00104ba8 */
std::regex_replace<std::regex_traits<char>,char,std::char_traits<char>,std::allocator<char>>
(param_1,in_RSI,local_48,&DAT_00134057,0);
std::regex::~basic_regex(local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,925 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &text) {
std::regex pattern("[ ,.]");
return std::regex_replace(text, pattern, ":");
}
| int main() {
assert(func0("Python language, Programming language.") == "Python:language::Programming:language:");
assert(func0("a b c,d e f") == "a:b:c:d:e:f");
assert(func0("ram reshma,ram rahim") == "ram:reshma:ram:rahim");
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 $0x48,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%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 0x20(%rsp),%rdi
mov 0x10(%rsp),%r8d
mov %r12,%rcx
lea 0x15e2e(%rip),%rdx
lea -0x5(%rdx),%rsi
callq 19187 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
jmp 48b4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x8b>
endbr64
mov %rax,%rbx
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov %rbx,%rdi
callq 46c0 <_Unwind_Resume@plt>
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x10(%rbx),%r12
mov %r12,(%rbx)
movq $0x0,0x8(%rbx)
movb $0x0,0x10(%rbx)
mov 0x0(%rbp),%rsi
mov %rsi,%rdx
add 0x8(%rbp),%rdx
lea 0x10(%rsp),%rcx
mov $0x0,%r9d
lea 0x15dc7(%rip),%r8
mov %rbx,%rdi
callq ee37 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
cmpq $0x0,0x1c6c0(%rip)
je 4967 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x13e>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4972 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x149>
lea 0x18(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 49af <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x186>
mov %rbx,%rax
add $0x48,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
cmp %rdi,%r12
je 4955 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x12c>
callq 4570 <_ZdlPv@plt>
lea 0x10(%rsp),%rdi
callq 5776 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbp,%rdi
callq 46c0 <_Unwind_Resume@plt>
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmp 4914 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xeb>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1c644(%rip)
je 49a4 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x17b>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmpq 4919 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xf0>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4990 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x167>
callq 45d0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_50]
lea rdi, [rbp+var_48]; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov ecx, 10h
lea rdx, asc_196EF+5; ""
lea rsi, [rdx-5]
mov rdi, r12
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
jmp short loc_48A0
endbr64
mov rbx, rax
mov rdi, [rbp+var_38]
test rdi, rdi
jz short loc_487B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_487B:
lea rdi, [rbp+var_48]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4898
call ___stack_chk_fail
loc_4898:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_48A0:
lea rax, [rbx+10h]
mov [rbx], rax
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, [r14]
mov rdx, rsi
add rdx, [r14+8]
lea rcx, [rbp+var_50]
sub rsp, 8
push 0
mov r9d, 1
lea r8, asc_196F5; ":"
mov rdi, rbx
call _ZSt15__regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_mNSt15regex_constants15match_flag_typeE; std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(std::back_insert_iterator<std::string>,__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&,char const*,ulong,std::regex_constants::match_flag_type)
add rsp, 10h
mov rax, [rbp+var_38]
mov rdi, rax
test rax, rax
jz short loc_4922
lea rcx, [rax+8]
mov rdx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_497C
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_499F
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4919:
cmp eax, 1
jz loc_49AD
loc_4922:
lea rdi, [rbp+var_48]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_49B7
mov rax, rbx
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r14
pop rbp
retn
endbr64
mov r14, rax
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
lea rdi, [rbp+var_50]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4974
call ___stack_chk_fail
loc_4974:
mov rdi, r14; struct _Unwind_Exception *
call __Unwind_Resume
loc_497C:
mov r12, rdi
mov dword ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 0
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, r12
mov rax, [r12]
call qword ptr [rax+18h]
jmp short loc_4922
loc_499F:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4919
loc_49AD:
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_4922
loc_49B7:
call ___stack_chk_fail | long long func0(long long a1, long long *a2)
{
long long v4; // rsi
_DWORD *v5; // rdi
volatile signed __int32 *v6; // rcx
long long v7; // rdx
signed __int32 v8; // eax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
long long v12; // [rsp+10h] [rbp-40h]
long long v13; // [rsp+18h] [rbp-38h]
unsigned long long v14; // [rsp+28h] [rbp-28h]
v14 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v11);
v12 = 0LL;
v13 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v10, "[ ,.]", "", 16LL);
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = *a2;
std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(
a1,
*a2,
*((_DWORD *)a2 + 2) + *(_DWORD *)a2,
(unsigned int)v10,
(unsigned int)":",
1,
0);
v5 = (_DWORD *)v13;
if ( v13 )
{
v6 = (volatile signed __int32 *)(v13 + 8);
v7 = *(_QWORD *)(v13 + 8);
if ( v7 == 0x100000001LL )
{
*(_DWORD *)(v13 + 8) = 0;
v5[3] = 0;
(*(void ( **)(_DWORD *, long long, long long, volatile signed __int32 *))(*(_QWORD *)v5 + 16LL))(
v5,
v4,
0x100000001LL,
v6);
(*(void ( **)(_DWORD *))(*(_QWORD *)v5 + 24LL))(v5);
}
else
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v13 + 8);
v7 = (unsigned int)(v8 - 1);
*(_DWORD *)(v13 + 8) = v7;
}
else
{
v8 = _InterlockedExchangeAdd(v6, 0xFFFFFFFF);
}
if ( v8 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v5, v4, v7, v6);
}
}
std::locale::~locale((std::locale *)v11);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x50]
LEA RDI,[RBP + -0x48]
CALL 0x00104710
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV ECX,0x10
LEA RDX,[0x1196f4]
LEA RSI,[RDX + -0x5]
MOV RDI,R12
LAB_0010485f:
CALL 0x00117714
JMP 0x001048a0
LAB_001048a0:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
MOV RSI,qword ptr [R14]
MOV RDX,RSI
ADD RDX,qword ptr [R14 + 0x8]
LEA RCX,[RBP + -0x50]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x1
LEA R8,[0x1196f5]
MOV RDI,RBX
LAB_001048d7:
CALL 0x0010edca
ADD RSP,0x10
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00104922
LEA RCX,[RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x0010497c
CMP byte ptr [0x0011f460],0x0
JZ 0x0010499f
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104919:
CMP EAX,0x1
JZ 0x001049ad
LAB_00104922:
LEA RDI,[RBP + -0x48]
CALL 0x00104650
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001049b7
MOV RAX,RBX
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R14
POP RBP
RET
LAB_0010497c:
MOV R12,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RDI,R12
MOV RAX,qword ptr [R12]
CALL qword ptr [RAX + 0x18]
JMP 0x00104922
LAB_0010499f:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104919
LAB_001049ad:
CALL 0x0010588a
JMP 0x00104922
LAB_001049b7:
CALL 0x001045a0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int8 local_48;
_Sp_counted_base<(_Lock_policy)2> *local_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_50);
local_48 = 0;
local_40 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 0010485f to 00104863 has its CatchHandler @ 00104866 */
std::regex::_M_compile(local_58,"[ ,.]","",0x10);
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
/* try { // try from 001048d7 to 001048db has its CatchHandler @ 00104948 */
std::
__regex_replace<std::back_insert_iterator<std::string>,__normal_iterator<char_const*,std::string>,std::regex_traits<char>,char>
((back_insert_iterator)param_1,(__normal_iterator)*in_RSI,
(__normal_iterator)*in_RSI + (int)in_RSI[1],local_58,":",1,0);
p_Var2 = local_40;
if (local_40 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_40 + 8;
if (*(long *)(local_40 + 8) == 0x100000001) {
*(int4 *)(local_40 + 8) = 0;
*(int4 *)(local_40 + 0xc) = 0;
(**(code **)(*(long *)local_40 + 0x10))();
(**(code **)(*(long *)p_Var2 + 0x18))(p_Var2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar3 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)(local_40 + 8);
*(int *)(local_40 + 8) = iVar3 + -1;
}
if (iVar3 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_40);
}
}
}
std::locale::~locale(local_50);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,926 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &text) {
std::regex pattern("[ ,.]");
return std::regex_replace(text, pattern, ":");
}
| int main() {
assert(func0("Python language, Programming language.") == "Python:language::Programming:language:");
assert(func0("a b c,d e f") == "a:b:c:d:e:f");
assert(func0("ram reshma,ram rahim") == "ram:reshma:ram:rahim");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13
mov %rbp,%rdi
callq 4770 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x10(%rsp)
callq 4500 <_ZNSt6localeC1ERKS_@plt>
lea 0x16ae2(%rip),%rdx
mov 0x10(%rsp),%r8d
mov %r13,%rcx
lea 0x20(%rsp),%rdi
lea -0x5(%rdx),%rsi
callq 1a620 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %rbp,%rdi
lea 0x10(%r12),%r14
lea 0x10(%rsp),%rbp
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov %r14,(%r12)
xor %r9d,%r9d
mov %rbp,%rcx
movb $0x0,0x10(%r12)
mov (%rbx),%rsi
lea 0x16aa1(%rip),%r8
mov %r12,%rdi
movq $0x0,0x8(%r12)
mov 0x8(%rbx),%rdx
add %rsi,%rdx
callq e770 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x1d37b(%rip),%rbx
test %rbx,%rbx
je 4c80 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 4c8e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10e>
nopl 0x0(%rax)
mov %r13,%rdi
callq 46a0 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 4ccb <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14b>
add $0x40,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 4cc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x140>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 4c58 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
nopl 0x0(%rax,%rax,1)
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 4ca7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
callq 4610 <__stack_chk_fail@plt>
endbr64
mov %rax,%r13
jmpq 47e3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 4801 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1e>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_50]
push r12
lea r12, [rbp+var_48]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 30h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, asc_1A6EF+5; ""
pxor xmm0, xmm0
mov rdi, r13
mov ecx, 10h
lea rsi, [rdx-5]
movaps [rbp+var_40], xmm0
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
lea rax, [rbx+10h]
sub rsp, 8
mov byte ptr [rbx+10h], 0
mov rcx, r13
mov [rbx], rax
mov rsi, [r14]
mov r9d, 1
mov rdi, rbx; int
mov qword ptr [rbx+8], 0
mov rdx, [r14+8]
lea r8, asc_1A6F5; ":"
push 0
add rdx, rsi
call _ZSt15__regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_mNSt15regex_constants15match_flag_typeE; std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(std::back_insert_iterator<std::string>,__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&,char const*,ulong,std::regex_constants::match_flag_type)
pop rax
mov rax, qword ptr [rbp+var_40+8]
pop rdx
mov rdi, rax
test rax, rax
jz short loc_612F
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_6160
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz short loc_6180
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_612A:
cmp eax, 1
jz short loc_6190
loc_612F:
mov rdi, r12; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_6197
lea rsp, [rbp-20h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_6160:
mov rax, [rdi]
mov r13, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+18h]
jmp short loc_612F
loc_6180:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp short loc_612A
loc_6190:
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 short loc_612F
loc_6197:
call ___stack_chk_fail
endbr64
mov r14, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
jmp loc_486C | long long func0(long long a1, long long *a2)
{
long long v3; // rsi
long long v4; // rdi
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v9; // rax
_BYTE v10[8]; // [rsp+0h] [rbp-50h] BYREF
_BYTE v11[8]; // [rsp+8h] [rbp-48h] BYREF
__int128 v12; // [rsp+10h] [rbp-40h]
unsigned long long v13; // [rsp+28h] [rbp-28h]
v13 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v11);
v12 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v10, "[ ,.]", "", 16LL);
*(_BYTE *)(a1 + 16) = 0;
*(_QWORD *)a1 = a1 + 16;
v3 = *a2;
*(_QWORD *)(a1 + 8) = 0LL;
std::__regex_replace<std::back_insert_iterator<std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::regex_traits<char>,char>(a1);
v4 = *((_QWORD *)&v12 + 1);
if ( *((_QWORD *)&v12 + 1) )
{
v5 = *(_QWORD *)(*((_QWORD *)&v12 + 1) + 8LL);
v6 = (volatile signed __int32 *)(*((_QWORD *)&v12 + 1) + 8LL);
if ( v5 == 0x100000001LL )
{
v9 = **((_QWORD **)&v12 + 1);
*(_QWORD *)(*((_QWORD *)&v12 + 1) + 8LL) = 0LL;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(v9 + 16))(
v4,
v3,
0x100000001LL,
v6);
(*(void ( **)(long long))(*(_QWORD *)v4 + 24LL))(v4);
}
else
{
if ( _libc_single_threaded )
{
v7 = *(_DWORD *)(*((_QWORD *)&v12 + 1) + 8LL);
v5 = (unsigned int)(v7 - 1);
*(_DWORD *)(*((_QWORD *)&v12 + 1) + 8LL) = v5;
}
else
{
v7 = _InterlockedExchangeAdd(v6, 0xFFFFFFFF);
}
if ( v7 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v4, v3, v5, v6);
}
}
std::locale::~locale((std::locale *)v11);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x50]
PUSH R12
LEA R12,[RBP + -0x48]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001046f0
LEA RDX,[0x11a6f4]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,[RDX + -0x5]
MOVAPS xmmword ptr [RBP + -0x40],XMM0
LAB_001060b3:
CALL 0x001194d0
LEA RAX,[RBX + 0x10]
SUB RSP,0x8
MOV byte ptr [RBX + 0x10],0x0
MOV RCX,R13
MOV qword ptr [RBX],RAX
MOV RSI,qword ptr [R14]
MOV R9D,0x1
MOV RDI,RBX
MOV qword ptr [RBX + 0x8],0x0
MOV RDX,qword ptr [R14 + 0x8]
LEA R8,[0x11a6f5]
PUSH 0x0
ADD RDX,RSI
LAB_001060ee:
CALL 0x00112140
POP RAX
MOV RAX,qword ptr [RBP + -0x38]
POP RDX
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010612f
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00106160
CMP byte ptr [0x00120460],0x0
JZ 0x00106180
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_0010612a:
CMP EAX,0x1
JZ 0x00106190
LAB_0010612f:
MOV RDI,R12
CALL 0x00104640
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106197
LEA RSP,[RBP + -0x20]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00106160:
MOV RAX,qword ptr [RDI]
MOV R13,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x0010612f
LAB_00106180:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x0010612a
LAB_00106190:
CALL 0x001073c0
JMP 0x0010612f
LAB_00106197:
CALL 0x001045a0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int iVar3;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_58 [8];
int local_50 [8];
int local_48 [24];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_50);
local_48._0_16_ = (int [16])0x0;
/* try { // try from 001060b3 to 001060b7 has its CatchHandler @ 001061a8 */
std::regex::_M_compile(local_58,"[ ,.]","",0x10);
param_1[0x10] = (string)0x0;
*(string **)param_1 = param_1 + 0x10;
uVar2 = *in_RSI;
*(int8 *)(param_1 + 8) = 0;
/* try { // try from 001060ee to 001060f2 has its CatchHandler @ 0010619c */
std::
__regex_replace<std::back_insert_iterator<std::string>,__normal_iterator<char_const*,std::string>,std::regex_traits<char>,char>
((back_insert_iterator)param_1,(__normal_iterator)uVar2,
(int)in_RSI[1] + (__normal_iterator)uVar2,local_58,":",1,0);
uVar2 = local_48._8_8_;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_48._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_48._8_8_ + 8);
if (*(long *)(local_48._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_48._8_8_ + 8) = 0;
(**(code **)(*(long *)local_48._8_8_ + 0x10))();
(**(code **)(*(long *)uVar2 + 0x18))(uVar2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar3 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)(local_48._8_8_ + 8);
*(int *)(local_48._8_8_ + 8) = iVar3 + -1;
}
if (iVar3 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_48._8_8_);
}
}
}
std::locale::~locale(local_50);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,927 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(const std::string &text) {
std::regex pattern("[ ,.]");
return std::regex_replace(text, pattern, ":");
}
| int main() {
assert(func0("Python language, Programming language.") == "Python:language::Programming:language:");
assert(func0("a b c,d e f") == "a:b:c:d:e:f");
assert(func0("ram reshma,ram rahim") == "ram:reshma:ram:rahim");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
lea 0x8(%rsp),%rbp
lea 0x18(%rsp),%r13
mov %rbp,%rdi
callq 47b0 <_ZNSt6localeC1Ev@plt>
mov %rbp,%rsi
mov %r13,%rdi
movl $0x10,0x10(%rsp)
callq 4530 <_ZNSt6localeC1ERKS_@plt>
lea 0x171ca(%rip),%rdx
mov 0x10(%rsp),%r8d
mov %r13,%rcx
lea 0x20(%rsp),%rdi
lea -0x5(%rdx),%rsi
callq 1ac90 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %rbp,%rdi
lea 0x10(%r12),%r14
lea 0x10(%rsp),%rbp
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov %r14,(%r12)
xor %r9d,%r9d
mov %rbp,%rcx
movb $0x0,0x10(%r12)
mov (%rbx),%rsi
lea 0x17189(%rip),%r8
mov %r12,%rdi
movq $0x0,0x8(%r12)
mov 0x8(%rbx),%rdx
add %rsi,%rdx
callq 10d00 <_ZSt13regex_replaceISt20back_insert_iteratorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEN9__gnu_cxx17__normal_iteratorIPKcS6_EENS1_12regex_traitsIcEEcET_SF_T0_SG_RKNS1_11basic_regexIT2_T1_EEPKSI_NSt15regex_constants15match_flag_typeE>
mov 0x28(%rsp),%rbp
test %rbp,%rbp
je 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x1da3b(%rip),%rbx
test %rbx,%rbx
je 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 55de <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x10e>
nopl 0x0(%rax)
mov %r13,%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 561b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x14b>
add $0x40,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
cmp $0x1,%eax
jne 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5610 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x140>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 55a8 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd8>
nopl 0x0(%rax,%rax,1)
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 55f7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x127>
callq 4640 <__stack_chk_fail@plt>
endbr64
mov %rax,%r13
jmpq 4836 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 4854 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1e>
nopl 0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
lea r15, [rbp+var_E0]
push r13
push r12
mov r12, rsi
push rbx
mov rbx, rdi
sub rsp, 108h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_D8]
mov [rbp+var_128], r15
mov rdi, rax; this
mov [rbp+var_130], rax
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, asc_1B734+5; ""
pxor xmm0, xmm0
mov rdi, r15
mov ecx, 10h
lea rsi, [rdx-5]
movaps [rbp+var_D0], xmm0
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
lea rax, [rbx+10h]
mov byte ptr [rbx+10h], 0
sub rsp, 8
xor r9d, r9d
mov [rbx], rax
mov rcx, [rbp+var_128]
xor r8d, r8d
mov [rbp+var_108], rax
mov rax, [r12]
mov qword ptr [rbx+8], 0
mov r13, [r12+8]
movq xmm0, rax
mov r15, rax
mov [rbp+var_B0], rcx
mov [rbp+var_A8], 0
lea r12, [rax+r13]
lea rax, [rbp+var_A0]
movq xmm1, r12
mov [rbp+var_120], rax
mov rdx, rax
punpcklqdq xmm0, xmm1
movaps [rbp+var_C0], xmm0
movq rdi, xmm0
pxor xmm0, xmm0
mov rsi, qword ptr [rbp+var_C0+8]
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], 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_65C7
loc_6207:
lea rax, [rbp+var_C0]
pxor xmm0, xmm0
lea rsi, [rbp+var_80]
mov qword ptr [rbp+var_70], 0
mov rdi, rax
mov dword ptr [rbp+var_70+8], 0
mov [rbp+var_110], rsi
mov [rbp+var_118], rax
movaps [rbp+var_80], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_50], xmm0
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
jz loc_62FC
test r13, r13
jle short loc_626D
nop dword ptr [rax+00h]
loc_6258:
movsx esi, byte ptr [r15]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r15, 1
cmp r12, r15
jnz short loc_6258
loc_626D:
lea rdi, [rbp+var_60]
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, [rbp+var_120]
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EED2Ev; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector()
mov rax, qword ptr [rbp+var_D0+8]
mov rdi, rax
test rax, rax
jz short loc_62CB
mov rcx, [rax+8]
lea rdx, [rax+8]
mov rax, 100000001h
cmp rcx, rax
jz loc_6635
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_6654
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_62C2:
cmp eax, 1
jz loc_6662
loc_62CB:
mov rdi, [rbp+var_130]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz loc_6680
lea rsp, [rbp-28h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_62FC:
xor r13d, r13d
xor r14d, r14d
lea r15, [rbp+var_F0]
test al, al
jnz loc_64FE
nop dword ptr [rax+00000000h]
loc_6318:
mov rdx, qword ptr [rbp+var_A0]
mov rax, qword ptr [rbp+var_A0+8]
sub rax, rdx
lea rcx, [rdx+rax-30h]
cmp rax, 49h ; 'I'
lea rdx, [rdx+rax-48h]
mov rax, rcx
cmovb rax, rdx
mov r12, [rax]
mov rax, [rax+8]
mov [rbp+var_100], rax
sub rax, r12
test rax, rax
jg short loc_6384
jmp short loc_63CF
loc_6360:
mov rsi, [rbp+var_F8]
add r12, 1
mov [rax+rsi], r14b
mov rax, [rbx]
mov [rbx+8], r13
mov byte ptr [rax+rsi+1], 0
cmp [rbp+var_100], r12
jz short loc_63CF
loc_6384:
mov rax, [rbx+8]
movzx r14d, byte ptr [r12]
mov [rbp+var_F8], rax
lea r13, [rax+1]
mov rax, [rbx]
cmp [rbp+var_108], rax
jz loc_6530
mov rdx, [rbx+10h]
loc_63AC:
cmp rdx, r13
jnb short loc_6360
mov rsi, [rbp+var_F8]
xor ecx, ecx
xor edx, edx
mov rdi, rbx
mov r8d, 1
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_mutateEmmPKcm; std::string::_M_mutate(ulong,ulong,char const*,ulong)
mov rax, [rbx]
jmp short loc_6360
loc_63CF:
mov rdi, r15; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rax, [rbp+var_E8]
mov rsi, r15; std::locale *
mov rdi, rax; this
mov r14, rax
call __ZNSt6localeC1ERKS_; std::locale::locale(std::locale const&)
lea rdi, _ZNSt5ctypeIcE2idE@GLIBCXX_3_4; this
call __ZNKSt6locale2id5_M_idEv; std::locale::id::_M_id(void)
mov rdx, rax
mov rax, [rbp+var_E8]
mov rax, [rax+8]
cmp qword ptr [rax+rdx*8], 0
jz loc_666C
mov rdi, r14; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov esi, 3Ah ; ':'
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
mov rdi, r15; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdx, qword ptr [rbp+var_A0+8]
mov rax, qword ptr [rbp+var_A0]
mov rcx, rdx
sub rcx, rax
cmp rcx, 48h ; 'H'
jbe loc_6540
lea rsi, [rax+rcx-18h]
cmp rdx, rax
mov r14, [rsi]
mov r13, [rsi+8]
lea rsi, [rdx+rcx-48h]
cmovnz rsi, rax
loc_6464:
cmp byte ptr [rsi+10h], 0
jz short loc_64E3
cmp rdx, rax
jz loc_65BD
loc_6473:
mov r12, [rax+8]
mov rdi, r12
cmp r12, [rax]
jz loc_6572
loc_6483:
mov r8d, [rbp+var_A8]
sub rsp, 8
mov rcx, [rbp+var_B0]
xor r9d, r9d
mov rdx, [rbp+var_120]
mov rsi, qword ptr [rbp+var_C0+8]
or r8b, 80h
mov [rbp+var_A8], 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_6562
loc_64C2:
mov rax, qword ptr [rbp+var_A0+8]
cmp [rax-28h], r12
mov [rax-30h], r12
setnz byte ptr [rax-20h]
mov rax, qword ptr [rbp+var_C0]
mov qword ptr [rbp+var_90+8], rax
loc_64E3:
mov rsi, [rbp+var_110]
mov rdi, [rbp+var_118]
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
jz loc_6318
loc_64FE:
mov rax, r13
sub rax, r14
test rax, rax
jle loc_626D
nop dword ptr [rax]
loc_6510:
movsx esi, byte ptr [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9push_backEc; std::string::push_back(char)
add r14, 1
cmp r14, r13
jnz short loc_6510
jmp loc_626D
loc_6530:
mov edx, 0Fh
jmp loc_63AC
loc_6540:
lea rsi, [rax+rcx-48h]
mov r14, [rsi]
mov r13, [rsi+8]
cmp rdx, rax
jz loc_6464
cmp rcx, 48h ; 'H'
cmovnz rsi, rax
jmp loc_6464
loc_6562:
mov [rbp+var_B0], 0
jmp loc_64E3
loc_6572:
cmp r12, qword ptr [rbp+var_C0+8]
jz short loc_6562
sub rsp, 8
mov r8d, [rbp+var_A8]
mov rcx, [rbp+var_B0]
xor r9d, r9d
mov rdx, [rbp+var_120]
mov rsi, qword ptr [rbp+var_C0+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_6483
jmp loc_64C2
loc_65BD:
lea rax, [rax+rcx-48h]
jmp loc_6473
loc_65C7:
pxor xmm0, xmm0
lea r14, [rbp+var_60]
mov rdi, [rbp+var_120]
mov qword ptr [rbp+var_C0], 0
movaps [rbp+var_70], xmm0
mov rsi, r14
pxor xmm0, xmm0
mov qword ptr [rbp+var_C0+8], 0
mov [rbp+var_B0], 0
mov [rbp+var_A8], 0
movaps [rbp+var_80], xmm0
movaps [rbp+var_60], xmm0
movaps [rbp+var_50], 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_50+8]
mov rdi, r14
mov qword ptr [rbp+var_90+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_6207
loc_6635:
mov rax, [rdi]
mov r14, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r14]
mov rdi, r14
call qword ptr [rax+18h]
jmp loc_62CB
loc_6654:
mov eax, 0FFFFFFFFh
lock xadd [rdx], eax
jmp loc_62C2
loc_6662:
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_62CB
loc_666C:
mov rax, [rbp+var_38]
sub rax, fs:28h
jnz short loc_6685
call __ZSt16__throw_bad_castv; std::__throw_bad_cast(void)
loc_6680:
call ___stack_chk_fail
loc_6685:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov r15, rax
jmp loc_48B6
endbr64
mov r14, rax
jmp loc_48AB
endbr64
mov r12, rax
jmp loc_48A0
endbr64
mov r15, rax
jmp loc_48BF
endbr64
mov r15, rax
jmp loc_4900 | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v3; // rax
long long v4; // r13
char *v5; // r15
char *v6; // r12
char v7; // al
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
unsigned long long v12; // rsi
long long v13; // rdi
volatile signed __int32 *v14; // rdx
signed __int32 v15; // eax
long long v17; // rax
char *v18; // r12
long long v19; // rax
char v20; // r14
unsigned long long v21; // r13
long long v22; // rax
unsigned long long v23; // rdx
long long v24; // rax
long long v25; // r8
long long v26; // r9
__int128 v27; // rax
long long v28; // rcx
char *v29; // r14
char *v30; // r13
long long v31; // rsi
long long v32; // r12
int v33; // edi
int v34; // r8d
long long v35; // rax
bool v36; // zf
long long v37; // rax
long long v38; // [rsp-10h] [rbp-140h]
long long v39; // [rsp-10h] [rbp-140h]
long long v40; // [rsp-8h] [rbp-138h]
std::locale *v41; // [rsp+0h] [rbp-130h]
_QWORD *v42; // [rsp+28h] [rbp-108h]
char *v43; // [rsp+30h] [rbp-100h]
long long v44; // [rsp+38h] [rbp-F8h]
char v45[8]; // [rsp+40h] [rbp-F0h] BYREF
long long v46; // [rsp+48h] [rbp-E8h] BYREF
char v47[8]; // [rsp+50h] [rbp-E0h] BYREF
char v48[8]; // [rsp+58h] [rbp-D8h] BYREF
__int128 v49; // [rsp+60h] [rbp-D0h]
__m128i v50; // [rsp+70h] [rbp-C0h] BYREF
char *v51; // [rsp+80h] [rbp-B0h]
int v52; // [rsp+88h] [rbp-A8h]
__int128 v53; // [rsp+90h] [rbp-A0h] BYREF
__int128 v54; // [rsp+A0h] [rbp-90h]
__int128 v55; // [rsp+B0h] [rbp-80h] BYREF
__int128 v56; // [rsp+C0h] [rbp-70h]
__int128 v57; // [rsp+D0h] [rbp-60h] BYREF
__int128 v58; // [rsp+E0h] [rbp-50h]
unsigned long long v59; // [rsp+F8h] [rbp-38h]
v59 = __readfsqword(0x28u);
v41 = (std::locale *)v48;
std::locale::locale((std::locale *)v48);
v49 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v47, "[ ,.]", "", 16LL);
*((_BYTE *)a1 + 16) = 0;
*a1 = a1 + 2;
v42 = a1 + 2;
v3 = *a2;
a1[1] = 0LL;
v4 = (long long)a2[1];
v5 = v3;
v51 = v47;
v52 = 0;
v6 = &v3[v4];
v50 = _mm_unpacklo_epi64((__m128i)(unsigned long long)v3, (__m128i)(unsigned long long)&v3[v4]);
v53 = 0LL;
v54 = 0LL;
v7 = 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>>(
v50.m128i_i32[0],
v50.m128i_i32[2],
(unsigned int)&v53,
(unsigned int)v47,
0,
0,
0);
v10 = v38;
v11 = v40;
if ( !v7 )
{
v50 = 0uLL;
v56 = 0LL;
v51 = 0LL;
v52 = 0;
v55 = 0LL;
v57 = 0LL;
v58 = 0LL;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(
&v53,
&v57,
v8,
v9,
v38,
v40,
v48);
*((_QWORD *)&v54 + 1) = *((_QWORD *)&v58 + 1);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v57);
}
v12 = (unsigned long long)&v55;
*(_QWORD *)&v56 = 0LL;
DWORD2(v56) = 0;
v55 = 0LL;
v57 = 0LL;
v58 = 0LL;
if ( (unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(
&v50,
&v55,
v8,
v9,
v10,
v11) )
{
if ( v4 > 0 )
{
do
{
v12 = (unsigned int)*v5;
std::string::push_back(a1, v12);
++v5;
}
while ( v6 != v5 );
}
goto LABEL_6;
}
do
{
v17 = *((_QWORD *)&v53 + 1) - 48LL;
if ( *((_QWORD *)&v53 + 1) - (_QWORD)v53 < 0x49uLL )
v17 = *((_QWORD *)&v53 + 1) - 72LL;
v18 = *(char **)v17;
v43 = *(char **)(v17 + 8);
if ( (long long)&v43[-*(_QWORD *)v17] > 0 )
{
do
{
v20 = *v18;
v44 = a1[1];
v21 = v44 + 1;
v22 = *a1;
if ( v42 == (_QWORD *)*a1 )
v23 = 15LL;
else
v23 = a1[2];
if ( v23 < v21 )
{
std::string::_M_mutate(a1, v44, 0LL, 0LL, 1LL);
v22 = *a1;
}
++v18;
*(_BYTE *)(v22 + v44) = v20;
v19 = *a1;
a1[1] = v21;
*(_BYTE *)(v19 + v44 + 1) = 0;
}
while ( v43 != v18 );
}
std::locale::locale((std::locale *)v45);
std::locale::locale((std::locale *)&v46, (const std::locale *)v45);
v24 = std::locale::id::_M_id((std::locale::id *)&std::ctype<char>::id);
if ( !*(_QWORD *)(*(_QWORD *)(v46 + 8) + 8 * v24) )
std::__throw_bad_cast();
std::locale::~locale((std::locale *)&v46);
std::string::push_back(a1, 58LL);
std::locale::~locale((std::locale *)v45);
v27 = v53;
v28 = *((_QWORD *)&v53 + 1) - v53;
if ( *((_QWORD *)&v53 + 1) - (_QWORD)v53 <= 0x48uLL )
{
v31 = *((_QWORD *)&v53 + 1) - 72LL;
v29 = *(char **)(*((_QWORD *)&v53 + 1) - 72LL);
v30 = *(char **)(*((_QWORD *)&v53 + 1) - 72LL + 8);
if ( *((_QWORD *)&v53 + 1) != (_QWORD)v53 && v28 != 72 )
v31 = v53;
}
else
{
v29 = *(char **)(*((_QWORD *)&v53 + 1) - 24LL);
v30 = *(char **)(*((_QWORD *)&v53 + 1) - 24LL + 8);
v31 = *((_QWORD *)&v53 + 1) + v28 - 72;
if ( *((_QWORD *)&v53 + 1) != (_QWORD)v53 )
v31 = v53;
}
if ( *(_BYTE *)(v31 + 16) )
{
if ( *((_QWORD *)&v53 + 1) == (_QWORD)v53 )
*(_QWORD *)&v27 = *((_QWORD *)&v53 + 1) - 72LL;
v32 = *(_QWORD *)(v27 + 8);
v33 = v32;
if ( v32 == *(_QWORD *)v27 )
{
if ( v32 == v50.m128i_i64[1] )
{
LABEL_41:
v51 = 0LL;
goto LABEL_32;
}
v33 = v32 + 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>>(
v32,
v50.m128i_i32[2],
(unsigned int)&v53,
(_DWORD)v51,
v52 | 0x60u,
0,
0) )
{
LABEL_31:
v35 = *((_QWORD *)&v53 + 1);
v36 = *(_QWORD *)(*((_QWORD *)&v53 + 1) - 40LL) == v32;
*(_QWORD *)(*((_QWORD *)&v53 + 1) - 48LL) = v32;
*(_BYTE *)(v35 - 32) = !v36;
*((_QWORD *)&v54 + 1) = v50.m128i_i64[0];
goto LABEL_32;
}
}
v34 = v52;
LOBYTE(v34) = v52 | 0x80;
v52 = v34;
LOBYTE(v27) = 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>>(
v33,
v50.m128i_i32[2],
(unsigned int)&v53,
(_DWORD)v51,
v34,
0,
0);
*((_QWORD *)&v27 + 1) = v39;
v28 = v40;
if ( (_BYTE)v27 )
goto LABEL_31;
goto LABEL_41;
}
LABEL_32:
v12 = (unsigned long long)&v55;
}
while ( !(unsigned __int8)std::regex_iterator<__gnu_cxx::__normal_iterator<char const*,std::string>,char,std::regex_traits<char>>::operator==(
&v50,
&v55,
*((_QWORD *)&v27 + 1),
v28,
v25,
v26) );
if ( v30 - v29 > 0 )
{
do
{
v12 = (unsigned int)*v29;
std::string::push_back(a1, v12);
++v29;
}
while ( v29 != v30 );
}
LABEL_6:
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v57);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v53);
v13 = *((_QWORD *)&v49 + 1);
if ( *((_QWORD *)&v49 + 1) )
{
v14 = (volatile signed __int32 *)(*((_QWORD *)&v49 + 1) + 8LL);
if ( *(_QWORD *)(*((_QWORD *)&v49 + 1) + 8LL) == 0x100000001LL )
{
v37 = **((_QWORD **)&v49 + 1);
*(_QWORD *)(*((_QWORD *)&v49 + 1) + 8LL) = 0LL;
(*(void ( **)(long long, unsigned long long, volatile signed __int32 *))(v37 + 16))(v13, v12, v14);
(*(void ( **)(long long))(*(_QWORD *)v13 + 24LL))(v13);
}
else
{
if ( _libc_single_threaded )
{
v15 = *(_DWORD *)(*((_QWORD *)&v49 + 1) + 8LL);
*(_DWORD *)(*((_QWORD *)&v49 + 1) + 8LL) = v15 - 1;
}
else
{
v15 = _InterlockedExchangeAdd(v14, 0xFFFFFFFF);
}
if ( v15 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v13);
}
}
std::locale::~locale(v41);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
LEA R15,[RBP + -0xe0]
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x108
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xd8]
MOV qword ptr [RBP + -0x128],R15
MOV RDI,RAX
MOV qword ptr [RBP + -0x130],RAX
CALL 0x00104730
LEA RDX,[0x11b739]
PXOR XMM0,XMM0
MOV RDI,R15
MOV ECX,0x10
LEA RSI,[RDX + -0x5]
MOVAPS xmmword ptr [RBP + -0xd0],XMM0
LAB_0010615f:
CALL 0x00119bf0
LEA RAX,[RBX + 0x10]
MOV byte ptr [RBX + 0x10],0x0
SUB RSP,0x8
XOR R9D,R9D
MOV qword ptr [RBX],RAX
MOV RCX,qword ptr [RBP + -0x128]
XOR R8D,R8D
MOV qword ptr [RBP + -0x108],RAX
MOV RAX,qword ptr [R12]
MOV qword ptr [RBX + 0x8],0x0
MOV R13,qword ptr [R12 + 0x8]
MOVQ XMM0,RAX
MOV R15,RAX
MOV qword ptr [RBP + -0xb0],RCX
MOV dword ptr [RBP + -0xa8],0x0
LEA R12,[RAX + R13*0x1]
LEA RAX,[RBP + -0xa0]
MOVQ XMM1,R12
MOV qword ptr [RBP + -0x120],RAX
MOV RDX,RAX
PUNPCKLQDQ XMM0,XMM1
MOVAPS xmmword ptr [RBP + -0xc0],XMM0
MOVQ RDI,XMM0
PXOR XMM0,XMM0
MOV RSI,qword ptr [RBP + -0xb8]
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM0
PUSH 0x0
LAB_001061f6:
CALL 0x00113120
POP R8
POP R9
TEST AL,AL
JZ 0x001065c7
LAB_00106207:
LEA RAX,[RBP + -0xc0]
PXOR XMM0,XMM0
LEA RSI,[RBP + -0x80]
MOV qword ptr [RBP + -0x70],0x0
MOV RDI,RAX
MOV dword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x110],RSI
MOV qword ptr [RBP + -0x118],RAX
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
CALL 0x00107c90
TEST AL,AL
JZ 0x001062fc
TEST R13,R13
JLE 0x0010626d
NOP dword ptr [RAX]
LAB_00106258:
MOVSX ESI,byte ptr [R15]
MOV RDI,RBX
LAB_0010625f:
CALL 0x00104580
ADD R15,0x1
CMP R12,R15
JNZ 0x00106258
LAB_0010626d:
LEA RDI,[RBP + -0x60]
CALL 0x00107c60
MOV RDI,qword ptr [RBP + -0x120]
CALL 0x00107c60
MOV RAX,qword ptr [RBP + -0xc8]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x001062cb
MOV RCX,qword ptr [RAX + 0x8]
LEA RDX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RCX,RAX
JZ 0x00106635
CMP byte ptr [0x00121460],0x0
JZ 0x00106654
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_001062c2:
CMP EAX,0x1
JZ 0x00106662
LAB_001062cb:
MOV RDI,qword ptr [RBP + -0x130]
CALL 0x00104680
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106680
LEA RSP,[RBP + -0x28]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001062fc:
XOR R13D,R13D
XOR R14D,R14D
LEA R15,[RBP + -0xf0]
TEST AL,AL
JNZ 0x001064fe
NOP dword ptr [RAX]
LAB_00106318:
MOV RDX,qword ptr [RBP + -0xa0]
MOV RAX,qword ptr [RBP + -0x98]
SUB RAX,RDX
LEA RCX,[RDX + RAX*0x1 + -0x30]
CMP RAX,0x49
LEA RDX,[RDX + RAX*0x1 + -0x48]
MOV RAX,RCX
CMOVC RAX,RDX
MOV R12,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x100],RAX
SUB RAX,R12
TEST RAX,RAX
JG 0x00106384
JMP 0x001063cf
LAB_00106360:
MOV RSI,qword ptr [RBP + -0xf8]
ADD R12,0x1
MOV byte ptr [RAX + RSI*0x1],R14B
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBX + 0x8],R13
MOV byte ptr [RAX + RSI*0x1 + 0x1],0x0
CMP qword ptr [RBP + -0x100],R12
JZ 0x001063cf
LAB_00106384:
MOV RAX,qword ptr [RBX + 0x8]
MOVZX R14D,byte ptr [R12]
MOV qword ptr [RBP + -0xf8],RAX
LEA R13,[RAX + 0x1]
MOV RAX,qword ptr [RBX]
CMP qword ptr [RBP + -0x108],RAX
JZ 0x00106530
MOV RDX,qword ptr [RBX + 0x10]
LAB_001063ac:
CMP RDX,R13
JNC 0x00106360
MOV RSI,qword ptr [RBP + -0xf8]
XOR ECX,ECX
XOR EDX,EDX
MOV RDI,RBX
MOV R8D,0x1
CALL 0x001046f0
MOV RAX,qword ptr [RBX]
JMP 0x00106360
LAB_001063cf:
MOV RDI,R15
CALL 0x00104730
LEA RAX,[RBP + -0xe8]
MOV RSI,R15
MOV RDI,RAX
MOV R14,RAX
CALL 0x001044f0
LEA RDI,[0x121480]
CALL 0x001044a0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0xe8]
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + RDX*0x8],0x0
JZ 0x0010666c
MOV RDI,R14
CALL 0x00104680
MOV ESI,0x3a
MOV RDI,RBX
LAB_00106421:
CALL 0x00104580
MOV RDI,R15
CALL 0x00104680
MOV RDX,qword ptr [RBP + -0x98]
MOV RAX,qword ptr [RBP + -0xa0]
MOV RCX,RDX
SUB RCX,RAX
CMP RCX,0x48
JBE 0x00106540
LEA RSI,[RAX + RCX*0x1 + -0x18]
CMP RDX,RAX
MOV R14,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
LEA RSI,[RDX + RCX*0x1 + -0x48]
CMOVNZ RSI,RAX
LAB_00106464:
CMP byte ptr [RSI + 0x10],0x0
JZ 0x001064e3
CMP RDX,RAX
JZ 0x001065bd
LAB_00106473:
MOV R12,qword ptr [RAX + 0x8]
MOV RDI,R12
CMP R12,qword ptr [RAX]
JZ 0x00106572
LAB_00106483:
MOV R8D,dword ptr [RBP + -0xa8]
SUB RSP,0x8
MOV RCX,qword ptr [RBP + -0xb0]
XOR R9D,R9D
MOV RDX,qword ptr [RBP + -0x120]
MOV RSI,qword ptr [RBP + -0xb8]
OR R8B,0x80
MOV dword ptr [RBP + -0xa8],R8D
PUSH 0x0
LAB_001064b3:
CALL 0x00113120
POP RDX
POP RCX
TEST AL,AL
JZ 0x00106562
LAB_001064c2:
MOV RAX,qword ptr [RBP + -0x98]
CMP qword ptr [RAX + -0x28],R12
MOV qword ptr [RAX + -0x30],R12
SETNZ byte ptr [RAX + -0x20]
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x88],RAX
LAB_001064e3:
MOV RSI,qword ptr [RBP + -0x110]
MOV RDI,qword ptr [RBP + -0x118]
CALL 0x00107c90
TEST AL,AL
JZ 0x00106318
LAB_001064fe:
MOV RAX,R13
SUB RAX,R14
TEST RAX,RAX
JLE 0x0010626d
NOP dword ptr [RAX]
LAB_00106510:
MOVSX ESI,byte ptr [R14]
MOV RDI,RBX
CALL 0x00104580
ADD R14,0x1
CMP R14,R13
JNZ 0x00106510
JMP 0x0010626d
LAB_00106530:
MOV EDX,0xf
JMP 0x001063ac
LAB_00106540:
LEA RSI,[RAX + RCX*0x1 + -0x48]
MOV R14,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP RDX,RAX
JZ 0x00106464
CMP RCX,0x48
CMOVNZ RSI,RAX
JMP 0x00106464
LAB_00106562:
MOV qword ptr [RBP + -0xb0],0x0
JMP 0x001064e3
LAB_00106572:
CMP R12,qword ptr [RBP + -0xb8]
JZ 0x00106562
SUB RSP,0x8
MOV R8D,dword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RBP + -0xb0]
XOR R9D,R9D
MOV RDX,qword ptr [RBP + -0x120]
MOV RSI,qword ptr [RBP + -0xb8]
PUSH 0x0
OR R8D,0x60
CALL 0x00113120
POP RSI
POP RDI
LEA RDI,[R12 + 0x1]
TEST AL,AL
JZ 0x00106483
JMP 0x001064c2
LAB_001065bd:
LEA RAX,[RAX + RCX*0x1 + -0x48]
JMP 0x00106473
LAB_001065c7:
PXOR XMM0,XMM0
LEA R14,[RBP + -0x60]
MOV RDI,qword ptr [RBP + -0x120]
MOV qword ptr [RBP + -0xc0],0x0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV RSI,R14
PXOR XMM0,XMM0
MOV qword ptr [RBP + -0xb8],0x0
MOV qword ptr [RBP + -0xb0],0x0
MOV dword ptr [RBP + -0xa8],0x0
MOVAPS xmmword ptr [RBP + -0x80],XMM0
MOVAPS xmmword ptr [RBP + -0x60],XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
LAB_00106618:
CALL 0x00105090
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,R14
MOV qword ptr [RBP + -0x88],RAX
CALL 0x00107c60
JMP 0x00106207
LAB_00106635:
MOV RAX,qword ptr [RDI]
MOV R14,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
MOV RDI,R14
CALL qword ptr [RAX + 0x18]
JMP 0x001062cb
LAB_00106654:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDX],EAX
JMP 0x001062c2
LAB_00106662:
CALL 0x001078d0
JMP 0x001062cb
LAB_0010666c:
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00106685
LAB_0010667b:
CALL 0x00104630
LAB_00106680:
CALL 0x001045e0
LAB_00106685:
CALL 0x001045e0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
string sVar2;
string *psVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
string *psVar10;
long lVar11;
long *plVar12;
ulong uVar13;
ulong uVar14;
long *in_RSI;
char cVar15;
long lVar16;
string *psVar17;
long lVar18;
long in_FS_OFFSET;
locale local_f8 [2];
long local_f0;
regex local_e8 [8];
int local_e0 [8];
int local_d8 [16];
long local_c8;
long lStack_c0;
regex *local_b8;
uint local_b0;
int local_a8 [16];
int local_98 [16];
regex_iterator local_88 [16];
int local_78 [16];
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_68 [16];
int local_58 [16];
long local_40;
local_78._12_4_ = SUB84(local_78._0_8_,4);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_e0);
local_d8 = (int [16])0x0;
/* try { // try from 0010615f to 00106163 has its CatchHandler @ 0010668a */
std::regex::_M_compile(local_e8,"[ ,.]","",0x10);
param_1[0x10] = (string)0x0;
*(string **)param_1 = param_1 + 0x10;
lVar18 = *in_RSI;
*(int8 *)(param_1 + 8) = 0;
lVar16 = in_RSI[1];
local_b0 = 0;
lVar11 = lVar18 + lVar16;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_c8 = lVar18;
lStack_c0 = lVar11;
local_b8 = local_e8;
/* try { // try from 001061f6 to 001061fa has its CatchHandler @ 001066ba */
bVar6 = 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)lVar18,(__normal_iterator)lVar11,(match_results *)local_a8,
local_e8,0,0,false);
if (!bVar6) {
local_c8 = 0;
local_78 = (int [16])0x0;
lStack_c0 = 0;
local_b8 = (regex *)0x0;
local_b0 = 0;
local_88[0] = (regex_iterator)0x0;
local_88[1] = (regex_iterator)0x0;
local_88[2] = (regex_iterator)0x0;
local_88[3] = (regex_iterator)0x0;
local_88[4] = (regex_iterator)0x0;
local_88[5] = (regex_iterator)0x0;
local_88[6] = (regex_iterator)0x0;
local_88[7] = (regex_iterator)0x0;
local_88[8] = (regex_iterator)0x0;
local_88[9] = (regex_iterator)0x0;
local_88[10] = (regex_iterator)0x0;
local_88[0xb] = (regex_iterator)0x0;
local_88[0xc] = (regex_iterator)0x0;
local_88[0xd] = (regex_iterator)0x0;
local_88[0xe] = (regex_iterator)0x0;
local_88[0xf] = (regex_iterator)0x0;
local_68[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[10] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_58 = (int [16])0x0;
/* try { // try from 00106618 to 0010661c has its CatchHandler @ 001066c6 */
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_a8,(vector *)local_68);
local_98._8_8_ = local_58._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_68);
}
local_78._0_12_ = ZEXT812(0);
local_88[0] = (regex_iterator)0x0;
local_88[1] = (regex_iterator)0x0;
local_88[2] = (regex_iterator)0x0;
local_88[3] = (regex_iterator)0x0;
local_88[4] = (regex_iterator)0x0;
local_88[5] = (regex_iterator)0x0;
local_88[6] = (regex_iterator)0x0;
local_88[7] = (regex_iterator)0x0;
local_88[8] = (regex_iterator)0x0;
local_88[9] = (regex_iterator)0x0;
local_88[10] = (regex_iterator)0x0;
local_88[0xb] = (regex_iterator)0x0;
local_88[0xc] = (regex_iterator)0x0;
local_88[0xd] = (regex_iterator)0x0;
local_88[0xe] = (regex_iterator)0x0;
local_88[0xf] = (regex_iterator)0x0;
local_68[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[10] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_68[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_58 = (int [16])0x0;
cVar7 = 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_c8,local_88);
cVar15 = (char)param_1;
if (cVar7 == '\0') {
do {
lVar11 = local_a8._0_8_ + -0x30;
if ((ulong)(local_a8._8_8_ - local_a8._0_8_) < 0x49) {
lVar11 = local_a8._0_8_ + -0x48;
}
puVar9 = (int8 *)(lVar11 + (local_a8._8_8_ - local_a8._0_8_));
psVar17 = (string *)*puVar9;
psVar3 = (string *)puVar9[1];
if (psVar3 != psVar17 && -1 < (long)psVar3 - (long)psVar17) {
do {
uVar13 = *(ulong *)(param_1 + 8);
sVar2 = *psVar17;
psVar10 = *(string **)param_1;
if (param_1 + 0x10 == psVar10) {
uVar14 = 0xf;
}
else {
uVar14 = *(ulong *)(param_1 + 0x10);
}
if (uVar14 < uVar13 + 1) {
std::string::_M_mutate((ulong)param_1,uVar13,(char *)0x0,0);
psVar10 = *(string **)param_1;
}
psVar17 = psVar17 + 1;
psVar10[uVar13] = sVar2;
*(ulong *)(param_1 + 8) = uVar13 + 1;
*(int *)(*(long *)param_1 + 1 + uVar13) = 0;
} while (psVar3 != psVar17);
}
std::locale::locale(local_f8);
std::locale::locale(&local_f0,local_f8);
lVar11 = std::locale::id::_M_id();
if (*(long *)(*(long *)(local_f0 + 8) + lVar11 * 8) == 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 0010667b to 0010667f has its CatchHandler @ 001066ae */
std::__throw_bad_cast();
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
std::locale::~locale(&local_f0);
/* try { // try from 00106421 to 00106425 has its CatchHandler @ 001066a2 */
std::string::push_back(cVar15);
std::locale::~locale(local_f8);
uVar13 = local_a8._8_8_ - local_a8._0_8_;
if (uVar13 < 0x49) {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x48));
lVar11 = *plVar12;
lVar18 = plVar12[1];
if ((local_a8._8_8_ != local_a8._0_8_) && (uVar13 != 0x48)) {
plVar12 = (long *)local_a8._0_8_;
}
}
else {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x18));
lVar11 = *plVar12;
lVar18 = plVar12[1];
plVar12 = (long *)(local_a8._8_8_ + (uVar13 - 0x48));
if (local_a8._8_8_ != local_a8._0_8_) {
plVar12 = (long *)local_a8._0_8_;
}
}
if (*(char *)(plVar12 + 2) != '\0') {
plVar12 = (long *)local_a8._0_8_;
if (local_a8._8_8_ == local_a8._0_8_) {
plVar12 = (long *)(local_a8._0_8_ + (uVar13 - 0x48));
}
lVar4 = plVar12[1];
lVar16 = lVar4;
if (lVar4 == *plVar12) {
if (lVar4 == lStack_c0) goto LAB_00106562;
bVar6 = 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)lVar4,(__normal_iterator)lStack_c0,
(match_results *)local_a8,local_b8,local_b0 | 0x60,0,false);
lVar16 = lVar4 + 1;
if (!bVar6) goto LAB_00106483;
}
else {
LAB_00106483:
local_b0 = local_b0 | 0x80;
/* try { // try from 001064b3 to 001065a8 has its CatchHandler @ 00106696 */
bVar6 = 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)lVar16,(__normal_iterator)lStack_c0,
(match_results *)local_a8,local_b8,local_b0,0,false);
if (!bVar6) {
LAB_00106562:
local_b8 = (regex *)0x0;
goto LAB_001064e3;
}
}
*(long *)(local_a8._8_8_ + -0x30) = lVar4;
*(bool *)(local_a8._8_8_ + -0x20) = *(long *)(local_a8._8_8_ + -0x28) != lVar4;
local_98._8_8_ = local_c8;
}
LAB_001064e3:
cVar7 = 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_c8,local_88);
} while (cVar7 == '\0');
if (lVar18 != lVar11 && -1 < lVar18 - lVar11) {
do {
std::string::push_back(cVar15);
lVar11 = lVar11 + 1;
} while (lVar11 != lVar18);
}
}
else if (0 < lVar16) {
do {
/* try { // try from 0010625f to 001063c9 has its CatchHandler @ 00106696 */
std::string::push_back(cVar15);
lVar18 = lVar18 + 1;
} while (lVar11 != lVar18);
}
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::~vector(local_68);
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_a8);
uVar5 = 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))();
(**(code **)(*(long *)uVar5 + 0x18))(uVar5);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar8 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar8 = *(int *)(local_d8._8_8_ + 8);
*(int *)(local_d8._8_8_ + 8) = iVar8 + -1;
}
if (iVar8 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_d8._8_8_);
}
}
}
std::locale::~locale(local_e0);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,928 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int x) {
int left = 0;
int right = A.size() - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
assert(func0({2, 5, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 1);
assert(func0({2, 3, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 2);
assert(func0({2, 4, 1, 5, 6, 6, 8, 9, 9, 9}, 6) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1646 <_ZNKSt6vectorIiSaIiEE4sizeEv>
sub $0x1,%eax
mov %eax,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
mov -0x10(%rbp),%eax
cmp -0xc(%rbp),%eax
jg 12f0 <_Z5func0RKSt6vectorIiSaIiEEi+0xc7>
mov -0xc(%rbp),%eax
sub -0x10(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%edx
mov -0x10(%rbp),%eax
add %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 166e <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
sete %al
test %al,%al
je 12b3 <_Z5func0RKSt6vectorIiSaIiEEi+0x8a>
mov -0x4(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 125c <_Z5func0RKSt6vectorIiSaIiEEi+0x33>
mov -0x4(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 166e <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
cmp %eax,-0x1c(%rbp)
setl %al
test %al,%al
je 12e2 <_Z5func0RKSt6vectorIiSaIiEEi+0xb9>
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmpq 125c <_Z5func0RKSt6vectorIiSaIiEEi+0x33>
mov -0x4(%rbp),%eax
add $0x1,%eax
mov %eax,-0x10(%rbp)
jmpq 125c <_Z5func0RKSt6vectorIiSaIiEEi+0x33>
mov -0x8(%rbp),%eax
leaveq
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
sub eax, 1
mov [rbp+var_C], eax
mov [rbp+var_8], 0FFFFFFFFh
jmp loc_1301
loc_1281:
mov eax, [rbp+var_C]
sub eax, [rbp+var_10]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov edx, eax
mov eax, [rbp+var_10]
add eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp [rbp+var_1C], eax
setz al
test al, al
jz short loc_12CC
mov eax, [rbp+var_4]
mov [rbp+var_8], eax
mov eax, [rbp+var_4]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_1301
loc_12CC:
mov eax, [rbp+var_4]
movsxd rdx, eax
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
cmp [rbp+var_1C], eax
setl al
test al, al
jz short loc_12F8
mov eax, [rbp+var_4]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_1301
loc_12F8:
mov eax, [rbp+var_4]
add eax, 1
mov [rbp+var_10], eax
loc_1301:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_C]
jle loc_1281
mov eax, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
int v3; // [rsp+10h] [rbp-10h]
int v4; // [rsp+14h] [rbp-Ch]
unsigned int v5; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v4 = std::vector<int>::size(a1) - 1;
v5 = -1;
while ( v3 <= v4 )
{
v6 = (v4 - v3) / 2 + v3;
if ( a2 == *(_DWORD *)std::vector<int>::operator[](a1, v6) )
{
v5 = (v4 - v3) / 2 + v3;
v4 = v6 - 1;
}
else if ( a2 >= *(_DWORD *)std::vector<int>::operator[](a1, v6) )
{
v3 = v6 + 1;
}
else
{
v4 = v6 - 1;
}
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001016a8
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x00101301
LAB_00101281:
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x10]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001016d0
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
SETZ AL
TEST AL,AL
JZ 0x001012cc
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101301
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0x4]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001016d0
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x1c],EAX
SETL AL
TEST AL,AL
JZ 0x001012f8
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x00101301
LAB_001012f8:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LAB_00101301:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0xc]
JLE 0x00101281
MOV EAX,dword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int *piVar2;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_1);
local_14 = local_14 + -1;
local_10 = -1;
while (local_18 <= local_14) {
iVar1 = local_18 + (local_14 - local_18) / 2;
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)iVar1);
if (param_2 == *piVar2) {
local_14 = iVar1 + -1;
local_10 = iVar1;
}
else {
piVar2 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)param_1,(long)iVar1);
if (param_2 < *piVar2) {
local_14 = iVar1 + -1;
}
else {
local_18 = iVar1 + 1;
}
}
}
return local_10;
} |
2,929 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int x) {
int left = 0;
int right = A.size() - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
assert(func0({2, 5, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 1);
assert(func0({2, 3, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 2);
assert(func0({2, 4, 1, 5, 6, 6, 8, 9, 9, 9}, 6) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
sar $0x2,%rdx
sub $0x1,%edx
js 125d <_Z5func0RKSt6vectorIiSaIiEEi+0x54>
mov $0xffffffff,%r9d
mov $0x0,%ecx
jmp 1237 <_Z5func0RKSt6vectorIiSaIiEEi+0x2e>
lea -0x1(%rax),%edx
mov %eax,%r9d
cmp %edx,%ecx
jg 1263 <_Z5func0RKSt6vectorIiSaIiEEi+0x5a>
mov %edx,%edi
sub %ecx,%edi
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
add %ecx,%eax
movslq %eax,%rdi
mov (%r8,%rdi,4),%edi
cmp %esi,%edi
je 122d <_Z5func0RKSt6vectorIiSaIiEEi+0x24>
jle 1258 <_Z5func0RKSt6vectorIiSaIiEEi+0x4f>
lea -0x1(%rax),%edx
jmp 1233 <_Z5func0RKSt6vectorIiSaIiEEi+0x2a>
lea 0x1(%rax),%ecx
jmp 1233 <_Z5func0RKSt6vectorIiSaIiEEi+0x2a>
mov $0xffffffff,%r9d
mov %r9d,%eax
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8d, esi
mov r9, [rdi]
mov rdx, [rdi+8]
sub rdx, r9
sar rdx, 2
sub edx, 1
js short loc_125F
mov edi, 0FFFFFFFFh
mov ecx, 0
jmp short loc_1238
loc_122F:
lea edx, [rax-1]
mov edi, eax
loc_1234:
cmp edx, ecx
jl short loc_1264
loc_1238:
mov esi, edx
sub esi, ecx
mov eax, esi
shr eax, 1Fh
add eax, esi
sar eax, 1
add eax, ecx
movsxd rsi, eax
mov esi, [r9+rsi*4]
cmp esi, r8d
jz short loc_122F
jle short loc_125A
lea edx, [rax-1]
jmp short loc_1234
loc_125A:
lea ecx, [rax+1]
jmp short loc_1234
loc_125F:
mov edi, 0FFFFFFFFh
loc_1264:
mov eax, edi
retn | long long func0(long long *a1, int a2)
{
long long v3; // r9
int v4; // edx
unsigned int v5; // edi
int v6; // ecx
signed int v7; // eax
int v8; // esi
v3 = *a1;
v4 = ((a1[1] - *a1) >> 2) - 1;
if ( v4 < 0 )
{
return (unsigned int)-1;
}
else
{
v5 = -1;
v6 = 0;
do
{
v7 = v6 + (v4 - v6) / 2;
v8 = *(_DWORD *)(v3 + 4LL * v7);
if ( v8 == a2 )
{
v4 = v7 - 1;
v5 = v7;
}
else if ( v8 <= a2 )
{
v6 = v7 + 1;
}
else
{
v4 = v7 - 1;
}
}
while ( v4 >= v6 );
}
return v5;
} | func0:
ENDBR64
MOV R8D,ESI
MOV R9,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,R9
SAR RDX,0x2
SUB EDX,0x1
JS 0x0010125f
MOV EDI,0xffffffff
MOV ECX,0x0
JMP 0x00101238
LAB_0010122f:
LEA EDX,[RAX + -0x1]
MOV EDI,EAX
LAB_00101234:
CMP EDX,ECX
JL 0x00101264
LAB_00101238:
MOV ESI,EDX
SUB ESI,ECX
MOV EAX,ESI
SHR EAX,0x1f
ADD EAX,ESI
SAR EAX,0x1
ADD EAX,ECX
MOVSXD RSI,EAX
MOV ESI,dword ptr [R9 + RSI*0x4]
CMP ESI,R8D
JZ 0x0010122f
JLE 0x0010125a
LEA EDX,[RAX + -0x1]
JMP 0x00101234
LAB_0010125a:
LEA ECX,[RAX + 0x1]
JMP 0x00101234
LAB_0010125f:
MOV EDI,0xffffffff
LAB_00101264:
MOV EAX,EDI
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar4 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
if (iVar4 < 0) {
iVar2 = -1;
}
else {
iVar3 = 0;
iVar5 = -1;
do {
iVar2 = (iVar4 - iVar3) / 2 + iVar3;
iVar1 = *(int *)(*(long *)param_1 + (long)iVar2 * 4);
if (iVar1 == param_2) {
iVar4 = iVar2 + -1;
}
else if (param_2 < iVar1) {
iVar4 = iVar2 + -1;
iVar2 = iVar5;
}
else {
iVar3 = iVar2 + 1;
iVar2 = iVar5;
}
iVar5 = iVar2;
} while (iVar3 <= iVar4);
}
return iVar2;
} |
2,930 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int x) {
int left = 0;
int right = A.size() - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
assert(func0({2, 5, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 1);
assert(func0({2, 3, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 2);
assert(func0({2, 4, 1, 5, 6, 6, 8, 9, 9, 9}, 6) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
mov $0xffffffff,%r9d
sub %r8,%rdx
sar $0x2,%rdx
sub $0x1,%edx
js 147c <_Z5func0RKSt6vectorIiSaIiEEi+0x4c>
xor %ecx,%ecx
jmp 1461 <_Z5func0RKSt6vectorIiSaIiEEi+0x31>
nopl 0x0(%rax)
jle 1480 <_Z5func0RKSt6vectorIiSaIiEEi+0x50>
lea -0x1(%rax),%edx
cmp %ecx,%edx
jl 147c <_Z5func0RKSt6vectorIiSaIiEEi+0x4c>
mov %edx,%eax
sub %ecx,%eax
sar %eax
add %ecx,%eax
movslq %eax,%rdi
cmp %esi,(%r8,%rdi,4)
jne 1458 <_Z5func0RKSt6vectorIiSaIiEEi+0x28>
lea -0x1(%rax),%edx
mov %eax,%r9d
cmp %ecx,%edx
jge 1461 <_Z5func0RKSt6vectorIiSaIiEEi+0x31>
mov %r9d,%eax
retq
lea 0x1(%rax),%ecx
jmp 145d <_Z5func0RKSt6vectorIiSaIiEEi+0x2d>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rdx, [rdi+8]
mov r9d, 0FFFFFFFFh
sub rdx, r8
sar rdx, 2
sub edx, 1
js short loc_13FC
xor ecx, ecx
jmp short loc_13E1
loc_13D8:
jge short loc_1400
lea edx, [rax-1]
loc_13DD:
cmp ecx, edx
jg short loc_13FC
loc_13E1:
mov eax, edx
sub eax, ecx
sar eax, 1
add eax, ecx
movsxd rdi, eax
cmp esi, [r8+rdi*4]
jnz short loc_13D8
lea edx, [rax-1]
mov r9d, eax
cmp ecx, edx
jle short loc_13E1
loc_13FC:
mov eax, r9d
retn
loc_1400:
lea ecx, [rax+1]
jmp short loc_13DD | long long func0(long long *a1, int a2)
{
long long v2; // r8
unsigned int v3; // r9d
int v4; // edx
int v5; // ecx
signed int v6; // eax
v2 = *a1;
v3 = -1;
v4 = ((a1[1] - *a1) >> 2) - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = v5 + ((v4 - v5) >> 1);
if ( a2 != *(_DWORD *)(v2 + 4LL * v6) )
break;
v4 = v6 - 1;
v3 = v6;
if ( v5 > v6 - 1 )
return v3;
}
if ( a2 >= *(_DWORD *)(v2 + 4LL * v6) )
v5 = v6 + 1;
else
v4 = v6 - 1;
}
while ( v5 <= v4 );
}
return v3;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV R9D,0xffffffff
SUB RDX,R8
SAR RDX,0x2
SUB EDX,0x1
JS 0x001013fc
XOR ECX,ECX
JMP 0x001013e1
LAB_001013d8:
JGE 0x00101400
LEA EDX,[RAX + -0x1]
LAB_001013dd:
CMP ECX,EDX
JG 0x001013fc
LAB_001013e1:
MOV EAX,EDX
SUB EAX,ECX
SAR EAX,0x1
ADD EAX,ECX
MOVSXD RDI,EAX
CMP ESI,dword ptr [R8 + RDI*0x4]
JNZ 0x001013d8
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP ECX,EDX
JLE 0x001013e1
LAB_001013fc:
MOV EAX,R9D
RET
LAB_00101400:
LEA ECX,[RAX + 0x1]
JMP 0x001013dd | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar5 = -1;
iVar4 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
if (-1 < iVar4) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (iVar4 - iVar3 >> 1) + iVar3;
iVar1 = *(int *)(*(long *)param_1 + (long)iVar2 * 4);
if (param_2 != iVar1) break;
iVar4 = iVar2 + -1;
iVar5 = iVar2;
if (iVar4 < iVar3) {
return iVar2;
}
}
if (param_2 < iVar1) {
iVar4 = iVar2 + -1;
}
else {
iVar3 = iVar2 + 1;
}
} while (iVar3 <= iVar4);
}
return iVar5;
} |
2,931 | func0 |
#include <vector>
#include <assert.h>
| int func0(const std::vector<int>& A, int x) {
int left = 0;
int right = A.size() - 1;
int result = -1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (x == A[mid]) {
result = mid;
right = mid - 1;
} else if (x < A[mid]) {
right = mid - 1;
} else {
left = mid + 1;
}
}
return result;
}
| int main() {
assert(func0({2, 5, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 1);
assert(func0({2, 3, 5, 5, 6, 6, 8, 9, 9, 9}, 5) == 2);
assert(func0({2, 4, 1, 5, 6, 6, 8, 9, 9, 9}, 6) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
mov $0xffffffff,%r9d
sub %r8,%rdx
sar $0x2,%rdx
sub $0x1,%edx
js 142c <_Z5func0RKSt6vectorIiSaIiEEi+0x4c>
xor %ecx,%ecx
jmp 1411 <_Z5func0RKSt6vectorIiSaIiEEi+0x31>
nopl 0x0(%rax)
jge 1430 <_Z5func0RKSt6vectorIiSaIiEEi+0x50>
lea -0x1(%rax),%edx
cmp %edx,%ecx
jg 142c <_Z5func0RKSt6vectorIiSaIiEEi+0x4c>
mov %edx,%eax
sub %ecx,%eax
sar %eax
add %ecx,%eax
movslq %eax,%rdi
cmp (%r8,%rdi,4),%esi
jne 1408 <_Z5func0RKSt6vectorIiSaIiEEi+0x28>
lea -0x1(%rax),%edx
mov %eax,%r9d
cmp %edx,%ecx
jle 1411 <_Z5func0RKSt6vectorIiSaIiEEi+0x31>
mov %r9d,%eax
retq
lea 0x1(%rax),%ecx
jmp 140d <_Z5func0RKSt6vectorIiSaIiEEi+0x2d>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rdx, [rdi+8]
mov r9d, 0FFFFFFFFh
sub rdx, r8
sar rdx, 2
sub edx, 1
js short loc_13FC
xor ecx, ecx
jmp short loc_13E1
loc_13D8:
jge short loc_1400
lea edx, [rax-1]
loc_13DD:
cmp ecx, edx
jg short loc_13FC
loc_13E1:
mov eax, edx
sub eax, ecx
sar eax, 1
add eax, ecx
movsxd rdi, eax
cmp esi, [r8+rdi*4]
jnz short loc_13D8
lea edx, [rax-1]
mov r9d, eax
cmp ecx, edx
jle short loc_13E1
loc_13FC:
mov eax, r9d
retn
loc_1400:
lea ecx, [rax+1]
jmp short loc_13DD | long long func0(long long *a1, int a2)
{
long long v2; // r8
unsigned int v3; // r9d
int v4; // edx
int v5; // ecx
signed int v6; // eax
v2 = *a1;
v3 = -1;
v4 = ((a1[1] - *a1) >> 2) - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = v5 + ((v4 - v5) >> 1);
if ( a2 != *(_DWORD *)(v2 + 4LL * v6) )
break;
v4 = v6 - 1;
v3 = v6;
if ( v5 > v6 - 1 )
return v3;
}
if ( a2 >= *(_DWORD *)(v2 + 4LL * v6) )
v5 = v6 + 1;
else
v4 = v6 - 1;
}
while ( v5 <= v4 );
}
return v3;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV R9D,0xffffffff
SUB RDX,R8
SAR RDX,0x2
SUB EDX,0x1
JS 0x001013fc
XOR ECX,ECX
JMP 0x001013e1
LAB_001013d8:
JGE 0x00101400
LEA EDX,[RAX + -0x1]
LAB_001013dd:
CMP ECX,EDX
JG 0x001013fc
LAB_001013e1:
MOV EAX,EDX
SUB EAX,ECX
SAR EAX,0x1
ADD EAX,ECX
MOVSXD RDI,EAX
CMP ESI,dword ptr [R8 + RDI*0x4]
JNZ 0x001013d8
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP ECX,EDX
JLE 0x001013e1
LAB_001013fc:
MOV EAX,R9D
RET
LAB_00101400:
LEA ECX,[RAX + 0x1]
JMP 0x001013dd | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
iVar5 = -1;
iVar4 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
if (-1 < iVar4) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (iVar4 - iVar3 >> 1) + iVar3;
iVar1 = *(int *)(*(long *)param_1 + (long)iVar2 * 4);
if (param_2 != iVar1) break;
iVar4 = iVar2 + -1;
iVar5 = iVar2;
if (iVar4 < iVar3) {
return iVar2;
}
}
if (param_2 < iVar1) {
iVar4 = iVar2 + -1;
}
else {
iVar3 = iVar2 + 1;
}
} while (iVar3 <= iVar4);
}
return iVar5;
} |
2,932 | func0 |
#include <assert.h>
#include <vector>
using namespace std;
| int func0(vector<int> arr, int n) {
int ans = 0;
int res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i -= 1;
}
return ans;
}
| int main() {
assert(func0({1, 2, 3}, 3) == 20);
assert(func0({1, 2}, 2) == 5);
assert(func0({1, 2, 3, 4}, 4) == 84);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
js 128e <_Z5func0St6vectorIiSaIiEEi+0x65>
mov -0x8(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 152c <_ZNSt6vectorIiSaIiEEixEm>
mov (%rax),%eax
mov -0xc(%rbp),%edx
add $0x1,%edx
imul %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,-0x10(%rbp)
mov -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
subl $0x1,-0x8(%rbp)
jmp 1253 <_Z5func0St6vectorIiSaIiEEi+0x2a>
mov -0x10(%rbp),%eax
leaveq
retq
| _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_12A8
loc_1275:
mov eax, [rbp+var_8]
movsxd rdx, eax
mov rax, [rbp+var_18]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov eax, [rax]
mov edx, [rbp+var_C]
add edx, 1
imul eax, edx
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
add [rbp+var_10], eax
mov eax, [rbp+var_4]
mov [rbp+var_C], eax
sub [rbp+var_8], 1
loc_12A8:
cmp [rbp+var_8], 0
jns short loc_1275
mov eax, [rbp+var_10]
leave
retn | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-10h]
int v4; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v3 = 0;
v4 = 0;
for ( i = a2 - 1; i >= 0; --i )
{
v6 = (v4 + 1) * *(_DWORD *)std::vector<int>::operator[](a1, i);
v3 += v6;
v4 = v6;
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012a8
LAB_00101275:
MOV EAX,dword ptr [RBP + -0x8]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001015b0
MOV EAX,dword ptr [RAX]
MOV EDX,dword ptr [RBP + -0xc]
ADD EDX,0x1
IMUL EAX,EDX
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
SUB dword ptr [RBP + -0x8],0x1
LAB_001012a8:
CMP dword ptr [RBP + -0x8],0x0
JNS 0x00101275
MOV EAX,dword ptr [RBP + -0x10]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int4 in_register_0000003c;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = 0;
for (local_10 = param_2 + -1; -1 < local_10; local_10 = local_10 + -1) {
piVar1 = (int *)std::vector<int,std::allocator<int>>::operator[]
((vector<int,std::allocator<int>> *)
CONCAT44(in_register_0000003c,param_1),(long)local_10);
local_14 = *piVar1 * (local_14 + 1);
local_18 = local_18 + local_14;
}
return local_18;
} |
2,933 | func0 |
#include <assert.h>
#include <vector>
using namespace std;
| int func0(vector<int> arr, int n) {
int ans = 0;
int res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i -= 1;
}
return ans;
}
| int main() {
assert(func0({1, 2, 3}, 3) == 20);
assert(func0({1, 2}, 2) == 5);
assert(func0({1, 2, 3, 4}, 4) == 84);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
sub $0x1,%esi
js 1236 <_Z5func0St6vectorIiSaIiEEi+0x2d>
mov (%rdi),%rcx
movslq %esi,%rsi
mov $0x0,%eax
mov $0x0,%edx
add $0x1,%eax
imul (%rcx,%rsi,4),%eax
add %eax,%edx
sub $0x1,%rsi
test %esi,%esi
jns 1222 <_Z5func0St6vectorIiSaIiEEi+0x19>
mov %edx,%eax
retq
mov $0x0,%edx
jmp 1233 <_Z5func0St6vectorIiSaIiEEi+0x2a>
| _Z5func0St6vectorIiSaIiEEi:
endbr64
sub esi, 1
js short loc_1236
mov rcx, [rdi]
movsxd rsi, esi
mov eax, 0
mov edx, 0
loc_1222:
add eax, 1
imul eax, [rcx+rsi*4]
add edx, eax
sub rsi, 1
test esi, esi
jns short loc_1222
loc_1233:
mov eax, edx
retn
loc_1236:
mov edx, 0
jmp short loc_1233 | long long func0(_QWORD *a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // edx
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
{
return 0;
}
else
{
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(*a1 + 4 * v2) * (v3 + 1);
v4 += v3;
--v2;
}
while ( (int)v2 >= 0 );
}
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x00101236
MOV RCX,qword ptr [RDI]
MOVSXD RSI,ESI
MOV EAX,0x0
MOV EDX,0x0
LAB_00101222:
ADD EAX,0x1
IMUL EAX,dword ptr [RCX + RSI*0x4]
ADD EDX,EAX
SUB RSI,0x1
TEST ESI,ESI
JNS 0x00101222
LAB_00101233:
MOV EAX,EDX
RET
LAB_00101236:
MOV EDX,0x0
JMP 0x00101233 | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int4 in_register_0000003c;
if (param_2 + -1 < 0) {
iVar2 = 0;
}
else {
lVar3 = (long)(param_2 + -1);
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(*(long *)CONCAT44(in_register_0000003c,param_1) + lVar3 * 4);
iVar2 = iVar2 + iVar1;
lVar3 = lVar3 + -1;
} while (-1 < (int)lVar3);
}
return iVar2;
} |
2,934 | func0 |
#include <assert.h>
#include <vector>
using namespace std;
| int func0(vector<int> arr, int n) {
int ans = 0;
int res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i -= 1;
}
return ans;
}
| int main() {
assert(func0({1, 2, 3}, 3) == 20);
assert(func0({1, 2}, 2) == 5);
assert(func0({1, 2, 3, 4}, 4) == 84);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
sub $0x1,%esi
js 13e0 <_Z5func0St6vectorIiSaIiEEi+0x30>
mov (%rdi),%rdx
movslq %esi,%rsi
xor %eax,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
add $0x1,%eax
imul (%rdx,%rsi,4),%eax
sub $0x1,%rsi
add %eax,%r8d
test %esi,%esi
jns 13c8 <_Z5func0St6vectorIiSaIiEEi+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEEi:
endbr64
sub esi, 1
js short loc_13D0
mov rcx, [rdi]
movsxd rsi, esi
xor eax, eax
xor edx, edx
nop dword ptr [rax+rax+00h]
loc_13B8:
add eax, 1
imul eax, [rcx+rsi*4]
sub rsi, 1
add edx, eax
test esi, esi
jns short loc_13B8
mov eax, edx
retn
loc_13D0:
xor edx, edx
mov eax, edx
retn | long long func0(_QWORD *a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // edx
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
return 0LL;
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(*a1 + 4 * v2--) * (v3 + 1);
v4 += v3;
}
while ( (int)v2 >= 0 );
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x001013d0
MOV RCX,qword ptr [RDI]
MOVSXD RSI,ESI
XOR EAX,EAX
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b8:
ADD EAX,0x1
IMUL EAX,dword ptr [RCX + RSI*0x4]
SUB RSI,0x1
ADD EDX,EAX
TEST ESI,ESI
JNS 0x001013b8
MOV EAX,EDX
RET
LAB_001013d0:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int4 in_register_0000003c;
if (-1 < param_2 + -1) {
lVar3 = (long)(param_2 + -1);
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(*(long *)CONCAT44(in_register_0000003c,param_1) + lVar3 * 4);
lVar3 = lVar3 + -1;
iVar2 = iVar2 + iVar1;
} while (-1 < (int)lVar3);
return iVar2;
}
return 0;
} |
2,935 | func0 |
#include <assert.h>
#include <vector>
using namespace std;
| int func0(vector<int> arr, int n) {
int ans = 0;
int res = 0;
int i = n - 1;
while (i >= 0) {
int incr = arr[i] * (1 + res);
ans += incr;
res = incr;
i -= 1;
}
return ans;
}
| int main() {
assert(func0({1, 2, 3}, 3) == 20);
assert(func0({1, 2}, 2) == 5);
assert(func0({1, 2, 3, 4}, 4) == 84);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
sub $0x1,%esi
js 13c0 <_Z5func0St6vectorIiSaIiEEi+0x30>
mov (%rdi),%rdx
movslq %esi,%rsi
xor %eax,%eax
xor %r8d,%r8d
nopl 0x0(%rax)
add $0x1,%eax
imul (%rdx,%rsi,4),%eax
sub $0x1,%rsi
add %eax,%r8d
test %esi,%esi
jns 13a8 <_Z5func0St6vectorIiSaIiEEi+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0St6vectorIiSaIiEEi:
endbr64
sub esi, 1
js short loc_13D0
mov rcx, [rdi]
movsxd rsi, esi
xor eax, eax
xor edx, edx
nop dword ptr [rax+rax+00h]
loc_13B8:
add eax, 1
imul eax, [rcx+rsi*4]
sub rsi, 1
add edx, eax
test esi, esi
jns short loc_13B8
mov eax, edx
retn
loc_13D0:
xor edx, edx
mov eax, edx
retn | long long func0(_QWORD *a1, int a2)
{
long long v2; // rsi
int v3; // eax
unsigned int v4; // edx
LODWORD(v2) = a2 - 1;
if ( (int)v2 < 0 )
return 0LL;
v2 = (int)v2;
v3 = 0;
v4 = 0;
do
{
v3 = *(_DWORD *)(*a1 + 4 * v2--) * (v3 + 1);
v4 += v3;
}
while ( (int)v2 >= 0 );
return v4;
} | func0:
ENDBR64
SUB ESI,0x1
JS 0x001013d0
MOV RCX,qword ptr [RDI]
MOVSXD RSI,ESI
XOR EAX,EAX
XOR EDX,EDX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013b8:
ADD EAX,0x1
IMUL EAX,dword ptr [RCX + RSI*0x4]
SUB RSI,0x1
ADD EDX,EAX
TEST ESI,ESI
JNS 0x001013b8
MOV EAX,EDX
RET
LAB_001013d0:
XOR EDX,EDX
MOV EAX,EDX
RET | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
long lVar3;
int4 in_register_0000003c;
if (-1 < param_2 + -1) {
lVar3 = (long)(param_2 + -1);
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = (iVar1 + 1) * *(int *)(*(long *)CONCAT44(in_register_0000003c,param_1) + lVar3 * 4);
lVar3 = lVar3 + -1;
iVar2 = iVar2 + iVar1;
} while (-1 < (int)lVar3);
return iVar2;
}
return 0;
} |
2,936 | func0 | #include <iostream>
#include <assert.h>
unsigned int set_middle_bits(unsigned int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| unsigned int func0(unsigned int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O0 | cpp | func0(unsigned int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x8,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jne 11e6 <_Z5func0j+0x1c>
mov $0x1,%eax
jmp 11f3 <_Z5func0j+0x29>
mov -0x4(%rbp),%eax
mov %eax,%edi
callq 1189 <_Z15set_middle_bitsj>
xor -0x4(%rbp),%eax
leaveq
retq
| _Z5func0j:
endbr64
push rbp
mov rbp, rsp
sub rsp, 8
mov [rbp+var_4], edi
cmp [rbp+var_4], 1
jnz short loc_11A6
mov eax, 1
jmp short locret_11B3
loc_11A6:
mov eax, [rbp+var_4]
mov edi, eax; unsigned int
call _Z15set_middle_bitsj; set_middle_bits(uint)
xor eax, [rbp+var_4]
locret_11B3:
leave
retn | long long func0(unsigned int a1)
{
if ( a1 == 1 )
return 1LL;
else
return a1 ^ (unsigned int)set_middle_bits(a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x8
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x001011a6
MOV EAX,0x1
JMP 0x001011b3
LAB_001011a6:
MOV EAX,dword ptr [RBP + -0x4]
MOV EDI,EAX
CALL 0x00101149
XOR EAX,dword ptr [RBP + -0x4]
LAB_001011b3:
LEAVE
RET | /* func0(unsigned int) */
uint func0(uint param_1)
{
uint uVar1;
if (param_1 == 1) {
uVar1 = 1;
}
else {
uVar1 = set_middle_bits(param_1);
uVar1 = uVar1 ^ param_1;
}
return uVar1;
} |
2,937 | func0 | #include <iostream>
#include <assert.h>
unsigned int set_middle_bits(unsigned int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| unsigned int func0(unsigned int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O1 | cpp | func0(unsigned int):
endbr64
mov %edi,%eax
cmp $0x1,%edi
je 11c9 <_Z5func0j+0x34>
mov %edi,%edx
shr %edx
or %edi,%edx
mov %edx,%eax
shr $0x2,%eax
or %eax,%edx
mov %edx,%eax
shr $0x4,%eax
or %eax,%edx
mov %edx,%eax
shr $0x8,%eax
or %eax,%edx
mov %edx,%eax
shr $0x10,%eax
or %edx,%eax
shr %eax
xor %edi,%eax
xor $0x1,%eax
retq
| _Z5func0j:
endbr64
mov eax, edi
cmp edi, 1
jz short locret_1189
mov edx, edi
shr edx, 1
or edx, edi
mov eax, edx
shr eax, 2
or edx, eax
mov eax, edx
shr eax, 4
or edx, eax
mov eax, edx
shr eax, 8
or edx, eax
mov eax, edx
shr eax, 10h
or eax, edx
shr eax, 1
xor eax, edi
xor eax, 1
locret_1189:
retn | long long func0(unsigned int a1)
{
long long result; // rax
result = a1;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1;
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x1
JZ 0x00101189
MOV EDX,EDI
SHR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x10
OR EAX,EDX
SHR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_00101189:
RET | /* func0(unsigned int) */
uint func0(uint param_1)
{
uint uVar1;
if (param_1 != 1) {
uVar1 = param_1 >> 1 | param_1;
uVar1 = uVar1 | uVar1 >> 2;
uVar1 = uVar1 | uVar1 >> 4;
uVar1 = uVar1 | uVar1 >> 8;
param_1 = (uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return param_1;
} |
2,938 | func0 | #include <iostream>
#include <assert.h>
unsigned int set_middle_bits(unsigned int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| unsigned int func0(unsigned int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O2 | cpp | func0(unsigned int):
endbr64
mov $0x1,%eax
cmp $0x1,%edi
je 1227 <_Z5func0j+0x37>
mov %edi,%edx
shr %edx
or %edi,%edx
mov %edx,%eax
shr $0x2,%eax
or %eax,%edx
mov %edx,%eax
shr $0x4,%eax
or %eax,%edx
mov %edx,%eax
shr $0x8,%eax
or %eax,%edx
mov %edx,%eax
shr $0x10,%eax
or %edx,%eax
shr %eax
xor %edi,%eax
xor $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0j:
endbr64
mov eax, 1
cmp edi, 1
jz short locret_11A7
mov edx, edi
shr edx, 1
or edx, edi
mov eax, edx
shr eax, 2
or edx, eax
mov eax, edx
shr eax, 4
or edx, eax
mov eax, edx
shr eax, 8
or edx, eax
mov eax, edx
shr eax, 10h
or eax, edx
shr eax, 1
xor eax, edi
xor eax, 1
locret_11A7:
retn | long long func0(unsigned int a1)
{
long long result; // rax
result = 1LL;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1;
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,0x1
JZ 0x001011a7
MOV EDX,EDI
SHR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x10
OR EAX,EDX
SHR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_001011a7:
RET | /* func0(unsigned int) */
uint func0(uint param_1)
{
uint uVar1;
uVar1 = 1;
if (param_1 != 1) {
uVar1 = param_1 >> 1 | param_1;
uVar1 = uVar1 | uVar1 >> 2;
uVar1 = uVar1 | uVar1 >> 4;
uVar1 = uVar1 | uVar1 >> 8;
uVar1 = (uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return uVar1;
} |
2,939 | func0 | #include <iostream>
#include <assert.h>
unsigned int set_middle_bits(unsigned int n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
return (n >> 1) ^ 1;
}
| unsigned int func0(unsigned int n) {
if (n == 1) {
return 1;
}
return n ^ set_middle_bits(n);
}
| int main() {
assert(func0(9) == 15);
assert(func0(10) == 12);
assert(func0(11) == 13);
return 0;
}
| O3 | cpp | func0(unsigned int):
endbr64
mov $0x1,%eax
cmp $0x1,%edi
je 1227 <_Z5func0j+0x37>
mov %edi,%edx
shr %edx
or %edi,%edx
mov %edx,%eax
shr $0x2,%eax
or %eax,%edx
mov %edx,%eax
shr $0x4,%eax
or %eax,%edx
mov %edx,%eax
shr $0x8,%eax
or %eax,%edx
mov %edx,%eax
shr $0x10,%eax
or %edx,%eax
shr %eax
xor %edi,%eax
xor $0x1,%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0j:
endbr64
mov eax, 1
cmp edi, 1
jz short locret_11A7
mov edx, edi
shr edx, 1
or edx, edi
mov eax, edx
shr eax, 2
or edx, eax
mov eax, edx
shr eax, 4
or edx, eax
mov eax, edx
shr eax, 8
or edx, eax
mov eax, edx
shr eax, 10h
or eax, edx
shr eax, 1
xor eax, edi
xor eax, 1
locret_11A7:
retn | long long func0(unsigned int a1)
{
long long result; // rax
result = 1LL;
if ( a1 != 1 )
return a1 ^ ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1) | ((((((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 8) | ((((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 4) | ((a1 | (a1 >> 1)) >> 2) | a1 | (a1 >> 1)) >> 16)) >> 1) ^ 1;
return result;
} | func0:
ENDBR64
MOV EAX,0x1
CMP EDI,0x1
JZ 0x001011a7
MOV EDX,EDI
SHR EDX,0x1
OR EDX,EDI
MOV EAX,EDX
SHR EAX,0x2
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x4
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
OR EDX,EAX
MOV EAX,EDX
SHR EAX,0x10
OR EAX,EDX
SHR EAX,0x1
XOR EAX,EDI
XOR EAX,0x1
LAB_001011a7:
RET | /* func0(unsigned int) */
uint func0(uint param_1)
{
uint uVar1;
uVar1 = 1;
if (param_1 != 1) {
uVar1 = param_1 >> 1 | param_1;
uVar1 = uVar1 | uVar1 >> 2;
uVar1 = uVar1 | uVar1 >> 4;
uVar1 = uVar1 | uVar1 >> 8;
uVar1 = (uVar1 >> 0x10 | uVar1) >> 1 ^ param_1 ^ 1;
}
return uVar1;
} |
2,940 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int x) {
auto i = std::lower_bound(a.begin(), a.end(), x);
return i - a.begin();
}
| int main() {
assert(func0({1,2,4,5}, 6) == 4);
assert(func0({1,2,4,5}, 3) == 2);
assert(func0({1,2,4,5}, 7) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 16ea <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1692 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,%rcx
lea -0x3c(%rbp),%rax
mov %rax,%rdx
mov %rbx,%rsi
mov %rcx,%rdi
callq 1742 <_ZSt11lower_boundIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET_S8_S8_RKT0_>
mov %rax,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1692 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1778 <_ZN9__gnu_cxxmiIPKiSt6vectorIiSaIiEEEENS_17__normal_iteratorIT_T0_E15difference_typeERKS9_SC_>
mov -0x18(%rbp),%rcx
xor %fs:0x28,%rcx
je 12f7 <_Z5func0RKSt6vectorIiSaIiEEi+0x8e>
callq 1140 <__stack_chk_fail@plt>
add $0x38,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rcx, rax
lea rax, [rbp+var_3C]
mov rdx, rax
mov rsi, rbx
mov rdi, rcx
call _ZSt11lower_boundIN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEEiET_S8_S8_RKT0_; std::lower_bound<__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_28], rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+var_20], rax
lea rdx, [rbp+var_20]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxmiIPKiSt6vectorIiSaIiEEEENS_17__normal_iteratorIT_T0_E15difference_typeERKS9_SC_; __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&)
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_12D7
call ___stack_chk_fail
loc_12D7:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+4h] [rbp-3Ch] BYREF
long long v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+18h] [rbp-28h] BYREF
_QWORD v8[3]; // [rsp+20h] [rbp-20h] BYREF
v6 = a1;
v5 = a2;
v8[1] = __readfsqword(0x28u);
v2 = std::vector<int>::end(a1);
v3 = std::vector<int>::begin(a1);
v7 = std::lower_bound<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,int>(v3, v2, &v5);
v8[0] = std::vector<int>::begin(v6);
return __gnu_cxx::operator-<int const*,std::vector<int>>(&v7, v8);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101686
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x0010163a
MOV RCX,RAX
LEA RAX,[RBP + -0x3c]
MOV RDX,RAX
MOV RSI,RBX
MOV RDI,RCX
CALL 0x001016d6
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x0010163a
MOV qword ptr [RBP + -0x20],RAX
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x0010170c
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012d7
CALL 0x00101130
LAB_001012d7:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
void func0(vector *param_1,int param_2)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int4 extraout_var;
long in_FS_OFFSET;
int local_44;
vector<int,std::allocator<int>> *local_40;
int8 local_30;
int8 local_28;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_44 = param_2;
local_40 = (vector<int,std::allocator<int>> *)param_1;
_Var1 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_1);
_Var2 = std::vector<int,std::allocator<int>>::begin(local_40);
_Var1 = std::lower_bound<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,int>
(_Var2,_Var1,&local_44);
local_30 = CONCAT44(extraout_var,_Var1);
local_28 = std::vector<int,std::allocator<int>>::begin(local_40);
operator-((__normal_iterator *)&local_30,(__normal_iterator *)&local_28);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
} |
2,941 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int x) {
auto i = std::lower_bound(a.begin(), a.end(), x);
return i - a.begin();
}
| int main() {
assert(func0({1,2,4,5}, 6) == 4);
assert(func0({1,2,4,5}, 3) == 2);
assert(func0({1,2,4,5}, 7) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%rcx
mov 0x8(%rdi),%rdx
sub %rcx,%rdx
sar $0x2,%rdx
mov %rcx,%rax
jmp 1263 <_Z5func0RKSt6vectorIiSaIiEEi+0x1a>
mov %rdi,%rdx
test %rdx,%rdx
jle 1284 <_Z5func0RKSt6vectorIiSaIiEEi+0x3b>
mov %rdx,%rdi
sar %rdi
lea (%rax,%rdi,4),%r8
cmp %esi,(%r8)
jge 1260 <_Z5func0RKSt6vectorIiSaIiEEi+0x17>
lea 0x4(%r8),%rax
sub %rdi,%rdx
sub $0x1,%rdx
jmp 1263 <_Z5func0RKSt6vectorIiSaIiEEi+0x1a>
sub %rcx,%rax
sar $0x2,%rax
retq
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rax, [rdi+8]
sub rax, r8
mov rdx, rax
sar rdx, 2
test rax, rax
jle short loc_124B
mov rax, r8
jmp short loc_1230
loc_1228:
mov rdx, rcx
loc_122B:
test rdx, rdx
jle short loc_124E
loc_1230:
mov rcx, rdx
sar rcx, 1
lea rdi, [rax+rcx*4]
cmp [rdi], esi
jge short loc_1228
lea rax, [rdi+4]
sub rdx, rcx
sub rdx, 1
jmp short loc_122B
loc_124B:
mov rax, r8
loc_124E:
sub rax, r8
sar rax, 2
retn | long long func0(_QWORD *a1, int a2)
{
_DWORD *v2; // r8
long long v3; // rdx
_DWORD *v4; // rax
_DWORD *v5; // rdi
v2 = (_DWORD *)*a1;
v3 = (long long)(a1[1] - *a1) >> 2;
if ( (long long)(a1[1] - *a1) <= 0 )
{
v4 = (_DWORD *)*a1;
}
else
{
v4 = (_DWORD *)*a1;
do
{
v5 = &v4[v3 >> 1];
if ( *v5 >= a2 )
{
v3 >>= 1;
}
else
{
v4 = v5 + 1;
v3 = v3 - (v3 >> 1) - 1;
}
}
while ( v3 > 0 );
}
return v4 - v2;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R8
MOV RDX,RAX
SAR RDX,0x2
TEST RAX,RAX
JLE 0x0010124b
MOV RAX,R8
JMP 0x00101230
LAB_00101228:
MOV RDX,RCX
LAB_0010122b:
TEST RDX,RDX
JLE 0x0010124e
LAB_00101230:
MOV RCX,RDX
SAR RCX,0x1
LEA RDI,[RAX + RCX*0x4]
CMP dword ptr [RDI],ESI
JGE 0x00101228
LEA RAX,[RDI + 0x4]
SUB RDX,RCX
SUB RDX,0x1
JMP 0x0010122b
LAB_0010124b:
MOV RAX,R8
LAB_0010124e:
SUB RAX,R8
SAR RAX,0x2
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
long func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
long lVar4;
long lVar5;
piVar2 = *(int **)param_1;
lVar5 = *(long *)(param_1 + 8) - (long)piVar2;
piVar1 = piVar2;
lVar4 = lVar5 >> 2;
while (lVar3 = lVar4, 0 < lVar5) {
lVar5 = lVar3 >> 1;
lVar4 = lVar5;
if (piVar1[lVar5] < param_2) {
piVar1 = piVar1 + lVar5 + 1;
lVar5 = (lVar3 - lVar5) + -1;
lVar4 = lVar5;
}
}
return (long)piVar1 - (long)piVar2 >> 2;
} |
2,942 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int x) {
auto i = std::lower_bound(a.begin(), a.end(), x);
return i - a.begin();
}
| int main() {
assert(func0({1,2,4,5}, 6) == 4);
assert(func0({1,2,4,5}, 3) == 2);
assert(func0({1,2,4,5}, 7) == 4);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
mov %r8,%rax
sar $0x2,%rdx
nopl (%rax)
test %rdx,%rdx
jle 147b <_Z5func0RKSt6vectorIiSaIiEEi+0x3b>
mov %rdx,%rcx
sar %rcx
lea (%rax,%rcx,4),%rdi
cmp %esi,(%rdi)
jge 1488 <_Z5func0RKSt6vectorIiSaIiEEi+0x48>
sub %rcx,%rdx
lea 0x4(%rdi),%rax
sub $0x1,%rdx
test %rdx,%rdx
jg 145d <_Z5func0RKSt6vectorIiSaIiEEi+0x1d>
sub %r8,%rax
sar $0x2,%rax
retq
nopl 0x0(%rax,%rax,1)
mov %rcx,%rdx
jmp 1458 <_Z5func0RKSt6vectorIiSaIiEEi+0x18>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rax, [rdi+8]
sub rax, r8
mov rdx, rax
sar rdx, 2
test rax, rax
jle short loc_13C0
mov rax, r8
jmp short loc_13A0
loc_1390:
sub rdx, rcx
lea rax, [rdi+4]
sub rdx, 1
test rdx, rdx
jle short loc_13B6
loc_13A0:
mov rcx, rdx
sar rcx, 1
lea rdi, [rax+rcx*4]
cmp [rdi], esi
jl short loc_1390
mov rdx, rcx
test rdx, rdx
jg short loc_13A0
loc_13B6:
sub rax, r8
sar rax, 2
retn
loc_13C0:
xor eax, eax
retn | long long func0(_QWORD *a1, int a2)
{
_DWORD *v2; // r8
long long v3; // rdx
_DWORD *v4; // rax
long long v5; // rcx
_DWORD *v6; // rdi
v2 = (_DWORD *)*a1;
v3 = (long long)(a1[1] - *a1) >> 2;
if ( (long long)(a1[1] - *a1) <= 0 )
return 0LL;
v4 = (_DWORD *)*a1;
do
{
while ( 1 )
{
v5 = v3 >> 1;
v6 = &v4[v3 >> 1];
if ( *v6 >= a2 )
break;
v4 = v6 + 1;
v3 = v3 - v5 - 1;
if ( v3 <= 0 )
return v4 - v2;
}
v3 >>= 1;
}
while ( v5 > 0 );
return v4 - v2;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R8
MOV RDX,RAX
SAR RDX,0x2
TEST RAX,RAX
JLE 0x001013c0
MOV RAX,R8
JMP 0x001013a0
LAB_00101390:
SUB RDX,RCX
LEA RAX,[RDI + 0x4]
SUB RDX,0x1
TEST RDX,RDX
JLE 0x001013b6
LAB_001013a0:
MOV RCX,RDX
SAR RCX,0x1
LEA RDI,[RAX + RCX*0x4]
CMP dword ptr [RDI],ESI
JL 0x00101390
MOV RDX,RCX
TEST RDX,RDX
JG 0x001013a0
LAB_001013b6:
SUB RAX,R8
SAR RAX,0x2
RET
LAB_001013c0:
XOR EAX,EAX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
long func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
long lVar4;
piVar1 = *(int **)param_1;
lVar4 = *(long *)(param_1 + 8) - (long)piVar1 >> 2;
piVar2 = piVar1;
if (*(long *)(param_1 + 8) - (long)piVar1 < 1) {
return 0;
}
do {
while( true ) {
lVar3 = lVar4 >> 1;
if (piVar2[lVar3] < param_2) break;
lVar4 = lVar3;
if (lVar3 < 1) goto LAB_001013b6;
}
piVar2 = piVar2 + lVar3 + 1;
lVar4 = (lVar4 - lVar3) + -1;
} while (0 < lVar4);
LAB_001013b6:
return (long)piVar2 - (long)piVar1 >> 2;
} |
2,943 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(const std::vector<int>& a, int x) {
auto i = std::lower_bound(a.begin(), a.end(), x);
return i - a.begin();
}
| int main() {
assert(func0({1,2,4,5}, 6) == 4);
assert(func0({1,2,4,5}, 3) == 2);
assert(func0({1,2,4,5}, 7) == 4);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
mov %r8,%rax
sar $0x2,%rdx
nopl (%rax)
test %rdx,%rdx
jle 144b <_Z5func0RKSt6vectorIiSaIiEEi+0x3b>
mov %rdx,%rcx
sar %rcx
lea (%rax,%rcx,4),%rdi
cmp %esi,(%rdi)
jge 1458 <_Z5func0RKSt6vectorIiSaIiEEi+0x48>
sub %rcx,%rdx
lea 0x4(%rdi),%rax
sub $0x1,%rdx
test %rdx,%rdx
jg 142d <_Z5func0RKSt6vectorIiSaIiEEi+0x1d>
sub %r8,%rax
sar $0x2,%rax
retq
nopl 0x0(%rax,%rax,1)
mov %rcx,%rdx
jmp 1428 <_Z5func0RKSt6vectorIiSaIiEEi+0x18>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rax, [rdi+8]
sub rax, r8
mov rdx, rax
sar rdx, 2
test rax, rax
jle short loc_13D0
mov rax, r8
nop dword ptr [rax]
loc_1390:
mov rcx, rdx
sar rcx, 1
lea rdi, [rax+rcx*4]
cmp [rdi], esi
jge short loc_13C0
sub rdx, rcx
lea rax, [rdi+4]
sub rdx, 1
test rdx, rdx
jg short loc_1390
loc_13AE:
sub rax, r8
sar rax, 2
retn
loc_13C0:
test rcx, rcx
jz short loc_13AE
mov rdx, rcx
jmp short loc_1390
loc_13D0:
xor eax, eax
retn | long long func0(_QWORD *a1, int a2)
{
_DWORD *v2; // r8
long long v3; // rdx
_DWORD *v4; // rax
long long v5; // rcx
_DWORD *v6; // rdi
v2 = (_DWORD *)*a1;
v3 = (long long)(a1[1] - *a1) >> 2;
if ( (long long)(a1[1] - *a1) <= 0 )
return 0LL;
v4 = (_DWORD *)*a1;
while ( 1 )
{
while ( 1 )
{
v5 = v3 >> 1;
v6 = &v4[v3 >> 1];
if ( *v6 >= a2 )
break;
v4 = v6 + 1;
v3 = v3 - v5 - 1;
if ( v3 <= 0 )
return v4 - v2;
}
if ( !v5 )
break;
v3 >>= 1;
}
return v4 - v2;
} | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R8
MOV RDX,RAX
SAR RDX,0x2
TEST RAX,RAX
JLE 0x001013d0
MOV RAX,R8
NOP dword ptr [RAX]
LAB_00101390:
MOV RCX,RDX
SAR RCX,0x1
LEA RDI,[RAX + RCX*0x4]
CMP dword ptr [RDI],ESI
JGE 0x001013c0
SUB RDX,RCX
LEA RAX,[RDI + 0x4]
SUB RDX,0x1
TEST RDX,RDX
JG 0x00101390
LAB_001013ae:
SUB RAX,R8
SAR RAX,0x2
RET
LAB_001013c0:
TEST RCX,RCX
JZ 0x001013ae
MOV RDX,RCX
JMP 0x00101390
LAB_001013d0:
XOR EAX,EAX
RET | /* func0(std::vector<int, std::allocator<int> > const&, int) */
long func0(vector *param_1,int param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
long lVar4;
piVar1 = *(int **)param_1;
piVar2 = piVar1;
lVar4 = *(long *)(param_1 + 8) - (long)piVar1 >> 2;
if (*(long *)(param_1 + 8) - (long)piVar1 < 1) {
return 0;
}
do {
while( true ) {
lVar3 = lVar4 >> 1;
if (piVar2[lVar3] < param_2) break;
lVar4 = lVar3;
if (lVar3 == 0) goto LAB_001013ae;
}
piVar2 = piVar2 + lVar3 + 1;
lVar4 = (lVar4 - lVar3) + -1;
} while (0 < lVar4);
LAB_001013ae:
return (long)piVar2 - (long)piVar1 >> 2;
} |
2,944 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& string) {
std::regex regex("^[aeiouAEIOU][A-Za-z0-9_]*");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
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 $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2b3ec(%rip),%rsi
mov %rax,%rdi
callq 7170 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC1EPKcNSt15regex_constants18syntax_option_typeE>
lea -0x40(%rbp),%rcx
mov -0x60(%rbp),%rax
mov $0x0,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 722d <_ZSt12regex_searchISt11char_traitsIcESaIcEcNSt7__cxx1112regex_traitsIcEEEbRKNS3_12basic_stringIT1_T_T0_EERKNS3_11basic_regexIS7_T2_EENSt15regex_constants15match_flag_typeE>
test %al,%al
je 5cf2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x89>
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 5af0 <_ZNSaIcEC1Ev@plt>
lea -0x41(%rbp),%rdx
mov -0x58(%rbp),%rax
lea 0x2b3c8(%rip),%rsi
mov %rax,%rdi
callq 727e <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_>
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 58f0 <_ZNSaIcED1Ev@plt>
jmp 5d21 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xb8>
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 5af0 <_ZNSaIcEC1Ev@plt>
lea -0x41(%rbp),%rdx
mov -0x58(%rbp),%rax
lea 0x2b39d(%rip),%rsi
mov %rax,%rdi
callq 727e <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1IS3_EEPKcRKS3_>
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 58f0 <_ZNSaIcED1Ev@plt>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71fa <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 5d8b <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x122>
jmp 5d86 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x11d>
endbr64
mov %rax,%rbx
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 58f0 <_ZNSaIcED1Ev@plt>
jmp 5d6f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x106>
endbr64
mov %rax,%rbx
lea -0x41(%rbp),%rax
mov %rax,%rdi
callq 58f0 <_ZNSaIcED1Ev@plt>
jmp 5d6f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x106>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 71fa <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 5ae0 <_Unwind_Resume@plt>
callq 5940 <__stack_chk_fail@plt>
mov -0x58(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aAeiouaeiouAZaZ; "^[aeiouAEIOU][A-Za-z0-9_]*"
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)
lea rcx, [rbp+var_40]
mov rax, [rbp+var_70]
mov edx, 0
mov rsi, rcx
mov rdi, rax
call _ZSt12regex_searchISt11char_traitsIcESaIcEcNSt7__cxx1112regex_traitsIcEEEbRKNS3_12basic_stringIT1_T_T0_EERKNS3_11basic_regexIS7_T2_EENSt15regex_constants15match_flag_typeE; std::regex_search<std::char_traits<char>,std::allocator<char>,char,std::regex_traits<char>>(std::string const&,std::basic_regex<char,std::regex_traits<char>> const&,std::regex_constants::match_flag_type)
test al, al
jz short loc_4B96
lea rax, [rbp+var_51]
mov [rbp+var_50], rax
nop
nop
lea rdx, [rbp+var_51]
mov rax, [rbp+var_68]
lea rcx, aValid; "Valid"
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbp+var_51]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
jmp short loc_4BC7
loc_4B96:
lea rax, [rbp+var_51]
mov [rbp+var_48], rax
nop
nop
lea rdx, [rbp+var_51]
mov rax, [rbp+var_68]
lea rcx, aInvalid; "Invalid"
mov rsi, rcx
mov rdi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbp+var_51]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
loc_4BC7:
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_4C47
jmp short loc_4C42
endbr64
mov rbx, rax
lea rax, [rbp+var_51]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
jmp short loc_4C17
endbr64
mov rbx, rax
lea rax, [rbp+var_51]
mov rdi, rax
call _ZNSt15__new_allocatorIcED2Ev; std::__new_allocator<char>::~__new_allocator()
nop
jmp short loc_4C17
endbr64
mov rbx, rax
loc_4C17:
lea rax, [rbp+var_40]
mov rdi, rax
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_4C3A
call ___stack_chk_fail
loc_4C3A:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_4C42:
call ___stack_chk_fail
loc_4C47:
mov rax, [rbp+var_68]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-51h] BYREF
char *v4; // [rsp+20h] [rbp-50h]
char *v5; // [rsp+28h] [rbp-48h]
_BYTE v6[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v7; // [rsp+58h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(v6, "^[aeiouAEIOU][A-Za-z0-9_]*", 16LL);
if ( (unsigned __int8)std::regex_search<std::char_traits<char>,std::allocator<char>,char,std::regex_traits<char>>(
a2,
v6,
0LL) )
{
v4 = &v3;
std::string::basic_string<std::allocator<char>>(a1, "Valid", &v3);
}
else
{
v5 = &v3;
std::string::basic_string<std::allocator<char>>(a1, "Invalid", &v3);
}
std::__new_allocator<char>::~__new_allocator(&v3);
std::basic_regex<char,std::regex_traits<char>>::~basic_regex(v6);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b43:
CALL 0x001061ba
LEA RCX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x70]
MOV EDX,0x0
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b5b:
CALL 0x0010628b
TEST AL,AL
JZ 0x00104b96
LEA RAX,[RBP + -0x51]
MOV qword ptr [RBP + -0x50],RAX
NOP
NOP
LEA RDX,[RBP + -0x51]
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[0x13206c]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b83:
CALL 0x001062dc
LEA RAX,[RBP + -0x51]
MOV RDI,RAX
CALL 0x00106424
JMP 0x00104bc7
LAB_00104b96:
LEA RAX,[RBP + -0x51]
MOV qword ptr [RBP + -0x48],RAX
NOP
NOP
LEA RDX,[RBP + -0x51]
MOV RAX,qword ptr [RBP + -0x68]
LEA RCX,[0x132072]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104bb5:
CALL 0x001062dc
LEA RAX,[RBP + -0x51]
MOV RDI,RAX
CALL 0x00106424
NOP
LAB_00104bc7:
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00106258
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x00104c47
JMP 0x00104c42
LAB_00104c42:
CALL 0x00104840
LAB_00104c47:
MOV RAX,qword ptr [RBP + -0x68]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
string *in_RSI;
long in_FS_OFFSET;
allocator local_59;
allocator *local_58;
allocator *local_50;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"^[aeiouAEIOU][A-Za-z0-9_]*",0x10);
/* try { // try from 00104b5b to 00104b5f has its CatchHandler @ 00104c10 */
bVar1 = std::
regex_search<std::char_traits<char>,std::allocator<char>,char,std::regex_traits<char>>
(in_RSI,local_48,0);
if (bVar1) {
local_58 = &local_59;
/* try { // try from 00104b83 to 00104b87 has its CatchHandler @ 00104be4 */
std::string::string<std::allocator<char>>(param_1,"Valid",&local_59);
std::__new_allocator<char>::~__new_allocator((__new_allocator<char> *)&local_59);
}
else {
local_50 = &local_59;
/* try { // try from 00104bb5 to 00104bb9 has its CatchHandler @ 00104bfa */
std::string::string<std::allocator<char>>(param_1,"Invalid",&local_59);
std::__new_allocator<char>::~__new_allocator((__new_allocator<char> *)&local_59);
}
std::regex::~basic_regex(local_48);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,945 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& string) {
std::regex regex("^[aeiouAEIOU][A-Za-z0-9_]*");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
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 $0x58,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
mov %r13,%rdi
callq 4730 <_ZNSt6localeC1Ev@plt>
movl $0x10,(%rsp)
lea 0x8(%rsp),%r12
mov %r13,%rsi
mov %r12,%rdi
callq 44d0 <_ZNSt6localeC1ERKS_@plt>
lea 0x10(%rsp),%rdi
mov (%rsp),%r8d
mov %r12,%rcx
lea 0x14e4d(%rip),%rdx
lea -0x1a(%rdx),%rsi
callq 1819d <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
jmp 48b2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x89>
endbr64
mov %rax,%rbx
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
lea 0x20(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov %rbx,%rdi
callq 46c0 <_Unwind_Resume@plt>
lea 0x20(%rsp),%r12
mov %r12,%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x0(%rbp),%rdi
mov %rdi,%rsi
add 0x8(%rbp),%rsi
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
mov %rsp,%rcx
mov $0x0,%r8d
mov %r12,%rdx
callq cce2 <_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>
mov %eax,%ebp
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 4910 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xe7>
callq 4570 <_ZdlPv@plt>
test %bpl,%bpl
jne 4957 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x12e>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
lea 0x14dbc(%rip),%rdx
lea -0x7(%rdx),%rsi
mov %rbx,%rdi
callq 5858 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
jmp 4971 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x148>
endbr64
mov %rax,%rbx
mov 0x20(%rsp),%rdi
test %rdi,%rdi
je 4947 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x11e>
callq 4570 <_ZdlPv@plt>
mov %rsp,%rdi
callq 57d4 <_ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED1Ev>
mov %rbx,%rdi
callq 46c0 <_Unwind_Resume@plt>
lea 0x10(%rbx),%rax
mov %rax,(%rbx)
lea 0x14d72(%rip),%rdx
lea -0x5(%rdx),%rsi
mov %rbx,%rdi
callq 5858 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
mov 0x18(%rsp),%rbp
test %rbp,%rbp
je 4994 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16b>
cmpq $0x0,0x1a645(%rip)
je 49bc <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x193>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%rbp)
cmp $0x1,%eax
je 49c7 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19e>
lea 0x8(%rsp),%rdi
callq 4660 <_ZNSt6localeD1Ev@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 4a0d <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1e4>
mov %rbx,%rax
add $0x58,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov 0x8(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%rbp)
jmp 498f <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x166>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x10(%rax)
cmpq $0x0,0x1a5ef(%rip)
je 49f6 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1cd>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%rbp)
cmp $0x1,%eax
jne 4994 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16b>
mov 0x0(%rbp),%rax
mov %rbp,%rdi
callq *0x18(%rax)
jmp 4994 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x16b>
mov 0xc(%rbp),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%rbp)
jmp 49e5 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1bc>
endbr64
mov %rax,%rbx
jmpq 4947 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x11e>
callq 45d0 <__stack_chk_fail@plt>
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_70]
lea rdi, [rbp+var_68]; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov ecx, 10h
lea rdx, aAeiouaeiouAZaZ+1Ah; ""
lea rsi, [rdx-1Ah]
mov rdi, r12
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
jmp short loc_4880
endbr64
mov rbx, rax
mov rdi, [rbp+var_58]
test rdi, rdi
jz short loc_485B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_485B:
lea rdi, [rbp+var_68]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz short loc_4878
call ___stack_chk_fail
loc_4878:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_4880:
mov rdi, [r14]
mov rsi, rdi
add rsi, [r14+8]
mov [rbp+var_50], 0
mov [rbp+var_48], 0
mov [rbp+var_40], 0
mov [rbp+var_38], 0
lea rcx, [rbp+var_70]
lea rdx, [rbp+var_50]
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)
mov r12d, eax
add rsp, 10h
mov rdi, [rbp+var_50]; void *
test rdi, rdi
jz short loc_48E5
mov rsi, [rbp+var_40]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_48E5:
test r12b, r12b
jnz short loc_4937
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aInvalid+7; ""
lea rsi, [rdx-7]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
jmp short loc_4951
endbr64
mov rbx, rax
lea rdi, [rbp+var_50]
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_4916:
lea rdi, [rbp+var_70]
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; std::basic_regex<char,std::regex_traits<char>>::~basic_regex()
mov rax, [rbp+var_28]
sub rax, fs:28h
jz loc_49F2
call ___stack_chk_fail
loc_4937:
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aValid+5; ""
lea rsi, [rdx-5]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
loc_4951:
mov rax, [rbp+var_58]
mov rdi, rax
test rax, rax
jz short loc_498B
lea rcx, [rax+8]
mov rdx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz short loc_49B1
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz short loc_49D4
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4986:
cmp eax, 1
jz short loc_49DF
loc_498B:
lea rdi, [rbp+var_68]; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz short loc_49FA
mov rax, rbx
lea rsp, [rbp-18h]
pop rbx
pop r12
pop r14
pop rbp
retn
loc_49B1:
mov r12, rdi
mov dword ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 0
mov rax, [rdi]
call qword ptr [rax+10h]
mov rdi, r12
mov rax, [r12]
call qword ptr [rax+18h]
jmp short loc_498B
loc_49D4:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp short loc_4986
loc_49DF:
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 short loc_498B
endbr64
mov rbx, rax
jmp loc_4916
loc_49F2:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_49FA:
call ___stack_chk_fail | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x70]
LEA RDI,[RBP + -0x68]
CALL 0x001046f0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV ECX,0x10
LEA RDX,[0x1195f9]
LEA RSI,[RDX + -0x1a]
MOV RDI,R12
LAB_0010483f:
CALL 0x0011689c
JMP 0x00104880
LAB_00104880:
MOV RDI,qword ptr [R14]
MOV RSI,RDI
ADD RSI,qword ptr [R14 + 0x8]
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
LEA RCX,[RBP + -0x70]
LEA RDX,[RBP + -0x50]
SUB RSP,0x8
PUSH 0x0
MOV R9D,0x0
MOV R8D,0x0
LAB_001048c4:
CALL 0x0010db35
MOV R12D,EAX
ADD RSP,0x10
MOV RDI,qword ptr [RBP + -0x50]
TEST RDI,RDI
JZ 0x001048e5
MOV RSI,qword ptr [RBP + -0x40]
SUB RSI,RDI
CALL 0x00104540
LAB_001048e5:
TEST R12B,R12B
JNZ 0x00104937
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x119607]
LEA RSI,[RDX + -0x7]
MOV RDI,RBX
LAB_001048ff:
CALL 0x00105abc
JMP 0x00104951
LAB_00104937:
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
LEA RDX,[0x1195ff]
LEA RSI,[RDX + -0x5]
MOV RDI,RBX
CALL 0x00105abc
LAB_00104951:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x0010498b
LEA RCX,[RAX + 0x8]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x001049b1
CMP byte ptr [0x0011f460],0x0
JZ 0x001049d4
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104986:
CMP EAX,0x1
JZ 0x001049df
LAB_0010498b:
LEA RDI,[RBP + -0x68]
CALL 0x00104630
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001049fa
MOV RAX,RBX
LEA RSP,[RBP + -0x18]
POP RBX
POP R12
POP R14
POP RBP
RET
LAB_001049b1:
MOV R12,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x0
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
MOV RDI,R12
MOV RAX,qword ptr [R12]
CALL qword ptr [RAX + 0x18]
JMP 0x0010498b
LAB_001049d4:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104986
LAB_001049df:
CALL 0x00105938
JMP 0x0010498b
LAB_001049fa:
CALL 0x00104580 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int8 local_68;
_Sp_counted_base<(_Lock_policy)2> *local_60;
void *local_58;
int8 local_50;
long local_48;
int8 local_40;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_70);
local_68 = 0;
local_60 = (_Sp_counted_base<(_Lock_policy)2> *)0x0;
/* try { // try from 0010483f to 00104843 has its CatchHandler @ 00104846 */
std::regex::_M_compile(local_78,"^[aeiouAEIOU][A-Za-z0-9_]*","",0x10);
local_58 = (void *)0x0;
local_50 = 0;
local_48 = 0;
local_40 = 0;
/* try { // try from 001048c4 to 001048c8 has its CatchHandler @ 00104906 */
bVar3 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)*in_RSI,(__normal_iterator)*in_RSI + (int)in_RSI[1],
(match_results *)&local_58,local_78,0,0,false);
if (local_58 != (void *)0x0) {
operator_delete(local_58,local_48 - (long)local_58);
}
if (bVar3) {
*(string **)param_1 = param_1 + 0x10;
std::string::_M_construct<char_const*>((char *)param_1,"Valid",0x1195ff);
}
else {
*(string **)param_1 = param_1 + 0x10;
/* try { // try from 001048ff to 00104950 has its CatchHandler @ 001049e6 */
std::string::_M_construct<char_const*>((char *)param_1,"Invalid",0x119607);
}
p_Var2 = local_60;
if (local_60 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = local_60 + 8;
if (*(long *)(local_60 + 8) == 0x100000001) {
*(int4 *)(local_60 + 8) = 0;
*(int4 *)(local_60 + 0xc) = 0;
(**(code **)(*(long *)local_60 + 0x10))();
(**(code **)(*(long *)p_Var2 + 0x18))(p_Var2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar4 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)(local_60 + 8);
*(int *)(local_60 + 8) = iVar4 + -1;
}
if (iVar4 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold(local_60);
}
}
}
std::locale::~locale(local_70);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
|
2,946 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& string) {
std::regex regex("^[aeiouAEIOU][A-Za-z0-9_]*");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp
mov %r13,%rdi
callq 4750 <_ZNSt6localeC1Ev@plt>
mov %r13,%rsi
mov %rbp,%rdi
movl $0x10,(%rsp)
callq 44f0 <_ZNSt6localeC1ERKS_@plt>
lea 0x15b20(%rip),%rdx
mov (%rsp),%r8d
mov %rbp,%rcx
lea 0x10(%rsp),%rdi
lea -0x1a(%rdx),%rsi
callq 19540 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %r13,%rdi
mov %rsp,%r14
callq 4680 <_ZNSt6localeD1Ev@plt>
mov (%rbx),%rdi
mov 0x8(%rbx),%rsi
xor %r8d,%r8d
movq $0x0,0x20(%rsp)
mov %r14,%rcx
mov %r13,%rdx
movq $0x0,0x28(%rsp)
add %rdi,%rsi
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
callq caf0 <_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>
mov 0x20(%rsp),%rdi
mov %eax,%ebx
test %rdi,%rdi
je 4c1e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xbe>
callq 4590 <_ZdlPv@plt>
lea 0x10(%r12),%rax
test %bl,%bl
je 4c90 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov %rax,(%r12)
lea 0x15aa5(%rip),%rdx
mov %r12,%rdi
lea -0x5(%rdx),%rsi
callq 5a80 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
mov 0x18(%rsp),%r13
test %r13,%r13
je 4c68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x108>
mov 0x1c361(%rip),%rbx
test %rbx,%rbx
je 4cb0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x150>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r13)
cmp $0x1,%eax
je 4cc0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x160>
nopl 0x0(%rax)
mov %rbp,%rdi
callq 4680 <_ZNSt6localeD1Ev@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 4cfd <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x19d>
add $0x50,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov %rax,(%r12)
lea 0x15a44(%rip),%rdx
mov %r12,%rdi
lea -0x7(%rdx),%rsi
callq 5a80 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag>
jmp 4c3e <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xde>
nopl 0x0(%rax)
mov 0x8(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r13)
cmp $0x1,%eax
jne 4c68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x108>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 4cf0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x190>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r13)
cmp $0x1,%eax
jne 4c68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x108>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x18(%rax)
jmpq 4c68 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x108>
xchg %ax,%ax
mov 0xc(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r13)
jmp 4cda <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x17a>
callq 45f0 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 47c3 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 47e2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1f>
endbr64
mov %rax,%rbp
jmpq 47d2 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0xf>
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
mov r14, rsi
push r13
lea r13, [rbp+var_70]
push r12
lea r12, [rbp+var_68]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, aAeiouaeiouAZaZ+1Ah; ""
pxor xmm0, xmm0
mov rdi, r13
mov ecx, 10h
lea rsi, [rdx-1Ah]
movaps [rbp+var_60], xmm0
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEE10_M_compileEPKcS5_NSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::_M_compile(char const*,char const*,std::regex_constants::syntax_option_type)
pxor xmm0, xmm0
sub rsp, 8
mov rdi, [r14]
mov rsi, [r14+8]
movaps xmmword ptr [rbp+var_50], xmm0
lea rax, [rbp+var_50]
xor r9d, r9d
xor r8d, r8d
movaps [rbp+var_40], xmm0
add rsi, rdi
mov rcx, r13
mov rdx, rax
push 0
mov r14, rax
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 rdi, [rbp+var_50]; void *
mov r13d, eax
pop rax
pop rdx
test rdi, rdi
jz short loc_4C06
mov rsi, qword ptr [rbp+var_40]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4C06:
test r13b, r13b
jz loc_4CA0
lea rax, [rbx+10h]
mov dword ptr [rbx+10h], 696C6156h
mov [rbx], rax
mov byte ptr [rbx+14h], 64h ; 'd'
mov qword ptr [rbx+8], 5
mov byte ptr [rbx+15h], 0
loc_4C2D:
mov rax, qword ptr [rbp+var_60+8]
mov rdi, rax
test rax, rax
jz short loc_4C73
mov rdx, [rax+8]
lea rcx, [rax+8]
mov rax, 100000001h
cmp rdx, rax
jz loc_4CD0
cmp cs:__libc_single_threaded@GLIBC_2_32, 0
jz loc_4CF0
mov eax, [rdi+8]
lea edx, [rax-1]
mov [rdi+8], edx
loc_4C6A:
cmp eax, 1
jz loc_4D00
loc_4C73:
mov rdi, r12; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rbp+var_28]
sub rax, fs:28h
jnz loc_4D0A
lea rsp, [rbp-20h]
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop rbp
retn
loc_4CA0:
lea rax, [rbx+10h]
mov dword ptr [rbx+10h], 61766E49h
mov [rbx], rax
mov dword ptr [rbx+13h], 64696C61h
mov qword ptr [rbx+8], 7
mov byte ptr [rbx+17h], 0
jmp loc_4C2D
loc_4CD0:
mov rax, [rdi]
mov r13, rdi
mov qword ptr [rdi+8], 0
call qword ptr [rax+10h]
mov rax, [r13+0]
mov rdi, r13
call qword ptr [rax+18h]
jmp short loc_4C73
loc_4CF0:
mov eax, 0FFFFFFFFh
lock xadd [rcx], eax
jmp loc_4C6A
loc_4D00:
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_4C73
loc_4D0A:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
jmp loc_378E | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v4; // rsi
long long v5; // rsi
char v6; // r13
long long v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v12; // rax
_BYTE v13[8]; // [rsp+0h] [rbp-70h] BYREF
_BYTE v14[8]; // [rsp+8h] [rbp-68h] BYREF
__int128 v15; // [rsp+10h] [rbp-60h]
void *v16[2]; // [rsp+20h] [rbp-50h] BYREF
__int128 v17; // [rsp+30h] [rbp-40h]
unsigned long long v18; // [rsp+48h] [rbp-28h]
v18 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v14);
v15 = 0LL;
std::basic_regex<char,std::regex_traits<char>>::_M_compile(v13, "^[aeiouAEIOU][A-Za-z0-9_]*", "", 16LL);
v3 = *a2;
v4 = a2[1];
*(_OWORD *)v16 = 0LL;
v17 = 0LL;
v5 = v3 + v4;
v6 = 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>>(
v3,
v5,
(unsigned int)v16,
(unsigned int)v13,
0,
0,
0);
if ( v16[0] )
{
v5 = v17 - (unsigned long long)v16[0];
operator delete(v16[0], v17 - (unsigned long long)v16[0]);
}
if ( v6 )
{
*(_DWORD *)(a1 + 16) = 1768710486;
*(_QWORD *)a1 = a1 + 16;
*(_BYTE *)(a1 + 20) = 100;
*(_QWORD *)(a1 + 8) = 5LL;
*(_BYTE *)(a1 + 21) = 0;
}
else
{
strcpy((char *)(a1 + 16), "Invalid");
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 7LL;
}
v7 = *((_QWORD *)&v15 + 1);
if ( *((_QWORD *)&v15 + 1) )
{
v8 = *(_QWORD *)(*((_QWORD *)&v15 + 1) + 8LL);
v9 = (volatile signed __int32 *)(*((_QWORD *)&v15 + 1) + 8LL);
if ( v8 == 0x100000001LL )
{
v12 = **((_QWORD **)&v15 + 1);
*(_QWORD *)(*((_QWORD *)&v15 + 1) + 8LL) = 0LL;
(*(void ( **)(long long, long long, long long, volatile signed __int32 *))(v12 + 16))(
v7,
v5,
0x100000001LL,
v9);
(*(void ( **)(long long))(*(_QWORD *)v7 + 24LL))(v7);
}
else
{
if ( _libc_single_threaded )
{
v10 = *(_DWORD *)(*((_QWORD *)&v15 + 1) + 8LL);
v8 = (unsigned int)(v10 - 1);
*(_DWORD *)(*((_QWORD *)&v15 + 1) + 8LL) = v8;
}
else
{
v10 = _InterlockedExchangeAdd(v9, 0xFFFFFFFF);
}
if ( v10 == 1 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release_last_use_cold(v7, v5, v8, v9);
}
}
std::locale::~locale((std::locale *)v14);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
MOV R14,RSI
PUSH R13
LEA R13,[RBP + -0x70]
PUSH R12
LEA R12,[RBP + -0x68]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CALL 0x001036d0
LEA RDX,[0x1185f9]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,[RDX + -0x1a]
MOVAPS xmmword ptr [RBP + -0x60],XMM0
LAB_00104bb3:
CALL 0x001175a0
PXOR XMM0,XMM0
SUB RSP,0x8
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x8]
MOVAPS xmmword ptr [RBP + -0x50],XMM0
LEA RAX,[RBP + -0x50]
XOR R9D,R9D
XOR R8D,R8D
MOVAPS xmmword ptr [RBP + -0x40],XMM0
ADD RSI,RDI
MOV RCX,R13
MOV RDX,RAX
PUSH 0x0
MOV R14,RAX
LAB_00104be7:
CALL 0x0010ce10
MOV RDI,qword ptr [RBP + -0x50]
MOV R13D,EAX
POP RAX
POP RDX
TEST RDI,RDI
JZ 0x00104c06
MOV RSI,qword ptr [RBP + -0x40]
SUB RSI,RDI
CALL 0x00103540
LAB_00104c06:
TEST R13B,R13B
JZ 0x00104ca0
LEA RAX,[RBX + 0x10]
MOV dword ptr [RBX + 0x10],0x696c6156
MOV qword ptr [RBX],RAX
MOV byte ptr [RBX + 0x14],0x64
MOV qword ptr [RBX + 0x8],0x5
MOV byte ptr [RBX + 0x15],0x0
LAB_00104c2d:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,RAX
TEST RAX,RAX
JZ 0x00104c73
MOV RDX,qword ptr [RAX + 0x8]
LEA RCX,[RAX + 0x8]
MOV RAX,0x100000001
CMP RDX,RAX
JZ 0x00104cd0
CMP byte ptr [0x0011e460],0x0
JZ 0x00104cf0
MOV EAX,dword ptr [RDI + 0x8]
LEA EDX,[RAX + -0x1]
MOV dword ptr [RDI + 0x8],EDX
LAB_00104c6a:
CMP EAX,0x1
JZ 0x00104d00
LAB_00104c73:
MOV RDI,R12
CALL 0x00103620
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00104d0a
LEA RSP,[RBP + -0x20]
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP RBP
RET
LAB_00104ca0:
LEA RAX,[RBX + 0x10]
MOV dword ptr [RBX + 0x10],0x61766e49
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x13],0x64696c61
MOV qword ptr [RBX + 0x8],0x7
MOV byte ptr [RBX + 0x17],0x0
JMP 0x00104c2d
LAB_00104cd0:
MOV RAX,qword ptr [RDI]
MOV R13,RDI
MOV qword ptr [RDI + 0x8],0x0
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R13]
MOV RDI,R13
CALL qword ptr [RAX + 0x18]
JMP 0x00104c73
LAB_00104cf0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RCX],EAX
JMP 0x00104c6a
LAB_00104d00:
CALL 0x00105fb0
JMP 0x00104c73
LAB_00104d0a:
CALL 0x00103580 | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int8 *in_RSI;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
int local_58 [16];
int local_48 [16];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
std::locale::locale(local_70);
local_68 = (int [16])0x0;
/* try { // try from 00104bb3 to 00104bb7 has its CatchHandler @ 00104d1b */
std::regex::_M_compile(local_78,"^[aeiouAEIOU][A-Za-z0-9_]*","",0x10);
local_58 = (int [16])0x0;
local_48 = (int [16])0x0;
/* try { // try from 00104be7 to 00104beb has its CatchHandler @ 00104d0f */
bVar3 = std::__detail::
__regex_algo_impl<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,char,std::regex_traits<char>>
((__normal_iterator)*in_RSI,(int)in_RSI[1] + (__normal_iterator)*in_RSI,
(match_results *)local_58,local_78,0,0,false);
if ((void *)local_58._0_8_ != (void *)0x0) {
operator_delete((void *)local_58._0_8_,local_48._0_8_ - local_58._0_8_);
}
if (bVar3) {
*(int4 *)(param_1 + 0x10) = 0x696c6156;
*(string **)param_1 = param_1 + 0x10;
param_1[0x14] = (string)0x64;
*(int8 *)(param_1 + 8) = 5;
param_1[0x15] = (string)0x0;
}
else {
*(int4 *)(param_1 + 0x10) = 0x61766e49;
*(string **)param_1 = param_1 + 0x10;
*(int4 *)(param_1 + 0x13) = 0x64696c61;
*(int8 *)(param_1 + 8) = 7;
param_1[0x17] = (string)0x0;
}
uVar2 = local_68._8_8_;
if ((_Sp_counted_base<(_Lock_policy)2> *)local_68._8_8_ !=
(_Sp_counted_base<(_Lock_policy)2> *)0x0) {
p_Var1 = (_Sp_counted_base<(_Lock_policy)2> *)(local_68._8_8_ + 8);
if (*(long *)(local_68._8_8_ + 8) == 0x100000001) {
*(int8 *)(local_68._8_8_ + 8) = 0;
(**(code **)(*(long *)local_68._8_8_ + 0x10))();
(**(code **)(*(long *)uVar2 + 0x18))(uVar2);
}
else {
if (__libc_single_threaded == '\0') {
LOCK();
iVar4 = *(int *)p_Var1;
*(int *)p_Var1 = *(int *)p_Var1 + -1;
UNLOCK();
}
else {
iVar4 = *(int *)(local_68._8_8_ + 8);
*(int *)(local_68._8_8_ + 8) = iVar4 + -1;
}
if (iVar4 == 1) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release_last_use_cold
((_Sp_counted_base<(_Lock_policy)2> *)local_68._8_8_);
}
}
}
std::locale::~locale(local_70);
if (local_30 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,947 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& string) {
std::regex regex("^[aeiouAEIOU][A-Za-z0-9_]*");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("annie") == "Valid");
assert(func0("dawood") == "Invalid");
assert(func0("Else") == "Valid");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r13
lea 0x8(%rsp),%rbp
mov %r13,%rdi
callq 47b0 <_ZNSt6localeC1Ev@plt>
mov %r13,%rsi
mov %rbp,%rdi
movl $0x10,(%rsp)
callq 4530 <_ZNSt6localeC1ERKS_@plt>
lea 0x161e0(%rip),%rdx
mov (%rsp),%r8d
mov %rbp,%rcx
lea 0x10(%rsp),%rdi
lea -0x1a(%rdx),%rsi
callq 19990 <_ZNSt8__detail13__compile_nfaINSt7__cxx1112regex_traitsIcEEPKcEENSt9enable_ifIXsrNS_20__is_contiguous_iterIT0_EE5valueESt10shared_ptrIKNS_4_NFAIT_EEEE4typeES8_S8_RKNSC_11locale_typeENSt15regex_constants18syntax_option_typeE>
mov %r13,%rdi
mov %rsp,%r14
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov (%rbx),%rdi
mov 0x8(%rbx),%rsi
pxor %xmm0,%xmm0
xor %r8d,%r8d
mov %r14,%rcx
mov %r13,%rdx
movaps %xmm0,0x20(%rsp)
add %rdi,%rsi
movaps %xmm0,0x30(%rsp)
callq cf80 <_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>
mov 0x20(%rsp),%rdi
mov %eax,%ebx
test %rdi,%rdi
je 5578 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xa8>
callq 45e0 <_ZdlPv@plt>
lea 0x10(%r12),%rax
test %bl,%bl
je 5600 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x130>
mov %rax,(%r12)
movl $0x696c6156,0x10(%r12)
movb $0x64,0x4(%rax)
movq $0x5,0x8(%r12)
movb $0x0,0x15(%r12)
mov 0x18(%rsp),%r13
test %r13,%r13
je 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov 0x1ca16(%rip),%rbx
test %rbx,%rbx
je 5630 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x160>
mov $0xffffffff,%eax
lock xadd %eax,0x8(%r13)
cmp $0x1,%eax
je 5640 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x170>
nopw 0x0(%rax,%rax,1)
mov %rbp,%rdi
callq 46e0 <_ZNSt6localeD1Ev@plt>
mov 0x48(%rsp),%rax
xor %fs:0x28,%rax
jne 5685 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1b5>
add $0x50,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax)
mov $0x696c,%edx
mov %rax,(%r12)
movl $0x61766e49,0x10(%r12)
mov %dx,0x4(%rax)
movb $0x64,0x6(%rax)
movq $0x7,0x8(%r12)
movb $0x0,0x17(%r12)
jmpq 55a1 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0xd1>
xchg %ax,%ax
mov 0x8(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0x8(%r13)
cmp $0x1,%eax
jne 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x10(%rax)
test %rbx,%rbx
je 5678 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1a8>
mov $0xffffffff,%eax
lock xadd %eax,0xc(%r13)
cmp $0x1,%eax
jne 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
mov 0x0(%r13),%rax
mov %r13,%rdi
callq *0x18(%rax)
jmpq 55d0 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x100>
nopw 0x0(%rax,%rax,1)
mov 0xc(%r13),%eax
lea -0x1(%rax),%edx
mov %edx,0xc(%r13)
jmp 565a <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x18a>
callq 4640 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 4836 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold>
endbr64
mov %rax,%r12
jmpq 4855 <_Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE.cold+0x1f>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
| _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 2B8h
mov rax, fs:28h
mov [rsp+2E8h+var_40], rax
xor eax, eax
lea r14, [rsp+2E8h+var_2A0]
mov rdi, r14; this
call __ZNSt6localeC1Ev; std::locale::locale(void)
lea rdx, aAeiouaeiouAZaZ+1Ah; ""
pxor xmm0, xmm0
lea rdi, [rsp+2E8h+var_1D8]
mov r8d, 10h
mov rcx, r14
lea rsi, [rdx-1Ah]
movaps [rsp+2E8h+var_298], xmm0
call _ZNSt8__detail9_CompilerINSt7__cxx1112regex_traitsIcEEEC2EPKcS6_RKSt6localeNSt15regex_constants18syntax_option_typeE; std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(char const*,char const*,std::locale const&,std::regex_constants::syntax_option_type)
movdqa xmm0, [rsp+2E8h+var_D8]
mov rdi, qword ptr [rsp+2E8h+var_298+8]
pxor xmm1, xmm1
movaps [rsp+2E8h+var_D8], xmm1
movaps [rsp+2E8h+var_298], xmm0
test rdi, rdi
jz short loc_5CFE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5CFE:
mov rdi, [rsp+2E8h+var_A8]
mov [rsp+2E8h+var_2A8], 10h
test rdi, rdi
jz short loc_5D64
mov rax, [rsp+2E8h+var_60]
mov rbp, [rsp+2E8h+var_80]
lea r12, [rax+8]
cmp rbp, r12
jnb short loc_5D4F
nop dword ptr [rax+00h]
loc_5D30:
mov rdi, [rbp+0]; void *
mov esi, 1F8h; unsigned __int64
add rbp, 8
call __ZdlPvm; operator delete(void *,ulong)
cmp rbp, r12
jb short loc_5D30
mov rdi, [rsp+2E8h+var_A8]; void *
loc_5D4F:
mov rax, [rsp+2E8h+var_A0]
lea rsi, ds:0[rax*8]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5D64:
lea rdi, [rsp+2E8h+var_C8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, qword ptr [rsp+2E8h+var_D8+8]
test rdi, rdi
jz short loc_5D83
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5D83:
lea rdi, [rsp+2E8h+var_108]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
pxor xmm0, xmm0
mov r13, [r15]
mov rbp, [r15+8]
mov rax, qword ptr [rsp+2E8h+var_298]
movaps [rsp+2E8h+var_288], xmm0
movaps [rsp+2E8h+var_278], xmm0
test rax, rax
jz loc_6210
mov rax, [rax+28h]
lea r15, [rsp+2E8h+var_288]
lea r12, [rsp+2E8h+var_268]
mov qword ptr [rsp+2E8h+var_278+8], r13
mov rdx, r12
mov rdi, r15
mov byte ptr [rsp+2E8h+var_258], 0
lea esi, [rax+3]
lea rax, [rsp+2E8h+var_2A8]
movaps [rsp+2E8h+var_268], xmm0
mov [rsp+2E8h+var_2D8], rax
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EE14_M_fill_assignEmRKSC_; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::_M_fill_assign(ulong,std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)
mov rcx, qword ptr [rsp+2E8h+var_298]
add rbp, r13
movq xmm1, r13
mov rsi, 0AAAAAAAAAAAAAAABh
movq xmm2, rbp
pxor xmm0, xmm0
mov rdx, [rcx+40h]
sub rdx, [rcx+38h]
punpcklqdq xmm1, xmm2
mov [rsp+2E8h+var_230], rcx
mov rax, rdx
mov [rsp+2E8h+var_228], r15
sar rax, 4
movaps [rsp+2E8h+var_268], xmm0
imul rax, rsi
lea rsi, [rsp+2E8h+var_2A8]
test byte ptr [rsp+2E8h+var_2A8+1], 4
movaps [rsp+2E8h+var_258], xmm0
mov [rsp+2E8h+var_2D8], rsi
mov [rsp+2E8h+var_238], rsi
mov [rsp+2E8h+n], rax
movaps [rsp+2E8h+var_248], xmm1
jnz loc_6038
test rdx, rdx
js loc_638F
mov [rsp+2E8h+var_210], 0
movups xmmword ptr [rsp+2E8h+var_220], xmm0
jz loc_6330
shl rax, 4
mov rdi, rax; unsigned __int64
mov [rsp+2E8h+n], rax
call __Znwm; operator new(ulong)
mov rdx, [rsp+2E8h+n]
mov [rsp+2E8h+var_220], rax
add rdx, rax
mov [rsp+2E8h+var_210], rdx
xchg ax, ax
loc_5EC0:
mov qword ptr [rax], 0
add rax, 10h
mov dword ptr [rax-8], 0
cmp rax, rdx
jnz short loc_5EC0
mov rcx, [rsp+2E8h+var_230]
mov rsi, [rsp+2E8h+var_228]
loc_5EE7:
mov rax, [rcx+20h]
mov rdi, r12
mov [rsp+2E8h+var_220+8], rdx
mov qword ptr [rsp+2E8h+var_208+8], 0
mov qword ptr [rsp+2E8h+var_208], rax
mov rax, qword ptr [rsp+2E8h+var_248]
mov dword ptr [rsp+2E8h+var_1F8], 0
mov qword ptr [rsp+2E8h+var_258+8], rax
mov byte ptr [rsp+2E8h+var_1F8+4], 0
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 rdx, qword ptr [rsp+2E8h+var_208]
mov esi, 1
mov rdi, r12
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb1EE6_M_dfsENSH_11_Match_modeEl; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_Match_mode,long)
cmp byte ptr [rsp+2E8h+var_1F8+4], 0
jnz loc_6280
mov eax, dword ptr [rsp+2E8h+var_1F8]
test al, 40h
jnz short loc_5FDD
or al, 80h
mov dword ptr [rsp+2E8h+var_1F8], eax
jmp short loc_5FCB
loc_5F70:
mov rsi, [rsp+2E8h+var_228]
add rax, 1
mov rdi, r12
mov byte ptr [rsp+2E8h+var_1F8+4], 0
mov qword ptr [rsp+2E8h+var_248], rax
mov qword ptr [rsp+2E8h+var_258+8], rax
mov qword ptr [rsp+2E8h+var_208+8], 0
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 rdx, qword ptr [rsp+2E8h+var_208]
mov esi, 1
mov rdi, r12
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb1EE6_M_dfsENSH_11_Match_modeEl; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_Match_mode,long)
cmp byte ptr [rsp+2E8h+var_1F8+4], 0
jnz loc_6280
loc_5FCB:
mov rax, qword ptr [rsp+2E8h+var_248]
cmp rax, qword ptr [rsp+2E8h+var_248+8]
jnz short loc_5F70
loc_5FDD:
mov rdi, [rsp+2E8h+var_220]; void *
test rdi, rdi
jz short loc_5FFA
mov rsi, [rsp+2E8h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5FFA:
mov rdi, r12
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_6002:
lea rdx, [rsp+2E8h+var_2C8]
mov esi, 3
mov rdi, r15
mov [rsp+2E8h+var_2B8], 0
mov [rsp+2E8h+var_2C0], rbp
mov [rsp+2E8h+var_2C8], rbp
call _ZNSt6vectorINSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS0_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISC_EE14_M_fill_assignEmRKSC_; std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::_M_fill_assign(ulong,std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>> const&)
mov rdi, r15
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_621A
loc_6038:
test rdx, rdx
js loc_63AE
cmp [rsp+2E8h+n], 0
movups xmmword ptr [rsp+2E8h+var_220], xmm0
mov [rsp+2E8h+var_210], 0
jz loc_6358
shl rax, 4
mov rdi, rax; unsigned __int64
mov [rsp+2E8h+n], rax
call __Znwm; operator new(ulong)
mov rdx, [rsp+2E8h+n]
mov [rsp+2E8h+var_220], rax
add rdx, rax
mov [rsp+2E8h+var_210], rdx
nop word ptr [rax+rax+00h]
loc_6090:
mov qword ptr [rax], 0
add rax, 10h
mov dword ptr [rax-8], 0
cmp rax, rdx
jnz short loc_6090
mov rcx, [rsp+2E8h+var_230]
mov rsi, 0AAAAAAAAAAAAAAABh
mov rax, [rcx+40h]
sub rax, [rcx+38h]
sar rax, 4
imul rax, rsi
mov [rsp+2E8h+n], rax
mov rdi, rax; unsigned __int64
loc_60D1:
mov rax, [rcx+20h]
pxor xmm0, xmm0
mov [rsp+2E8h+var_220+8], rdx
mov [rsp+2E8h+var_1F8], 0
mov [rsp+2E8h+var_2D0], rax
movaps [rsp+2E8h+var_208], xmm0
call __Znam; operator new[](ulong)
mov rcx, rax
mov rax, [rsp+2E8h+n]
sub rax, 1
js short loc_611F
mov rdx, [rsp+2E8h+n]; n
mov rdi, rcx; s
xor esi, esi; c
call _memset
mov rcx, rax
loc_611F:
mov rax, [rsp+2E8h+var_2D0]
mov rdi, r12
mov [rsp+2E8h+var_1F0], rcx
mov [rsp+2E8h+var_1E0], 0
mov [rsp+2E8h+var_1E8], rax
mov rax, qword ptr [rsp+2E8h+var_248]
mov qword ptr [rsp+2E8h+var_258+8], rax
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb0EE16_M_main_dispatchENSH_11_Match_modeESt17integral_constantIbLb0EE_constprop_0; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_Match_mode,std::integral_constant<bool,false>) [clone]
mov byte ptr [rsp+2E8h+n], al
test al, al
jnz loc_6380
mov eax, [rsp+2E8h+var_1E0]
test al, 40h
jnz short loc_61B6
or al, 80h
mov [rsp+2E8h+var_1E0], eax
jmp short loc_61A4
loc_6180:
add rax, 1
mov rdi, r12
mov qword ptr [rsp+2E8h+var_248], rax
mov qword ptr [rsp+2E8h+var_258+8], rax
call _ZNSt8__detail9_ExecutorIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaINS5_9sub_matchISB_EEENS5_12regex_traitsIcEELb0EE16_M_main_dispatchENSH_11_Match_modeESt17integral_constantIbLb0EE_constprop_0; std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_Match_mode,std::integral_constant<bool,false>) [clone]
test al, al
jnz loc_6380
loc_61A4:
mov rax, qword ptr [rsp+2E8h+var_248]
cmp rax, qword ptr [rsp+2E8h+var_248+8]
jnz short loc_6180
loc_61B6:
mov rdi, [rsp+2E8h+var_1F0]; void *
test rdi, rdi
jz short loc_61C8
call __ZdaPv; operator delete[](void *)
loc_61C8:
lea rdi, [rsp+2E8h+var_208]
call _ZNSt6vectorISt4pairIlS_INSt7__cxx119sub_matchIN9__gnu_cxx17__normal_iteratorIPKcNS1_12basic_stringIcSt11char_traitsIcESaIcEEEEEEESaISD_EEESaISG_EED2Ev; std::vector<std::pair<long,std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>>>::~vector()
mov rdi, [rsp+2E8h+var_220]; void *
test rdi, rdi
jz short loc_61F2
mov rsi, [rsp+2E8h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_61F2:
mov rdi, r12
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()
cmp byte ptr [rsp+2E8h+n], 0
jnz loc_62A5
jmp loc_6002
loc_6210:
lea rdi, [rsp+2E8h+var_288]
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_621A:
lea rax, [rbx+10h]
mov dword ptr [rbx+10h], 61766E49h
mov [rbx], rax
mov dword ptr [rbx+13h], 64696C61h
mov qword ptr [rbx+8], 7
mov byte ptr [rbx+17h], 0
loc_623B:
mov rdi, qword ptr [rsp+2E8h+var_298+8]
test rdi, rdi
jz short loc_624A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_624A:
mov rdi, r14; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rax, [rsp+2E8h+var_40]
sub rax, fs:28h
jnz loc_638A
add rsp, 2B8h
mov rax, rbx
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_6280:
mov rdi, [rsp+2E8h+var_220]; void *
test rdi, rdi
jz short loc_629D
mov rsi, [rsp+2E8h+var_210]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_629D:
mov rdi, r12
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_62A5:
mov rcx, qword ptr [rsp+2E8h+var_288]
mov rdx, qword ptr [rsp+2E8h+var_288+8]
mov rax, rcx
cmp rcx, rdx
jz short loc_62D6
nop word ptr [rax+rax+00000000h]
loc_62C0:
cmp byte ptr [rax+10h], 0
jnz short loc_62CD
mov [rax+8], rbp
mov [rax], rbp
loc_62CD:
add rax, 18h
cmp rdx, rax
jnz short loc_62C0
loc_62D6:
mov [rdx-30h], r13
lea rax, [rdx-18h]
lea rsi, [rdx-30h]
mov rdx, [rcx]
mov rdi, r15
mov [rsi+8], rdx
cmp rdx, r13
mov rdx, [rcx+8]
setnz byte ptr [rsi+10h]
mov [rax], rdx
cmp rdx, rbp
mov [rax+8], rbp
setnz byte ptr [rax+10h]
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 rax, [rbx+10h]
mov dword ptr [rbx+10h], 696C6156h
mov [rbx], rax
mov byte ptr [rbx+14h], 64h ; 'd'
mov qword ptr [rbx+8], 5
mov byte ptr [rbx+15h], 0
jmp loc_623B
loc_6330:
mov [rsp+2E8h+var_220], 0
mov rsi, r15
xor edx, edx
mov [rsp+2E8h+var_210], 0
jmp loc_5EE7
loc_6358:
mov [rsp+2E8h+var_220], 0
xor edx, edx
mov rdi, rax
mov [rsp+2E8h+var_210], 0
jmp loc_60D1
loc_6380:
mov byte ptr [rsp+2E8h+n], 1
jmp loc_61B6
loc_638A:
call ___stack_chk_fail
loc_638F:
mov rax, [rsp+2E8h+var_40]
sub rax, fs:28h
jnz short loc_63CD
lea rdi, aCannotCreateSt_0; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_63AE:
mov rax, [rsp+2E8h+var_40]
sub rax, fs:28h
jnz short loc_63D2
lea rdi, aCannotCreateSt_0; "cannot create std::vector larger than m"...
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_63CD:
call ___stack_chk_fail
loc_63D2:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE_cold; func0(std::string const&) [clone]
endbr64
mov rbx, rax
jmp loc_47FF
endbr64
mov rbx, rax
jmp loc_47D2
endbr64
mov rbx, rax
jmp loc_483B
endbr64
mov rbx, rax
jmp loc_4855
endbr64
mov rbx, rax
jmp loc_4862
endbr64
mov rbx, rax
jmp loc_486F | long long func0(long long a1, unsigned long long *a2)
{
__m128i v3; // xmm0
long long v4; // rdi
void *v5; // rdi
void **v6; // rbp
unsigned long long v7; // r12
void *v8; // rdi
unsigned long long v9; // r13
unsigned long long v10; // rbp
long long v11; // rax
long long v12; // rcx
unsigned long long v13; // rbp
long long v14; // rdx
unsigned long long v15; // rax
_QWORD *v16; // rax
_QWORD *v17; // rdx
__int128 *v18; // rsi
unsigned long long v19; // rax
int v20; // eax
_QWORD *v21; // rax
_QWORD *v22; // rdx
unsigned long long v23; // rdi
long long v24; // rax
void *v25; // rcx
int v26; // eax
_QWORD *v28; // rcx
__int128 i; // rax
long long v30; // rsi
bool v31; // zf
unsigned long long n; // [rsp+8h] [rbp-2E0h]
size_t nb; // [rsp+8h] [rbp-2E0h]
size_t nc; // [rsp+8h] [rbp-2E0h]
char na; // [rsp+8h] [rbp-2E0h]
long long v36; // [rsp+18h] [rbp-2D0h]
_QWORD v37[4]; // [rsp+20h] [rbp-2C8h] BYREF
int v38; // [rsp+40h] [rbp-2A8h] BYREF
char v39[8]; // [rsp+48h] [rbp-2A0h] BYREF
__m128i v40; // [rsp+50h] [rbp-298h]
__int128 v41; // [rsp+60h] [rbp-288h] BYREF
__int128 v42; // [rsp+70h] [rbp-278h]
__int128 v43; // [rsp+80h] [rbp-268h] BYREF
__int128 v44; // [rsp+90h] [rbp-258h]
__m128i v45; // [rsp+A0h] [rbp-248h]
int *v46; // [rsp+B0h] [rbp-238h]
long long v47; // [rsp+B8h] [rbp-230h]
__int128 *v48; // [rsp+C0h] [rbp-228h]
void *v49[2]; // [rsp+C8h] [rbp-220h]
char *v50; // [rsp+D8h] [rbp-210h]
__int128 v51; // [rsp+E0h] [rbp-208h] BYREF
long long v52; // [rsp+F0h] [rbp-1F8h]
void *v53; // [rsp+F8h] [rbp-1F0h]
long long v54; // [rsp+100h] [rbp-1E8h]
int v55; // [rsp+108h] [rbp-1E0h]
char v56[208]; // [rsp+110h] [rbp-1D8h] BYREF
char v57[48]; // [rsp+1E0h] [rbp-108h] BYREF
__m128i v58; // [rsp+210h] [rbp-D8h] BYREF
char v59[32]; // [rsp+220h] [rbp-C8h] BYREF
void *v60; // [rsp+240h] [rbp-A8h]
long long v61; // [rsp+248h] [rbp-A0h]
unsigned long long v62; // [rsp+268h] [rbp-80h]
long long v63; // [rsp+288h] [rbp-60h]
unsigned long long v64; // [rsp+2A8h] [rbp-40h]
v64 = __readfsqword(0x28u);
std::locale::locale((std::locale *)v39);
v40 = 0LL;
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler(v56, "^[aeiouAEIOU][A-Za-z0-9_]*", "", v39, 16LL);
v3 = _mm_load_si128(&v58);
v4 = v40.m128i_i64[1];
v58 = 0LL;
v40 = v3;
if ( v4 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
v5 = v60;
v38 = 16;
if ( v60 )
{
v6 = (void **)v62;
v7 = v63 + 8;
if ( v62 < v63 + 8 )
{
do
{
v8 = *v6++;
operator delete(v8, 0x1F8uLL);
}
while ( (unsigned long long)v6 < v7 );
v5 = v60;
}
operator delete(v5, 8 * v61);
}
std::string::_M_dispose(v59);
if ( v58.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::string::_M_dispose(v57);
v9 = *a2;
v10 = a2[1];
v41 = 0LL;
v42 = 0LL;
if ( !v40.m128i_i64[0] )
{
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v41);
goto LABEL_45;
}
v11 = *(_QWORD *)(v40.m128i_i64[0] + 40);
*((_QWORD *)&v42 + 1) = v9;
LOBYTE(v44) = 0;
v43 = 0LL;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::_M_fill_assign(
&v41,
(unsigned int)(v11 + 3),
&v43);
v12 = v40.m128i_i64[0];
v13 = v9 + v10;
v14 = *(_QWORD *)(v40.m128i_i64[0] + 64) - *(_QWORD *)(v40.m128i_i64[0] + 56);
v47 = v40.m128i_i64[0];
v48 = &v41;
v43 = 0LL;
v15 = 0xAAAAAAAAAAAAAAABLL * (v14 >> 4);
v44 = 0LL;
v46 = &v38;
n = v15;
v45 = _mm_unpacklo_epi64((__m128i)v9, (__m128i)v13);
if ( (v38 & 0x400) != 0 )
{
if ( v14 < 0 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
*(_OWORD *)v49 = 0LL;
v50 = 0LL;
if ( v15 )
{
nc = 0x1555555555555556LL * (v14 >> 4);
v21 = (_QWORD *)operator new(nc * 8);
v49[0] = v21;
v22 = &v21[nc];
v50 = (char *)&v21[nc];
do
{
*v21 = 0LL;
v21 += 2;
*((_DWORD *)v21 - 2) = 0;
}
while ( v21 != v22 );
v12 = v47;
n = 0xAAAAAAAAAAAAAAABLL * ((long long)(*(_QWORD *)(v47 + 64) - *(_QWORD *)(v47 + 56)) >> 4);
v23 = n;
}
else
{
v49[0] = 0LL;
v22 = 0LL;
v23 = 0LL;
v50 = 0LL;
}
v24 = *(_QWORD *)(v12 + 32);
v49[1] = v22;
v52 = 0LL;
v36 = v24;
v51 = 0LL;
v25 = (void *)operator new[](v23);
if ( (long long)(n - 1) >= 0 )
v25 = memset(v25, 0, n);
v53 = v25;
v55 = 0;
v54 = v36;
*((_QWORD *)&v44 + 1) = v45.m128i_i64[0];
na = std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(&v43);
if ( na )
{
LABEL_59:
na = 1;
}
else
{
v26 = v55;
if ( (v55 & 0x40) == 0 )
{
LOBYTE(v26) = v55 | 0x80;
v55 = v26;
while ( v45.m128i_i64[0] != v45.m128i_i64[1] )
{
*((_QWORD *)&v44 + 1) = ++v45.m128i_i64[0];
if ( (unsigned __int8)std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,false>::_M_main_dispatch(&v43) )
goto LABEL_59;
}
}
}
if ( v53 )
operator delete[](v53);
std::vector<std::pair<long,std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>>>::~vector(&v51);
if ( v49[0] )
operator delete(v49[0], v50 - (char *)v49[0]);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v43);
if ( !na )
goto LABEL_25;
}
else
{
if ( v14 < 0 )
std::__throw_length_error("cannot create std::vector larger than max_size()");
v50 = 0LL;
*(_OWORD *)v49 = 0LL;
if ( v14 )
{
nb = 0x1555555555555556LL * (v14 >> 4);
v16 = (_QWORD *)operator new(nb * 8);
v49[0] = v16;
v17 = &v16[nb];
v50 = (char *)&v16[nb];
do
{
*v16 = 0LL;
v16 += 2;
*((_DWORD *)v16 - 2) = 0;
}
while ( v16 != v17 );
v12 = v47;
v18 = v48;
}
else
{
v49[0] = 0LL;
v18 = &v41;
v17 = 0LL;
v50 = 0LL;
}
v19 = *(_QWORD *)(v12 + 32);
v49[1] = v17;
v51 = v19;
LODWORD(v52) = 0;
*((_QWORD *)&v44 + 1) = v45.m128i_i64[0];
BYTE4(v52) = 0;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(&v43, v18);
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(
&v43,
1LL,
v51);
if ( !BYTE4(v52) )
{
v20 = v52;
if ( (v52 & 0x40) == 0 )
{
LOBYTE(v20) = v52 | 0x80;
LODWORD(v52) = v20;
while ( v45.m128i_i64[0] != v45.m128i_i64[1] )
{
BYTE4(v52) = 0;
*((_QWORD *)&v44 + 1) = ++v45.m128i_i64[0];
*((_QWORD *)&v51 + 1) = 0LL;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::operator=(&v43, v48);
std::__detail::_Executor<__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>,std::regex_traits<char>,true>::_M_dfs(
&v43,
1LL,
v51);
if ( BYTE4(v52) )
goto LABEL_49;
}
}
if ( v49[0] )
operator delete(v49[0], v50 - (char *)v49[0]);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v43);
LABEL_25:
v37[2] = 0LL;
v37[1] = v13;
v37[0] = v13;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::_M_fill_assign(&v41, 3LL, v37);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v41);
LABEL_45:
strcpy((char *)(a1 + 16), "Invalid");
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 7LL;
goto LABEL_46;
}
LABEL_49:
if ( v49[0] )
operator delete(v49[0], v50 - (char *)v49[0]);
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v43);
}
v28 = (_QWORD *)v41;
for ( i = v41; *((_QWORD *)&i + 1) != (_QWORD)i; *(_QWORD *)&i = i + 24 )
{
if ( !*(_BYTE *)(i + 16) )
{
*(_QWORD *)(i + 8) = v13;
*(_QWORD *)i = v13;
}
}
*(_QWORD *)(*((_QWORD *)&i + 1) - 48LL) = v9;
*(_QWORD *)&i = *((_QWORD *)&i + 1) - 24LL;
v30 = *((_QWORD *)&i + 1) - 48LL;
*((_QWORD *)&i + 1) = *v28;
*(_QWORD *)(v30 + 8) = *v28;
v31 = *((_QWORD *)&i + 1) == v9;
*((_QWORD *)&i + 1) = v28[1];
*(_BYTE *)(v30 + 16) = !v31;
*(_QWORD *)i = *((_QWORD *)&i + 1);
*(_QWORD *)(i + 8) = v13;
*(_BYTE *)(i + 16) = *((_QWORD *)&i + 1) != v13;
std::vector<std::sub_match<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~vector(&v41);
*(_DWORD *)(a1 + 16) = 1768710486;
*(_QWORD *)a1 = a1 + 16;
*(_BYTE *)(a1 + 20) = 100;
*(_QWORD *)(a1 + 8) = 5LL;
*(_BYTE *)(a1 + 21) = 0;
LABEL_46:
if ( v40.m128i_i64[1] )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
std::locale::~locale((std::locale *)v39);
return a1;
} | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x2b8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2a8],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x48]
MOV RDI,R14
CALL 0x00104730
LEA RDX,[0x11a63a]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RDX + -0x1a]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
LAB_00105cd0:
CALL 0x00118b10
MOVDQA XMM0,xmmword ptr [RSP + 0x210]
MOV RDI,qword ptr [RSP + 0x58]
PXOR XMM1,XMM1
MOVAPS xmmword ptr [RSP + 0x210],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM0
TEST RDI,RDI
JZ 0x00105cfe
CALL 0x00107670
LAB_00105cfe:
MOV RDI,qword ptr [RSP + 0x240]
MOV dword ptr [RSP + 0x40],0x10
TEST RDI,RDI
JZ 0x00105d64
MOV RAX,qword ptr [RSP + 0x288]
MOV RBP,qword ptr [RSP + 0x268]
LEA R12,[RAX + 0x8]
CMP RBP,R12
JNC 0x00105d4f
NOP dword ptr [RAX]
LAB_00105d30:
MOV RDI,qword ptr [RBP]
MOV ESI,0x1f8
ADD RBP,0x8
CALL 0x001045a0
CMP RBP,R12
JC 0x00105d30
MOV RDI,qword ptr [RSP + 0x240]
LAB_00105d4f:
MOV RAX,qword ptr [RSP + 0x248]
LEA RSI,[RAX*0x8]
CALL 0x001045a0
LAB_00105d64:
LEA RDI,[RSP + 0x220]
CALL 0x00104620
MOV RDI,qword ptr [RSP + 0x218]
TEST RDI,RDI
JZ 0x00105d83
CALL 0x00107670
LAB_00105d83:
LEA RDI,[RSP + 0x1e0]
CALL 0x00104620
PXOR XMM0,XMM0
MOV R13,qword ptr [R15]
MOV RBP,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [RSP + 0x50]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
TEST RAX,RAX
JZ 0x00106210
MOV RAX,qword ptr [RAX + 0x28]
LEA R15,[RSP + 0x60]
LEA R12,[RSP + 0x80]
MOV qword ptr [RSP + 0x78],R13
MOV RDX,R12
MOV RDI,R15
MOV byte ptr [RSP + 0x90],0x0
LEA ESI,[RAX + 0x3]
LEA RAX,[RSP + 0x40]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOV qword ptr [RSP + 0x10],RAX
LAB_00105dec:
CALL 0x00108d50
MOV RCX,qword ptr [RSP + 0x50]
ADD RBP,R13
MOVQ XMM1,R13
MOV RSI,-0x5555555555555555
MOVQ XMM2,RBP
PXOR XMM0,XMM0
MOV RDX,qword ptr [RCX + 0x40]
SUB RDX,qword ptr [RCX + 0x38]
PUNPCKLQDQ XMM1,XMM2
MOV qword ptr [RSP + 0xb8],RCX
MOV RAX,RDX
MOV qword ptr [RSP + 0xc0],R15
SAR RAX,0x4
MOVAPS xmmword ptr [RSP + 0x80],XMM0
IMUL RAX,RSI
LEA RSI,[RSP + 0x40]
TEST byte ptr [RSP + 0x41],0x4
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0xb0],RSI
MOV qword ptr [RSP + 0x8],RAX
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
JNZ 0x00106038
TEST RDX,RDX
JS 0x0010638f
MOV qword ptr [RSP + 0xd8],0x0
MOVUPS xmmword ptr [RSP + 0xc8],XMM0
JZ 0x00106330
SHL RAX,0x4
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
LAB_00105ea1:
CALL 0x00104590
MOV RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xc8],RAX
ADD RDX,RAX
MOV qword ptr [RSP + 0xd8],RDX
NOP
LAB_00105ec0:
MOV qword ptr [RAX],0x0
ADD RAX,0x10
MOV dword ptr [RAX + -0x8],0x0
CMP RAX,RDX
JNZ 0x00105ec0
MOV RCX,qword ptr [RSP + 0xb8]
MOV RSI,qword ptr [RSP + 0xc0]
LAB_00105ee7:
MOV RAX,qword ptr [RCX + 0x20]
MOV RDI,R12
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xe8],0x0
MOV qword ptr [RSP + 0xe0],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV dword ptr [RSP + 0xf0],0x0
MOV qword ptr [RSP + 0x98],RAX
MOV byte ptr [RSP + 0xf4],0x0
LAB_00105f2d:
CALL 0x00105010
MOV RDX,qword ptr [RSP + 0xe0]
MOV ESI,0x1
MOV RDI,R12
CALL 0x00111b60
CMP byte ptr [RSP + 0xf4],0x0
JNZ 0x00106280
MOV EAX,dword ptr [RSP + 0xf0]
TEST AL,0x40
JNZ 0x00105fdd
OR AL,0x80
MOV dword ptr [RSP + 0xf0],EAX
JMP 0x00105fcb
LAB_00105f70:
MOV RSI,qword ptr [RSP + 0xc0]
ADD RAX,0x1
MOV RDI,R12
MOV byte ptr [RSP + 0xf4],0x0
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0x98],RAX
MOV qword ptr [RSP + 0xe8],0x0
CALL 0x00105010
MOV RDX,qword ptr [RSP + 0xe0]
MOV ESI,0x1
MOV RDI,R12
CALL 0x00111b60
CMP byte ptr [RSP + 0xf4],0x0
JNZ 0x00106280
LAB_00105fcb:
MOV RAX,qword ptr [RSP + 0xa0]
CMP RAX,qword ptr [RSP + 0xa8]
JNZ 0x00105f70
LAB_00105fdd:
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x00105ffa
MOV RSI,qword ptr [RSP + 0xd8]
SUB RSI,RDI
CALL 0x001045a0
LAB_00105ffa:
MOV RDI,R12
CALL 0x001078f0
LAB_00106002:
LEA RDX,[RSP + 0x20]
MOV ESI,0x3
MOV RDI,R15
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x28],RBP
MOV qword ptr [RSP + 0x20],RBP
LAB_00106022:
CALL 0x00108d50
MOV RDI,R15
CALL 0x001078f0
JMP 0x0010621a
LAB_00106038:
TEST RDX,RDX
JS 0x001063ae
CMP qword ptr [RSP + 0x8],0x0
MOVUPS xmmword ptr [RSP + 0xc8],XMM0
MOV qword ptr [RSP + 0xd8],0x0
JZ 0x00106358
SHL RAX,0x4
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
LAB_0010606d:
CALL 0x00104590
MOV RDX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0xc8],RAX
ADD RDX,RAX
MOV qword ptr [RSP + 0xd8],RDX
NOP word ptr [RAX + RAX*0x1]
LAB_00106090:
MOV qword ptr [RAX],0x0
ADD RAX,0x10
MOV dword ptr [RAX + -0x8],0x0
CMP RAX,RDX
JNZ 0x00106090
MOV RCX,qword ptr [RSP + 0xb8]
MOV RSI,-0x5555555555555555
MOV RAX,qword ptr [RCX + 0x40]
SUB RAX,qword ptr [RCX + 0x38]
SAR RAX,0x4
IMUL RAX,RSI
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,RAX
LAB_001060d1:
MOV RAX,qword ptr [RCX + 0x20]
PXOR XMM0,XMM0
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xf0],0x0
MOV qword ptr [RSP + 0x18],RAX
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
LAB_001060fa:
CALL 0x001043c0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,0x1
JS 0x0010611f
MOV RDX,qword ptr [RSP + 0x8]
MOV RDI,RCX
XOR ESI,ESI
CALL 0x001044d0
MOV RCX,RAX
LAB_0010611f:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,R12
MOV qword ptr [RSP + 0xf8],RCX
MOV dword ptr [RSP + 0x108],0x0
MOV qword ptr [RSP + 0x100],RAX
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x98],RAX
LAB_00106152:
CALL 0x00105540
MOV byte ptr [RSP + 0x8],AL
TEST AL,AL
JNZ 0x00106380
MOV EAX,dword ptr [RSP + 0x108]
TEST AL,0x40
JNZ 0x001061b6
OR AL,0x80
MOV dword ptr [RSP + 0x108],EAX
JMP 0x001061a4
LAB_00106180:
ADD RAX,0x1
MOV RDI,R12
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0x98],RAX
CALL 0x00105540
TEST AL,AL
JNZ 0x00106380
LAB_001061a4:
MOV RAX,qword ptr [RSP + 0xa0]
CMP RAX,qword ptr [RSP + 0xa8]
JNZ 0x00106180
LAB_001061b6:
MOV RDI,qword ptr [RSP + 0xf8]
TEST RDI,RDI
JZ 0x001061c8
CALL 0x00104640
LAB_001061c8:
LEA RDI,[RSP + 0xe0]
CALL 0x00108690
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x001061f2
MOV RSI,qword ptr [RSP + 0xd8]
SUB RSI,RDI
CALL 0x001045a0
LAB_001061f2:
MOV RDI,R12
CALL 0x001078f0
CMP byte ptr [RSP + 0x8],0x0
JNZ 0x001062a5
JMP 0x00106002
LAB_00106210:
LEA RDI,[RSP + 0x60]
CALL 0x001078f0
LAB_0010621a:
LEA RAX,[RBX + 0x10]
MOV dword ptr [RBX + 0x10],0x61766e49
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x13],0x64696c61
MOV qword ptr [RBX + 0x8],0x7
MOV byte ptr [RBX + 0x17],0x0
LAB_0010623b:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x0010624a
CALL 0x00107670
LAB_0010624a:
MOV RDI,R14
CALL 0x00104680
MOV RAX,qword ptr [RSP + 0x2a8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010638a
ADD RSP,0x2b8
MOV RAX,RBX
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00106280:
MOV RDI,qword ptr [RSP + 0xc8]
TEST RDI,RDI
JZ 0x0010629d
MOV RSI,qword ptr [RSP + 0xd8]
SUB RSI,RDI
CALL 0x001045a0
LAB_0010629d:
MOV RDI,R12
CALL 0x001078f0
LAB_001062a5:
MOV RCX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOV RAX,RCX
CMP RCX,RDX
JZ 0x001062d6
NOP word ptr [RAX + RAX*0x1]
LAB_001062c0:
CMP byte ptr [RAX + 0x10],0x0
JNZ 0x001062cd
MOV qword ptr [RAX + 0x8],RBP
MOV qword ptr [RAX],RBP
LAB_001062cd:
ADD RAX,0x18
CMP RDX,RAX
JNZ 0x001062c0
LAB_001062d6:
MOV qword ptr [RDX + -0x30],R13
LEA RAX,[RDX + -0x18]
LEA RSI,[RDX + -0x30]
MOV RDX,qword ptr [RCX]
MOV RDI,R15
MOV qword ptr [RSI + 0x8],RDX
CMP RDX,R13
MOV RDX,qword ptr [RCX + 0x8]
SETNZ byte ptr [RSI + 0x10]
MOV qword ptr [RAX],RDX
CMP RDX,RBP
MOV qword ptr [RAX + 0x8],RBP
SETNZ byte ptr [RAX + 0x10]
CALL 0x001078f0
LEA RAX,[RBX + 0x10]
MOV dword ptr [RBX + 0x10],0x696c6156
MOV qword ptr [RBX],RAX
MOV byte ptr [RBX + 0x14],0x64
MOV qword ptr [RBX + 0x8],0x5
MOV byte ptr [RBX + 0x15],0x0
JMP 0x0010623b
LAB_00106330:
MOV qword ptr [RSP + 0xc8],0x0
MOV RSI,R15
XOR EDX,EDX
MOV qword ptr [RSP + 0xd8],0x0
JMP 0x00105ee7
LAB_00106358:
MOV qword ptr [RSP + 0xc8],0x0
XOR EDX,EDX
MOV RDI,RAX
MOV qword ptr [RSP + 0xd8],0x0
JMP 0x001060d1
LAB_00106380:
MOV byte ptr [RSP + 0x8],0x1
JMP 0x001061b6
LAB_0010638a:
CALL 0x001045e0
LAB_0010638f:
MOV RAX,qword ptr [RSP + 0x2a8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001063cd
LEA RDI,[0x11a1a0]
LAB_001063a9:
CALL 0x001044b0
LAB_001063ae:
MOV RAX,qword ptr [RSP + 0x2a8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001063d2
LEA RDI,[0x11a1a0]
LAB_001063c8:
CALL 0x001044b0
LAB_001063cd:
CALL 0x001045e0
LAB_001063d2:
CALL 0x001045e0 | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int auVar4 [16];
bool bVar5;
char cVar6;
long lVar7;
int8 *puVar8;
int8 *puVar9;
ulong uVar10;
ulong *puVar11;
long lVar12;
ulong uVar13;
ulong *in_RSI;
uint *puVar14;
_Match_mode _Var15;
long in_FS_OFFSET;
ulong local_2c8;
ulong local_2c0;
int8 local_2b8;
uint local_2a8 [2];
locale local_2a0 [2];
int local_298 [16];
int local_288 [16];
int local_278 [16];
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
local_268 [16];
int local_258 [8];
ulong uStack_250;
ulong local_248;
ulong uStack_240;
uint *local_238;
long local_230;
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*local_228;
int local_220 [16];
int8 *local_210;
int local_208 [16];
int8 local_1f8;
void *local_1f0;
int8 local_1e8;
uint local_1e0;
_Compiler<std::regex_traits<char>> local_1d8 [256];
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);
std::locale::locale(local_2a0);
local_298 = (int [16])0x0;
/* try { // try from 00105cd0 to 00105cd4 has its CatchHandler @ 001063e3 */
std::__detail::_Compiler<std::regex_traits<char>>::_Compiler
(local_1d8,"^[aeiouAEIOU][A-Za-z0-9_]*","",local_2a0,0x10);
auVar4 = local_d8._0_16_;
uVar2 = local_298._8_8_;
local_d8._0_16_ = (int [16])0x0;
local_298 = auVar4;
if ((_Sp_counted_base<(_Lock_policy)2> *)uVar2 != (_Sp_counted_base<(_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(_Lock_policy)2>::_M_release((_Sp_counted_base<(_Lock_policy)2> *)uVar2);
}
local_2a8[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();
uVar1 = *in_RSI;
uVar13 = in_RSI[1];
local_288 = (int [16])0x0;
local_278 = (int [16])0x0;
if (local_298._0_8_ == 0) {
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_288);
LAB_0010621a:
*(int4 *)(param_1 + 0x10) = 0x61766e49;
*(string **)param_1 = param_1 + 0x10;
*(int4 *)(param_1 + 0x13) = 0x64696c61;
*(int8 *)(param_1 + 8) = 7;
param_1[0x17] = (string)0x0;
}
else {
local_278._8_8_ = 0;
local_278._0_8_ = uVar1;
local_278 = local_278 << 0x40;
auVar4[0xf] = 0;
auVar4._0_15_ = stack0xfffffffffffffda9;
_local_258 = auVar4 << 8;
local_268[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
/* try { // try from 00105dec to 00105df0 has its CatchHandler @ 001063ef */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::_M_fill_assign((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_288,(ulong)((int)*(int8 *)(local_298._0_8_ + 0x28) + 3),
(sub_match *)local_268);
uVar13 = uVar13 + uVar1;
lVar12 = *(long *)(local_298._0_8_ + 0x40) - *(long *)(local_298._0_8_ + 0x38);
local_230 = local_298._0_8_;
lVar7 = lVar12 >> 4;
local_268[0] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[1] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[2] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[3] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[4] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[5] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[6] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[7] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[8] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[9] = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[10] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xb] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xc] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xd] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xe] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
local_268[0xf] =
(vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
)0x0;
puVar14 = local_2a8;
_local_258 = (int [16])0x0;
local_258 = (int [8])0x0;
local_248 = uVar1;
uStack_240 = uVar13;
local_238 = puVar14;
local_228 = (vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_288;
if ((local_2a8[0] & 0x400) == 0) {
if (lVar12 < 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 001063a9 to 001063ad has its CatchHandler @ 00106413 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_210 = (int8 *)0x0;
local_220 = (int [16])0x0;
if (lVar12 == 0) {
local_220._0_8_ = (int8 *)0x0;
local_210 = (int8 *)0x0;
}
else {
/* try { // try from 00105ea1 to 00105ea5 has its CatchHandler @ 00106413 */
local_220._0_8_ = operator_new(lVar7 * -0x5555555555555550);
local_210 = (int8 *)(local_220._0_8_ + lVar7 * -0xaaaaaaaaaaaaaaa * 8);
puVar9 = (int8 *)local_220._0_8_;
do {
*puVar9 = 0;
puVar8 = puVar9 + 2;
*(int4 *)(puVar9 + 1) = 0;
puVar9 = puVar8;
} while (puVar8 != local_210);
}
local_220._8_8_ = local_210;
local_208._8_8_ = 0;
local_208._0_8_ = *(ulong *)(local_230 + 0x20);
uStack_250 = local_248;
local_1f8 = (ulong)local_1f8._5_3_ << 0x28;
/* try { // try from 00105f2d to 00105fbc has its CatchHandler @ 0010641f */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator=(local_268,(vector *)local_228);
std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
::_M_dfs((_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
*)local_268,1,local_208._0_8_);
if (local_1f8._4_1_ == '\0') {
if ((local_1f8 & 0x40) != 0) {
LAB_00105fdd:
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_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_268);
goto LAB_00106002;
}
local_1f8 = local_1f8 | 0x80;
do {
if (local_248 == uStack_240) goto LAB_00105fdd;
local_248 = local_248 + 1;
local_1f8._0_5_ = (uint5)(uint)local_1f8;
uStack_250 = local_248;
local_208._8_8_ = 0;
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::operator=(local_268,(vector *)local_228);
std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
::_M_dfs((_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,true>
*)local_268,1,local_208._0_8_);
} while (local_1f8._4_1_ == '\0');
}
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_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_268);
}
else {
if (lVar12 < 0) {
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
/* try { // try from 001063c8 to 001063cc has its CatchHandler @ 00106407 */
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
local_220 = (int [16])0x0;
local_210 = (int8 *)0x0;
if (lVar7 * -0x5555555555555555 == 0) {
local_220._0_8_ = (int8 *)0x0;
local_210 = (int8 *)0x0;
uVar10 = 0;
}
else {
/* try { // try from 0010606d to 00106071 has its CatchHandler @ 00106407 */
local_220._0_8_ = operator_new(lVar7 * -0x5555555555555550);
local_210 = (int8 *)(local_220._0_8_ + lVar7 * -0xaaaaaaaaaaaaaaa * 8);
puVar9 = (int8 *)local_220._0_8_;
do {
*puVar9 = 0;
puVar8 = puVar9 + 2;
*(int4 *)(puVar9 + 1) = 0;
puVar9 = puVar8;
} while (puVar8 != local_210);
puVar14 = (uint *)0xaaaaaaaaaaaaaaab;
uVar10 = (*(long *)(local_230 + 0x40) - *(long *)(local_230 + 0x38) >> 4) *
-0x5555555555555555;
}
uVar2 = *(int8 *)(local_230 + 0x20);
local_220._8_8_ = local_210;
local_1f8 = 0;
local_208 = (int [16])0x0;
/* try { // try from 001060fa to 001060fe has its CatchHandler @ 001063fb */
local_1f0 = operator_new__(uVar10);
if (-1 < (long)(uVar10 - 1)) {
puVar14 = (uint *)0x0;
local_1f0 = memset(local_1f0,0,uVar10);
}
local_1e0 = 0;
uStack_250 = local_248;
_Var15 = (_Match_mode)local_268;
local_1e8 = uVar2;
/* try { // try from 00106152 to 0010619b has its CatchHandler @ 001063d7 */
cVar6 = std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,false>
::_M_main_dispatch(_Var15,(integral_constant)puVar14);
if (cVar6 == '\0') {
bVar5 = false;
if ((local_1e0 & 0x40) == 0) {
local_1e0 = local_1e0 | 0x80;
do {
if (local_248 == uStack_240) goto LAB_001061b6;
local_248 = local_248 + 1;
uStack_250 = local_248;
cVar6 = std::__detail::
_Executor<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>,std::regex_traits<char>,false>
::_M_main_dispatch(_Var15,(integral_constant)puVar14);
} while (cVar6 == '\0');
goto LAB_00106380;
}
}
else {
LAB_00106380:
bVar5 = true;
}
LAB_001061b6:
if (local_1f0 != (void *)0x0) {
operator_delete__(local_1f0);
}
std::
vector<std::pair<long,std::vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>>,std::allocator<std::pair<long,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::pair<long,std::vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>>,std::allocator<std::pair<long,std::vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>>>>
*)local_208);
if ((void *)local_220._0_8_ != (void *)0x0) {
operator_delete((void *)local_220._0_8_,(long)local_210 - local_220._0_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_268);
if (!bVar5) {
LAB_00106002:
local_2b8 = 0;
local_2c8 = uVar13;
local_2c0 = uVar13;
/* try { // try from 00106022 to 00106026 has its CatchHandler @ 001063ef */
std::
vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
::_M_fill_assign((vector<std::sub_match<__normal_iterator<char_const*,std::string>>,std::allocator<std::sub_match<__normal_iterator<char_const*,std::string>>>>
*)local_288,3,(sub_match *)&local_2c8);
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_288);
goto LAB_0010621a;
}
}
for (puVar11 = (ulong *)local_288._0_8_; puVar11 != (ulong *)local_288._8_8_;
puVar11 = puVar11 + 3) {
if (*(char *)(puVar11 + 2) == '\0') {
puVar11[1] = uVar13;
*puVar11 = uVar13;
}
}
*(ulong *)(local_288._8_8_ + -0x30) = uVar1;
uVar10 = *(ulong *)local_288._0_8_;
*(ulong *)(local_288._8_8_ + -0x28) = uVar10;
uVar3 = *(ulong *)(local_288._0_8_ + 8);
*(bool *)(local_288._8_8_ + -0x20) = uVar10 != uVar1;
*(ulong *)(local_288._8_8_ + -0x18) = uVar3;
*(ulong *)(local_288._8_8_ + -0x10) = uVar13;
*(bool *)(local_288._8_8_ + -8) = uVar3 != uVar13;
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_288);
*(int4 *)(param_1 + 0x10) = 0x696c6156;
*(string **)param_1 = param_1 + 0x10;
param_1[0x14] = (string)0x64;
*(int8 *)(param_1 + 8) = 5;
param_1[0x15] = (string)0x0;
}
if ((_Sp_counted_base<(_Lock_policy)2> *)local_298._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_298._8_8_);
}
std::locale::~locale(local_2a0);
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return param_1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,948 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / (pow(2, n)) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jns 1184 <_Z5func0i+0x1b>
pxor %xmm0,%xmm0
jmp 11c1 <_Z5func0i+0x58>
cvtsi2sdl -0x4(%rbp),%xmm0
mov 0xf10(%rip),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xf02(%rip),%xmm1
divsd %xmm0,%xmm1
movsd %xmm1,-0x10(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov %eax,%edi
callq 1169 <_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], 0
jns short loc_1184
pxor xmm0, xmm0
jmp short locret_11C5
loc_1184:
pxor xmm0, xmm0
cvtsi2sd xmm0, [rbp+var_4]
mov rax, cs:x
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_2088
divsd xmm1, xmm0
movsd [rbp+var_10], xmm1
mov eax, [rbp+var_4]
sub eax, 1
mov edi, eax; int
call _Z5func0i; func0(int)
addsd xmm0, [rbp+var_10]
locret_11C5:
leave
retn | double func0(int a1)
{
double v2; // xmm0_8
if ( a1 < 0 )
return 0.0;
v2 = pow(2.0, (double)a1);
func0(a1 - 1);
return v2 + 1.0 / v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
CMP dword ptr [RBP + -0x4],0x0
JNS 0x00101184
PXOR XMM0,XMM0
JMP 0x001011c5
LAB_00101184:
PXOR XMM0,XMM0
CVTSI2SD XMM0,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [0x00102080]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102088]
DIVSD XMM1,XMM0
MOVSD qword ptr [RBP + -0x10],XMM1
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV EDI,EAX
CALL 0x00101169
ADDSD XMM0,qword ptr [RBP + -0x10]
LAB_001011c5:
LEAVE
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
if (param_1 < 0) {
dVar2 = 0.0;
}
else {
dVar1 = pow(DAT_00102080,(double)param_1);
dVar1 = DAT_00102088 / dVar1;
dVar2 = (double)func0(param_1 + -1);
dVar2 = dVar2 + dVar1;
}
return dVar2;
} |
2,949 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / (pow(2, n)) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O1 | cpp | func0(int):
endbr64
pxor %xmm0,%xmm0
test %edi,%edi
js 11bb <_Z5func0i+0x52>
push %rbx
sub $0x10,%rsp
mov %edi,%ebx
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xf0c(%rip),%xmm0
callq 1060 <pow@plt>
movsd %xmm0,0x8(%rsp)
lea -0x1(%rbx),%edi
callq 1169 <_Z5func0i>
movapd %xmm0,%xmm1
movsd 0xef5(%rip),%xmm0
divsd 0x8(%rsp),%xmm0
addsd %xmm1,%xmm0
add $0x10,%rsp
pop %rbx
retq
retq
| _Z5func0i:
endbr64
pxor xmm0, xmm0
test edi, edi
js short locret_11B7
push rbx
sub rsp, 10h
mov ebx, edi
pxor xmm1, xmm1
cvtsi2sd xmm1, edi; y
movsd xmm0, cs:x; x
call _pow
movsd xmm1, cs:qword_2078
divsd xmm1, xmm0
movsd [rsp+18h+var_10], xmm1
lea edi, [rbx-1]; int
call _Z5func0i; func0(int)
addsd xmm0, [rsp+18h+var_10]
add rsp, 10h
pop rbx
retn
locret_11B7:
retn | double func0(int a1)
{
double result; // xmm0_8
double v2; // xmm0_8
result = 0.0;
if ( a1 >= 0 )
{
v2 = pow(2.0, (double)a1);
func0(a1 - 1);
return v2 + 1.0 / v2;
}
return result;
} | func0:
ENDBR64
PXOR XMM0,XMM0
TEST EDI,EDI
JS 0x001011b7
PUSH RBX
SUB RSP,0x10
MOV EBX,EDI
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102070]
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102078]
DIVSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
LEA EDI,[RBX + -0x1]
CALL 0x00101169
ADDSD XMM0,qword ptr [RSP + 0x8]
ADD RSP,0x10
POP RBX
RET
LAB_001011b7:
RET | /* func0(int) */
double func0(int param_1)
{
double dVar1;
double dVar2;
if (-1 < param_1) {
dVar1 = pow(DAT_00102070,(double)param_1);
dVar1 = DAT_00102078 / dVar1;
dVar2 = (double)func0(param_1 + -1);
return dVar2 + dVar1;
}
return 0.0;
} |
2,950 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / (pow(2, n)) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
js 1230 <_Z5func0i+0x10>
jmp 1240 <_Z5func0i.part.0>
nopw 0x0(%rax,%rax,1)
pxor %xmm0,%xmm0
retq
data16 nopw %cs:0x0(%rax,%rax,1)
| _Z5func0i_part_0:
push rbx
pxor xmm1, xmm1
mov ebx, edi
cvtsi2sd xmm1, edi; y
sub rsp, 30h
movsd xmm0, cs:x; x
call _pow
movsd xmm3, cs:qword_2078
divsd xmm3, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm3
test ebx, ebx
jz loc_135C
lea eax, [rbx-1]
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm5, cs:qword_2078
lea eax, [rbx-2]
divsd xmm5, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_28], xmm5
cmp ebx, 1
jz loc_1356
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm7, cs:qword_2078
lea eax, [rbx-3]
divsd xmm7, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_20], xmm7
cmp ebx, 2
jz loc_1350
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm2, cs:qword_2078
lea eax, [rbx-4]
divsd xmm2, xmm0
pxor xmm0, xmm0
cmp ebx, 3
jz short loc_134C
pxor xmm1, xmm1
movsd xmm0, cs:x; x
movsd [rsp+38h+var_18], xmm2
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm1, cs:qword_2078
cmp ebx, 4
lea edi, [rbx-5]
movsd xmm2, [rsp+38h+var_18]
divsd xmm1, xmm0
pxor xmm0, xmm0
jz short loc_1348
movsd [rsp+38h+var_10], xmm1
call _Z5func0i_part_0; func0(int) [clone]
movsd xmm1, [rsp+38h+var_10]
movsd xmm2, [rsp+38h+var_18]
loc_1348:
addsd xmm0, xmm1
loc_134C:
addsd xmm0, xmm2
loc_1350:
addsd xmm0, [rsp+38h+var_20]
loc_1356:
addsd xmm0, [rsp+38h+var_28]
loc_135C:
addsd xmm0, [rsp+38h+var_30]
add rsp, 30h
pop rbx
retn | double func0(int a1)
{
double v1; // xmm3_8
double v2; // xmm0_8
double v3; // xmm5_8
double v4; // xmm0_8
double v5; // xmm7_8
double v6; // xmm0_8
double v7; // xmm2_8
double v8; // xmm0_8
double v9; // xmm1_8
double v11; // [rsp+8h] [rbp-28h]
v1 = 1.0 / pow(2.0, (double)a1);
v2 = 0.0;
if ( a1 )
{
v3 = 1.0 / pow(2.0, (double)(a1 - 1));
v4 = 0.0;
v11 = v3;
if ( a1 != 1 )
{
v5 = 1.0 / pow(2.0, (double)(a1 - 2));
v6 = 0.0;
if ( a1 != 2 )
{
v7 = 1.0 / pow(2.0, (double)(a1 - 3));
v8 = 0.0;
if ( a1 != 3 )
{
v9 = 1.0 / pow(2.0, (double)(a1 - 4));
if ( a1 != 4 )
func0((unsigned int)(a1 - 5), 0.0, v9, v7);
v8 = v9 + 0.0;
}
v6 = v8 + v7;
}
v4 = v6 + v5;
}
v2 = v4 + v11;
}
return v2 + v1;
} | func0:
PUSH RBX
PXOR XMM1,XMM1
MOV EBX,EDI
CVTSI2SD XMM1,EDI
SUB RSP,0x30
MOVSD XMM0,qword ptr [0x00102070]
CALL 0x00101060
MOVSD XMM3,qword ptr [0x00102078]
DIVSD XMM3,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM3
TEST EBX,EBX
JZ 0x0010135c
LEA EAX,[RBX + -0x1]
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102070]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM5,qword ptr [0x00102078]
LEA EAX,[RBX + -0x2]
DIVSD XMM5,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x10],XMM5
CMP EBX,0x1
JZ 0x00101356
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102070]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM7,qword ptr [0x00102078]
LEA EAX,[RBX + -0x3]
DIVSD XMM7,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x18],XMM7
CMP EBX,0x2
JZ 0x00101350
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102070]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM2,qword ptr [0x00102078]
LEA EAX,[RBX + -0x4]
DIVSD XMM2,XMM0
PXOR XMM0,XMM0
CMP EBX,0x3
JZ 0x0010134c
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102070]
MOVSD qword ptr [RSP + 0x20],XMM2
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102078]
CMP EBX,0x4
LEA EDI,[RBX + -0x5]
MOVSD XMM2,qword ptr [RSP + 0x20]
DIVSD XMM1,XMM0
PXOR XMM0,XMM0
JZ 0x00101348
MOVSD qword ptr [RSP + 0x28],XMM1
CALL 0x00101220
MOVSD XMM1,qword ptr [RSP + 0x28]
MOVSD XMM2,qword ptr [RSP + 0x20]
LAB_00101348:
ADDSD XMM0,XMM1
LAB_0010134c:
ADDSD XMM0,XMM2
LAB_00101350:
ADDSD XMM0,qword ptr [RSP + 0x18]
LAB_00101356:
ADDSD XMM0,qword ptr [RSP + 0x10]
LAB_0010135c:
ADDSD XMM0,qword ptr [RSP + 0x8]
ADD RSP,0x30
POP RBX
RET | /* func0(int) [clone .part.0] */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
dVar1 = pow(DAT_00102070,(double)param_1);
dVar1 = DAT_00102078 / dVar1;
dVar6 = 0.0;
if (param_1 != 0) {
dVar2 = pow(DAT_00102070,(double)(param_1 + -1));
dVar2 = DAT_00102078 / dVar2;
dVar6 = 0.0;
if (param_1 != 1) {
dVar3 = pow(DAT_00102070,(double)(param_1 + -2));
dVar3 = DAT_00102078 / dVar3;
dVar6 = 0.0;
if (param_1 != 2) {
dVar4 = pow(DAT_00102070,(double)(param_1 + -3));
dVar4 = DAT_00102078 / dVar4;
dVar6 = 0.0;
if (param_1 != 3) {
dVar5 = pow(DAT_00102070,(double)(param_1 + -4));
dVar5 = DAT_00102078 / dVar5;
dVar6 = 0.0;
if (param_1 != 4) {
dVar6 = (double)func0(param_1 + -5);
}
dVar6 = dVar6 + dVar5;
}
dVar6 = dVar6 + dVar4;
}
dVar6 = dVar6 + dVar3;
}
dVar6 = dVar6 + dVar2;
}
return dVar6 + dVar1;
} |
2,951 | func0 |
#include <cmath>
#include <cassert>
| double func0(int n) {
if (n < 0) {
return 0;
} else {
return 1 / (pow(2, n)) + func0(n - 1);
}
}
| int main() {
assert(func0(7) == 1.9921875);
assert(func0(4) == 1.9375);
assert(func0(8) == 1.99609375);
return 0;
}
| O3 | cpp | func0(int) [clone .part.0]:
push %rbx
pxor %xmm1,%xmm1
mov %edi,%ebx
cvtsi2sd %edi,%xmm1
sub $0x10,%rsp
movsd 0xe61(%rip),%xmm0
callq 1060 <pow@plt>
movsd 0xe5c(%rip),%xmm1
divsd %xmm0,%xmm1
pxor %xmm0,%xmm0
test %ebx,%ebx
je 1264 <_Z5func0i.part.0+0x44>
lea -0x1(%rbx),%edi
movsd %xmm1,0x8(%rsp)
callq 1220 <_Z5func0i.part.0>
movsd 0x8(%rsp),%xmm1
add $0x10,%rsp
addsd %xmm1,%xmm0
pop %rbx
retq
xchg %ax,%ax
| _Z5func0i_part_0:
push rbx
pxor xmm1, xmm1
mov ebx, edi
cvtsi2sd xmm1, edi; y
sub rsp, 30h
movsd xmm0, cs:x; x
call _pow
movsd xmm3, cs:qword_2080
divsd xmm3, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_30], xmm3
test ebx, ebx
jz loc_135C
lea eax, [rbx-1]
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm5, cs:qword_2080
lea eax, [rbx-2]
divsd xmm5, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_28], xmm5
cmp ebx, 1
jz loc_1356
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm7, cs:qword_2080
lea eax, [rbx-3]
divsd xmm7, xmm0
pxor xmm0, xmm0
movsd [rsp+38h+var_20], xmm7
cmp ebx, 2
jz loc_1350
pxor xmm1, xmm1
movsd xmm0, cs:x; x
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm2, cs:qword_2080
lea eax, [rbx-4]
divsd xmm2, xmm0
pxor xmm0, xmm0
cmp ebx, 3
jz short loc_134C
pxor xmm1, xmm1
movsd xmm0, cs:x; x
movsd [rsp+38h+var_18], xmm2
cvtsi2sd xmm1, eax; y
call _pow
movsd xmm1, cs:qword_2080
cmp ebx, 4
lea edi, [rbx-5]
movsd xmm2, [rsp+38h+var_18]
divsd xmm1, xmm0
pxor xmm0, xmm0
jz short loc_1348
movsd [rsp+38h+var_10], xmm1
call _Z5func0i_part_0; func0(int) [clone]
movsd xmm1, [rsp+38h+var_10]
movsd xmm2, [rsp+38h+var_18]
loc_1348:
addsd xmm0, xmm1
loc_134C:
addsd xmm0, xmm2
loc_1350:
addsd xmm0, [rsp+38h+var_20]
loc_1356:
addsd xmm0, [rsp+38h+var_28]
loc_135C:
addsd xmm0, [rsp+38h+var_30]
add rsp, 30h
pop rbx
retn | double func0(int a1)
{
double v1; // xmm3_8
double v2; // xmm0_8
double v3; // xmm5_8
double v4; // xmm0_8
double v5; // xmm7_8
double v6; // xmm0_8
double v7; // xmm2_8
double v8; // xmm0_8
double v9; // xmm1_8
double v11; // [rsp+8h] [rbp-28h]
v1 = 1.0 / pow(2.0, (double)a1);
v2 = 0.0;
if ( a1 )
{
v3 = 1.0 / pow(2.0, (double)(a1 - 1));
v4 = 0.0;
v11 = v3;
if ( a1 != 1 )
{
v5 = 1.0 / pow(2.0, (double)(a1 - 2));
v6 = 0.0;
if ( a1 != 2 )
{
v7 = 1.0 / pow(2.0, (double)(a1 - 3));
v8 = 0.0;
if ( a1 != 3 )
{
v9 = 1.0 / pow(2.0, (double)(a1 - 4));
if ( a1 != 4 )
func0((unsigned int)(a1 - 5), 0.0, v9, v7);
v8 = v9 + 0.0;
}
v6 = v8 + v7;
}
v4 = v6 + v5;
}
v2 = v4 + v11;
}
return v2 + v1;
} | func0:
PUSH RBX
PXOR XMM1,XMM1
MOV EBX,EDI
CVTSI2SD XMM1,EDI
SUB RSP,0x30
MOVSD XMM0,qword ptr [0x00102078]
CALL 0x00101060
MOVSD XMM3,qword ptr [0x00102080]
DIVSD XMM3,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x8],XMM3
TEST EBX,EBX
JZ 0x0010135c
LEA EAX,[RBX + -0x1]
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102078]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM5,qword ptr [0x00102080]
LEA EAX,[RBX + -0x2]
DIVSD XMM5,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x10],XMM5
CMP EBX,0x1
JZ 0x00101356
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102078]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM7,qword ptr [0x00102080]
LEA EAX,[RBX + -0x3]
DIVSD XMM7,XMM0
PXOR XMM0,XMM0
MOVSD qword ptr [RSP + 0x18],XMM7
CMP EBX,0x2
JZ 0x00101350
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102078]
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM2,qword ptr [0x00102080]
LEA EAX,[RBX + -0x4]
DIVSD XMM2,XMM0
PXOR XMM0,XMM0
CMP EBX,0x3
JZ 0x0010134c
PXOR XMM1,XMM1
MOVSD XMM0,qword ptr [0x00102078]
MOVSD qword ptr [RSP + 0x20],XMM2
CVTSI2SD XMM1,EAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102080]
CMP EBX,0x4
LEA EDI,[RBX + -0x5]
MOVSD XMM2,qword ptr [RSP + 0x20]
DIVSD XMM1,XMM0
PXOR XMM0,XMM0
JZ 0x00101348
MOVSD qword ptr [RSP + 0x28],XMM1
CALL 0x00101220
MOVSD XMM1,qword ptr [RSP + 0x28]
MOVSD XMM2,qword ptr [RSP + 0x20]
LAB_00101348:
ADDSD XMM0,XMM1
LAB_0010134c:
ADDSD XMM0,XMM2
LAB_00101350:
ADDSD XMM0,qword ptr [RSP + 0x18]
LAB_00101356:
ADDSD XMM0,qword ptr [RSP + 0x10]
LAB_0010135c:
ADDSD XMM0,qword ptr [RSP + 0x8]
ADD RSP,0x30
POP RBX
RET | /* func0(int) [clone .part.0] */
double func0(int param_1)
{
double dVar1;
double dVar2;
double dVar3;
double dVar4;
double dVar5;
double dVar6;
dVar1 = pow(DAT_00102078,(double)param_1);
dVar1 = DAT_00102080 / dVar1;
dVar6 = 0.0;
if (param_1 != 0) {
dVar2 = pow(DAT_00102078,(double)(param_1 + -1));
dVar2 = DAT_00102080 / dVar2;
dVar6 = 0.0;
if (param_1 != 1) {
dVar3 = pow(DAT_00102078,(double)(param_1 + -2));
dVar3 = DAT_00102080 / dVar3;
dVar6 = 0.0;
if (param_1 != 2) {
dVar4 = pow(DAT_00102078,(double)(param_1 + -3));
dVar4 = DAT_00102080 / dVar4;
dVar6 = 0.0;
if (param_1 != 3) {
dVar5 = pow(DAT_00102078,(double)(param_1 + -4));
dVar5 = DAT_00102080 / dVar5;
dVar6 = 0.0;
if (param_1 != 4) {
dVar6 = (double)func0(param_1 + -5);
}
dVar6 = dVar6 + dVar5;
}
dVar6 = dVar6 + dVar4;
}
dVar6 = dVar6 + dVar3;
}
dVar6 = dVar6 + dVar2;
}
return dVar6 + dVar1;
} |
2,952 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
double x = std::sqrt(2 * std::pow(10,(n - 1)));
return std::round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
sub $0x1,%eax
mov %eax,%esi
mov $0xa,%edi
callq 1289 <_ZSt3powIiiEN9__gnu_cxx11__promote_2IT_T0_NS0_9__promoteIS2_XsrSt12__is_integerIS2_E7__valueEE6__typeENS4_IS3_XsrS5_IS3_E7__valueEE6__typeEE6__typeES2_S3_>
addsd %xmm0,%xmm0
callq 10b0 <sqrt@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movq %rax,%xmm0
callq 1080 <round@plt>
cvttsd2si %xmm0,%eax
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
sub eax, 1
mov esi, eax
mov edi, 0Ah
call _ZSt3powIiiEN9__gnu_cxx11__promote_2IDTplcvNS1_IT_XsrSt12__is_integerIS2_E7__valueEE6__typeELi0EcvNS1_IT0_XsrS3_IS7_E7__valueEE6__typeELi0EEXsrS3_ISB_E7__valueEE6__typeES2_S7_
addsd xmm0, xmm0
movq rax, xmm0
movq xmm0, rax; x
call _sqrt
movq rax, xmm0
mov [rbp+x], rax
mov rax, [rbp+x]
movq xmm0, rax; x
call _round
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1)
{
double v1; // xmm0_8
double v2; // xmm0_8
v1 = std::pow<int,int>(10LL, (unsigned int)(a1 - 1));
v2 = sqrt(v1 + v1);
return (unsigned int)(int)round(v2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV ESI,EAX
MOV EDI,0xa
CALL 0x001012ae
ADDSD XMM0,XMM0
MOVQ RAX,XMM0
MOVQ XMM0,RAX
CALL 0x001010b0
MOVQ RAX,XMM0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVQ XMM0,RAX
CALL 0x00101080
CVTTSD2SI EAX,XMM0
LEAVE
RET | /* func0(int) */
int func0(int param_1)
{
double extraout_XMM0_Qa;
double dVar1;
std::pow<int,int>(10,param_1 + -1);
dVar1 = sqrt(extraout_XMM0_Qa + extraout_XMM0_Qa);
dVar1 = round(dVar1);
return (int)dVar1;
} |
2,953 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
double x = std::sqrt(2 * std::pow(10,(n - 1)));
return std::round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O1 | cpp | func0(int):
endbr64
sub $0x18,%rsp
sub $0x1,%edi
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd 0xec4(%rip),%xmm0
callq 1090 <pow@plt>
addsd %xmm0,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 11f9 <_Z5func0i+0x50>
movsd 0x8(%rsp),%xmm0
callq 1080 <round@plt>
cvttsd2si %xmm0,%eax
add $0x18,%rsp
retq
callq 10b0 <sqrt@plt>
jmp 11e5 <_Z5func0i+0x3c>
| _Z5func0i:
endbr64
sub rsp, 8
sub edi, 1
pxor xmm1, xmm1
cvtsi2sd xmm1, edi; y
movsd xmm0, cs:x; x
call _pow
addsd xmm0, xmm0
sqrtsd xmm0, xmm0; x
call _round
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
return (unsigned int)(int)round(sqrt(v1 + v1));
} | func0:
ENDBR64
SUB RSP,0x8
SUB EDI,0x1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD XMM0,qword ptr [0x00102060]
CALL 0x00101080
ADDSD XMM0,XMM0
SQRTSD XMM0,XMM0
CALL 0x00101070
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | /* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102060,(double)(param_1 + -1));
dVar1 = round(SQRT(dVar1 + dVar1));
return (int)dVar1;
} |
2,954 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
double x = std::sqrt(2 * std::pow(10,(n - 1)));
return std::round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O2 | cpp | func0(int):
endbr64
sub $0x1,%edi
pxor %xmm1,%xmm1
sub $0x18,%rsp
movsd 0xe21(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1090 <pow@plt>
pxor %xmm2,%xmm2
addsd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1298 <_Z5func0i+0x48>
movapd %xmm1,%xmm0
callq 1080 <round@plt>
add $0x18,%rsp
cvttsd2si %xmm0,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 10b0 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1286 <_Z5func0i+0x36>
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
sub edi, 1
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:x; x
cvtsi2sd xmm1, edi; y
call _pow
addsd xmm0, xmm0
sqrtsd xmm0, xmm0; x
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
return (unsigned int)(int)round(sqrt(v1 + v1));
} | func0:
ENDBR64
SUB EDI,0x1
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102060]
CVTSI2SD XMM1,EDI
CALL 0x00101080
ADDSD XMM0,XMM0
SQRTSD XMM0,XMM0
CALL 0x00101070
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102060,(double)(param_1 + -1));
dVar1 = round(SQRT(dVar1 + dVar1));
return (int)dVar1;
} |
2,955 | func0 |
#include <cmath>
#include <cassert>
| int func0(int n) {
double x = std::sqrt(2 * std::pow(10,(n - 1)));
return std::round(x);
}
| int main() {
assert(func0(2) == 4);
assert(func0(3) == 14);
assert(func0(4) == 45);
return 0;
}
| O3 | cpp | func0(int):
endbr64
sub $0x1,%edi
pxor %xmm1,%xmm1
sub $0x18,%rsp
movsd 0xe21(%rip),%xmm0
cvtsi2sd %edi,%xmm1
callq 1090 <pow@plt>
pxor %xmm2,%xmm2
addsd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 1298 <_Z5func0i+0x48>
movapd %xmm1,%xmm0
callq 1080 <round@plt>
add $0x18,%rsp
cvttsd2si %xmm0,%eax
retq
movsd %xmm1,0x8(%rsp)
callq 10b0 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
jmp 1286 <_Z5func0i+0x36>
nopl 0x0(%rax,%rax,1)
| _Z5func0i:
endbr64
sub edi, 1
pxor xmm1, xmm1
sub rsp, 8
movsd xmm0, cs:x; x
cvtsi2sd xmm1, edi; y
call _pow
addsd xmm0, xmm0
sqrtsd xmm0, xmm0; x
call _round
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
double v1; // xmm0_8
v1 = pow(10.0, (double)(a1 - 1));
return (unsigned int)(int)round(sqrt(v1 + v1));
} | func0:
ENDBR64
SUB EDI,0x1
PXOR XMM1,XMM1
SUB RSP,0x8
MOVSD XMM0,qword ptr [0x00102068]
CVTSI2SD XMM1,EDI
CALL 0x00101080
ADDSD XMM0,XMM0
SQRTSD XMM0,XMM0
CALL 0x00101070
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = pow(DAT_00102068,(double)(param_1 + -1));
dVar1 = round(SQRT(dVar1 + dVar1));
return (int)dVar1;
} |
2,956 | func0 | #include <cassert>
#include <map>
#include <vector>
| std::map<int, int> func0(const std::vector<int>& test_tup) {
std::map<int, int> res;
for (size_t i = 0; i < test_tup.size(); i += 2) {
res[test_tup[i]] = test_tup[i + 1];
}
return res;
}
| int main() {
{
std::map<int, int> expected = {{1, 5}, {7, 10}, {13, 5}};
assert(func0({1, 5, 7, 10, 13, 5}) == expected);
}
{
std::map<int, int> expected = {{1, 2}, {3, 4}, {5, 6}};
assert(func0({1, 2, 3, 4, 5, 6}) == expected);
}
{
std::map<int, int> expected = {{7, 8}, {9, 10}, {11, 12}};
assert(func0({7, 8, 9, 10, 11, 12}) == expected);
}
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b70 <_ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEC1Ev>
movq $0x0,-0x20(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1c4a <_ZNKSt6vectorIiSaIiEE4sizeEv>
cmp %rax,-0x20(%rbp)
setb %al
test %al,%al
je 13bd <_Z5func0RKSt6vectorIiSaIiEE+0xb4>
mov -0x20(%rbp),%rax
lea 0x1(%rax),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c72 <_ZNKSt6vectorIiSaIiEEixEm>
mov (%rax),%ebx
mov -0x20(%rbp),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c72 <_ZNKSt6vectorIiSaIiEEixEm>
mov %rax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1c96 <_ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEixERS3_>
mov %ebx,(%rax)
addq $0x2,-0x20(%rbp)
jmp 1341 <_Z5func0RKSt6vectorIiSaIiEE+0x38>
endbr64
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1b90 <_ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 1210 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 13d2 <_Z5func0RKSt6vectorIiSaIiEE+0xc9>
callq 11c0 <__stack_chk_fail@plt>
mov -0x28(%rbp),%rax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEC2Ev; std::map<int,int>::map(void)
mov [rbp+var_18], 0
jmp short loc_1399
loc_1354:
mov rax, [rbp+var_18]
lea rdx, [rax+1]
mov rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov ebx, [rax]
mov rdx, [rbp+var_18]
mov rax, [rbp+var_30]
mov rsi, rdx
mov rdi, rax
call _ZNKSt6vectorIiSaIiEEixEm; std::vector<int>::operator[](ulong)
mov rdx, rax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEEixERS3_; std::map<int,int>::operator[](int const&)
mov [rax], ebx
add [rbp+var_18], 2
loc_1399:
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
cmp [rbp+var_18], rax
setb al
test al, al
jnz short loc_1354
jmp short loc_13D0
endbr64
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt3mapIiiSt4lessIiESaISt4pairIKiiEEED2Ev; std::map<int,int>::~map()
mov rax, rbx
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_13D0:
mov rax, [rbp+var_28]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, long long a2)
{
int v2; // ebx
long long v3; // rax
unsigned long long i; // [rsp+18h] [rbp-18h]
std::map<int,int>::map(a1);
for ( i = 0LL; i < std::vector<int>::size(a2); i += 2LL )
{
v2 = *(_DWORD *)std::vector<int>::operator[](a2, i + 1);
v3 = std::vector<int>::operator[](a2, i);
*(_DWORD *)std::map<int,int>::operator[](a1, v3) = v2;
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101be8
MOV qword ptr [RBP + -0x18],0x0
JMP 0x00101399
LAB_00101354:
MOV RAX,qword ptr [RBP + -0x18]
LEA RDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101cd0
MOV EBX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101cd0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
LAB_0010138d:
CALL 0x00101cf4
MOV dword ptr [RAX],EBX
ADD qword ptr [RBP + -0x18],0x2
LAB_00101399:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101ca8
CMP qword ptr [RBP + -0x18],RAX
SETC AL
TEST AL,AL
JNZ 0x00101354
JMP 0x001013d0
LAB_001013d0:
MOV RAX,qword ptr [RBP + -0x28]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
int4 uVar1;
int4 *puVar2;
int *piVar3;
ulong uVar4;
vector<int,std::allocator<int>> *in_RSI;
int8 local_20;
std::map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>>::map
((map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>> *)param_1);
local_20 = 0;
while( true ) {
uVar4 = std::vector<int,std::allocator<int>>::size(in_RSI);
if (uVar4 <= local_20) break;
puVar2 = (int4 *)std::vector<int,std::allocator<int>>::operator[](in_RSI,local_20 + 1);
uVar1 = *puVar2;
piVar3 = (int *)std::vector<int,std::allocator<int>>::operator[](in_RSI,local_20);
/* try { // try from 0010138d to 00101391 has its CatchHandler @ 001013b2 */
puVar2 = (int4 *)
std::map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>>::operator[]
((map<int,int,std::less<int>,std::allocator<std::pair<int_const,int>>> *)
param_1,piVar3);
*puVar2 = uVar1;
local_20 = local_20 + 2;
}
return param_1;
} |
2,957 | func0 | #include <cassert>
#include <map>
#include <vector>
| std::map<int, int> func0(const std::vector<int>& test_tup) {
std::map<int, int> res;
for (size_t i = 0; i < test_tup.size(); i += 2) {
res[test_tup[i]] = test_tup[i + 1];
}
return res;
}
| int main() {
{
std::map<int, int> expected = {{1, 5}, {7, 10}, {13, 5}};
assert(func0({1, 5, 7, 10, 13, 5}) == expected);
}
{
std::map<int, int> expected = {{1, 2}, {3, 4}, {5, 6}};
assert(func0({1, 2, 3, 4, 5, 6}) == expected);
}
{
std::map<int, int> expected = {{7, 8}, {9, 10}, {11, 12}};
assert(func0({7, 8, 9, 10, 11, 12}) == expected);
}
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%r12
movl $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
lea 0x8(%rdi),%r13
mov %r13,0x18(%rdi)
mov %r13,0x20(%rdi)
movq $0x0,0x28(%rdi)
mov (%rsi),%rdx
cmp %rdx,0x8(%rsi)
je 13f1 <_Z5func0RKSt6vectorIiSaIiEE+0x168>
mov %rsi,%r14
mov $0x0,%ebp
mov %rdi,0x8(%rsp)
jmpq 1391 <_Z5func0RKSt6vectorIiSaIiEE+0x108>
mov 0x18(%rax),%rax
test %rax,%rax
je 12f7 <_Z5func0RKSt6vectorIiSaIiEE+0x6e>
cmp %edx,0x20(%rax)
jl 12e0 <_Z5func0RKSt6vectorIiSaIiEE+0x57>
mov %rax,%rbx
mov 0x10(%rax),%rax
jmp 12e4 <_Z5func0RKSt6vectorIiSaIiEE+0x5b>
cmp %rbx,%r13
je 1301 <_Z5func0RKSt6vectorIiSaIiEE+0x78>
cmp %edx,0x20(%rbx)
jle 1373 <_Z5func0RKSt6vectorIiSaIiEE+0xea>
mov 0x8(%rsp),%rax
mov %rax,0x18(%rsp)
mov %rbx,0x10(%rsp)
mov $0x28,%edi
callq 1150 <_Znwm@plt>
jmp 1321 <_Z5func0RKSt6vectorIiSaIiEE+0x98>
mov %r13,%rbx
jmp 1301 <_Z5func0RKSt6vectorIiSaIiEE+0x78>
mov %rax,%rbx
mov (%r15),%eax
mov %eax,0x20(%rbx)
movl $0x0,0x24(%rbx)
lea 0x20(%rbx),%rdx
mov 0x10(%rsp),%rsi
mov 0x8(%rsp),%rdi
callq 1a76 <_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_>
mov %rax,%r15
test %rdx,%rdx
je 13c6 <_Z5func0RKSt6vectorIiSaIiEE+0x13d>
test %rax,%rax
setne %dil
cmp %rdx,%r13
sete %al
or %al,%dil
je 13ba <_Z5func0RKSt6vectorIiSaIiEE+0x131>
movzbl %dil,%edi
mov %r13,%rcx
mov %rbx,%rsi
callq 10f0 <_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_@plt>
addq $0x1,0x28(%r12)
mov 0x4(%rsp),%eax
mov %eax,0x24(%rbx)
add $0x2,%rbp
mov (%r14),%rdx
mov 0x8(%r14),%rax
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbp
jae 13f1 <_Z5func0RKSt6vectorIiSaIiEE+0x168>
lea 0x1(%rbp),%rax
mov (%rdx,%rax,4),%ecx
mov %ecx,0x4(%rsp)
lea -0x4(%rdx,%rax,4),%r15
mov 0x10(%r12),%rax
test %rax,%rax
je 131c <_Z5func0RKSt6vectorIiSaIiEE+0x93>
mov (%r15),%edx
mov %r13,%rbx
jmpq 12e9 <_Z5func0RKSt6vectorIiSaIiEE+0x60>
mov 0x20(%rdx),%eax
cmp %eax,0x20(%rbx)
setl %dil
jmp 135e <_Z5func0RKSt6vectorIiSaIiEE+0xd5>
mov %rbx,%rdi
callq 1140 <_ZdlPv@plt>
mov %r15,%rbx
jmp 1373 <_Z5func0RKSt6vectorIiSaIiEE+0xea>
endbr64
mov %rax,%rbx
mov 0x10(%r12),%rsi
mov 0x18(%rsp),%rdi
callq 1940 <_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE8_M_eraseEPSt13_Rb_tree_nodeIS2_E>
mov %rbx,%rdi
callq 1190 <_Unwind_Resume@plt>
mov %r12,%rax
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r12, rdi
mov dword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
lea r13, [rdi+8]
mov [rdi+18h], r13
mov [rdi+20h], r13
mov qword ptr [rdi+28h], 0
mov rdx, [rsi]
cmp rdx, [rsi+8]
jz loc_13E6
mov r14, rsi
mov ebp, 0
jmp loc_1383
loc_12DB:
mov rax, [rax+18h]
loc_12DF:
test rax, rax
jz short loc_12F2
loc_12E4:
cmp [rax+20h], edx
jl short loc_12DB
mov rbx, rax
mov rax, [rax+10h]
jmp short loc_12DF
loc_12F2:
cmp r13, rbx
jz short loc_12FC
cmp [rbx+20h], edx
jle short loc_1365
loc_12FC:
mov [rsp+48h+var_40], rbx
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
jmp short loc_1312
loc_130D:
mov rbx, r13
jmp short loc_12FC
loc_1312:
mov rbx, rax
mov r15d, [r15]
mov [rax+20h], r15d
mov dword ptr [rax+24h], 0
lea rdx, [rax+20h]
mov rsi, [rsp+48h+var_40]
mov rdi, r12
call _ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<int const,int>>,int const&)
mov [rsp+48h+var_40], rax
test rdx, rdx
jz short loc_13B6
cmp r13, rdx
setz dil
test rax, rax
setnz al
or dil, al
jz short loc_13AC
loc_1350:
movzx edi, dil
mov rcx, r13
mov rsi, rbx
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_1365:
mov eax, [rsp+48h+var_44]
mov [rbx+24h], eax
add rbp, 2
mov rdx, [r14]
mov rax, [r14+8]
sub rax, rdx
sar rax, 2
cmp rbp, rax
jnb short loc_13E6
loc_1383:
lea rax, [rbp+1]
mov ecx, [rdx+rax*4]
mov [rsp+48h+var_44], ecx
lea r15, [rdx+rax*4-4]
mov rax, [r12+10h]
test rax, rax
jz loc_130D
mov edx, [r15]
mov rbx, r13
jmp loc_12E4
loc_13AC:
cmp r15d, [rdx+20h]
setl dil
jmp short loc_1350
loc_13B6:
mov esi, 28h ; '('; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rbx, [rsp+48h+var_40]
jmp short loc_1365
endbr64
mov rbx, rax
mov rsi, [r12+10h]
mov rdi, r12
call _ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE8_M_eraseEPSt13_Rb_tree_nodeIS2_E; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::_M_erase(std::_Rb_tree_node<std::pair<int const,int>> *)
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_13E6:
mov rax, r12
add rsp, 18h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn | long long func0(long long a1, long long *a2)
{
_DWORD *v3; // r13
long long v4; // rdx
unsigned long long i; // rbp
long long v6; // rax
_DWORD *v7; // rbx
unsigned int v8; // r15d
long long insert_hint_unique_pos; // rax
_DWORD *v10; // rdx
bool v11; // di
unsigned int *v12; // r15
int v13; // edx
int v15; // [rsp+4h] [rbp-44h]
_DWORD *v16; // [rsp+8h] [rbp-40h]
_DWORD *v17; // [rsp+8h] [rbp-40h]
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)(a1 + 16) = 0LL;
v3 = (_DWORD *)(a1 + 8);
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v4 = *a2;
if ( *a2 != a2[1] )
{
for ( i = 0LL; i < (a2[1] - *a2) >> 2; i += 2LL )
{
v15 = *(_DWORD *)(v4 + 4 * (i + 1));
v12 = (unsigned int *)(v4 + 4 * (i + 1) - 4);
v6 = *(_QWORD *)(a1 + 16);
if ( v6 )
{
v13 = *v12;
v7 = v3;
do
{
if ( *(_DWORD *)(v6 + 32) < v13 )
{
v6 = *(_QWORD *)(v6 + 24);
}
else
{
v7 = (_DWORD *)v6;
v6 = *(_QWORD *)(v6 + 16);
}
}
while ( v6 );
if ( v3 != v7 && v7[8] <= v13 )
goto LABEL_15;
}
else
{
v7 = v3;
}
v16 = v7;
v7 = (_DWORD *)operator new(0x28uLL);
v8 = *v12;
*((_QWORD *)v7 + 4) = v8;
insert_hint_unique_pos = std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::_M_get_insert_hint_unique_pos(
a1,
v16,
v7 + 8);
v17 = (_DWORD *)insert_hint_unique_pos;
if ( v10 )
{
v11 = insert_hint_unique_pos != 0 || v3 == v10;
if ( !v11 )
v11 = (int)v8 < v10[8];
std::_Rb_tree_insert_and_rebalance(v11, v7, v10, v3);
++*(_QWORD *)(a1 + 40);
}
else
{
operator delete(v7, 0x28uLL);
v7 = v17;
}
LABEL_15:
v7[9] = v15;
v4 = *a2;
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R12,RDI
MOV dword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R13,[RDI + 0x8]
MOV qword ptr [RDI + 0x18],R13
MOV qword ptr [RDI + 0x20],R13
MOV qword ptr [RDI + 0x28],0x0
MOV RDX,qword ptr [RSI]
CMP RDX,qword ptr [RSI + 0x8]
JZ 0x001013e6
MOV R14,RSI
MOV EBP,0x0
JMP 0x00101383
LAB_001012db:
MOV RAX,qword ptr [RAX + 0x18]
LAB_001012df:
TEST RAX,RAX
JZ 0x001012f2
LAB_001012e4:
CMP dword ptr [RAX + 0x20],EDX
JL 0x001012db
MOV RBX,RAX
MOV RAX,qword ptr [RAX + 0x10]
JMP 0x001012df
LAB_001012f2:
CMP R13,RBX
JZ 0x001012fc
CMP dword ptr [RBX + 0x20],EDX
JLE 0x00101365
LAB_001012fc:
MOV qword ptr [RSP + 0x8],RBX
MOV EDI,0x28
LAB_00101306:
CALL 0x00101140
JMP 0x00101312
LAB_0010130d:
MOV RBX,R13
JMP 0x001012fc
LAB_00101312:
MOV RBX,RAX
MOV R15D,dword ptr [R15]
MOV dword ptr [RAX + 0x20],R15D
MOV dword ptr [RAX + 0x24],0x0
LEA RDX,[RAX + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,R12
CALL 0x00101ad4
MOV qword ptr [RSP + 0x8],RAX
TEST RDX,RDX
JZ 0x001013b6
CMP R13,RDX
SETZ DIL
TEST RAX,RAX
SETNZ AL
OR DIL,AL
JZ 0x001013ac
LAB_00101350:
MOVZX EDI,DIL
MOV RCX,R13
MOV RSI,RBX
CALL 0x001010f0
ADD qword ptr [R12 + 0x28],0x1
LAB_00101365:
MOV EAX,dword ptr [RSP + 0x4]
MOV dword ptr [RBX + 0x24],EAX
ADD RBP,0x2
MOV RDX,qword ptr [R14]
MOV RAX,qword ptr [R14 + 0x8]
SUB RAX,RDX
SAR RAX,0x2
CMP RBP,RAX
JNC 0x001013e6
LAB_00101383:
LEA RAX,[RBP + 0x1]
MOV ECX,dword ptr [RDX + RAX*0x4]
MOV dword ptr [RSP + 0x4],ECX
LEA R15,[RDX + RAX*0x4 + -0x4]
MOV RAX,qword ptr [R12 + 0x10]
TEST RAX,RAX
JZ 0x0010130d
MOV EDX,dword ptr [R15]
MOV RBX,R13
JMP 0x001012e4
LAB_001013ac:
CMP R15D,dword ptr [RDX + 0x20]
SETL DIL
JMP 0x00101350
LAB_001013b6:
MOV ESI,0x28
MOV RDI,RBX
CALL 0x00101150
MOV RBX,qword ptr [RSP + 0x8]
JMP 0x00101365
LAB_001013e6:
MOV RAX,R12
ADD RSP,0x18
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int *piVar2;
int4 uVar3;
int iVar4;
bool bVar5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
long lVar8;
_Rb_tree_node_base *p_Var9;
ulong uVar10;
long *in_RSI;
int auVar11 [16];
*(int4 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
*(_Rb_tree_node_base **)(param_1 + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(param_1 + 0x20) = p_Var1;
*(int8 *)(param_1 + 0x28) = 0;
lVar8 = *in_RSI;
if (lVar8 != in_RSI[1]) {
uVar10 = 0;
do {
uVar3 = *(int4 *)(lVar8 + (uVar10 + 1) * 4);
piVar2 = (int *)(lVar8 + -4 + (uVar10 + 1) * 4);
p_Var9 = p_Var1;
if (*(_Rb_tree_node_base **)(param_1 + 0x10) == (_Rb_tree_node_base *)0x0) {
LAB_001012fc:
/* try { // try from 00101306 to 0010130a has its CatchHandler @ 001013ca */
p_Var7 = (_Rb_tree_node_base *)operator_new(0x28);
iVar4 = *piVar2;
*(int *)(p_Var7 + 0x20) = iVar4;
*(int4 *)(p_Var7 + 0x24) = 0;
auVar11 = std::
_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
::_M_get_insert_hint_unique_pos
((_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
*)param_1,(_Rb_tree_const_iterator)p_Var9,(int *)(p_Var7 + 0x20));
p_Var6 = auVar11._8_8_;
p_Var9 = auVar11._0_8_;
if (p_Var6 == (_Rb_tree_node_base *)0x0) {
operator_delete(p_Var7,0x28);
}
else {
bVar5 = p_Var1 == p_Var6 || p_Var9 != (_Rb_tree_node_base *)0x0;
if (p_Var1 != p_Var6 && p_Var9 == (_Rb_tree_node_base *)0x0) {
bVar5 = iVar4 < *(int *)(p_Var6 + 0x20);
}
std::_Rb_tree_insert_and_rebalance(bVar5,p_Var7,p_Var6,p_Var1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
p_Var9 = p_Var7;
}
}
else {
iVar4 = *piVar2;
p_Var7 = *(_Rb_tree_node_base **)(param_1 + 0x10);
do {
if (*(int *)(p_Var7 + 0x20) < iVar4) {
p_Var6 = *(_Rb_tree_node_base **)(p_Var7 + 0x18);
}
else {
p_Var6 = *(_Rb_tree_node_base **)(p_Var7 + 0x10);
p_Var9 = p_Var7;
}
p_Var7 = p_Var6;
} while (p_Var6 != (_Rb_tree_node_base *)0x0);
if ((p_Var1 == p_Var9) || (iVar4 < *(int *)(p_Var9 + 0x20))) goto LAB_001012fc;
}
*(int4 *)(p_Var9 + 0x24) = uVar3;
uVar10 = uVar10 + 2;
lVar8 = *in_RSI;
} while (uVar10 < (ulong)(in_RSI[1] - lVar8 >> 2));
}
return param_1;
} |
2,958 | func0 | #include <cassert>
#include <map>
#include <vector>
| std::map<int, int> func0(const std::vector<int>& test_tup) {
std::map<int, int> res;
for (size_t i = 0; i < test_tup.size(); i += 2) {
res[test_tup[i]] = test_tup[i + 1];
}
return res;
}
| int main() {
{
std::map<int, int> expected = {{1, 5}, {7, 10}, {13, 5}};
assert(func0({1, 5, 7, 10, 13, 5}) == expected);
}
{
std::map<int, int> expected = {{1, 2}, {3, 4}, {5, 6}};
assert(func0({1, 2, 3, 4, 5, 6}) == expected);
}
{
std::map<int, int> expected = {{7, 8}, {9, 10}, {11, 12}};
assert(func0({7, 8, 9, 10, 11, 12}) == expected);
}
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi),%rbp
push %rbx
sub $0x18,%rsp
movl $0x0,0x8(%rdi)
mov (%rsi),%rdx
movq $0x0,0x10(%rdi)
mov %rbp,0x18(%rdi)
mov %rbp,0x20(%rdi)
movq $0x0,0x28(%rdi)
cmp 0x8(%rsi),%rdx
je 1840 <_Z5func0RKSt6vectorIiSaIiEE+0x140>
mov %rsi,%r14
xor %eax,%eax
xor %ebx,%ebx
nopl 0x0(%rax)
lea 0x1(%rbx),%rcx
mov (%rdx,%rcx,4),%r15d
lea -0x4(%rdx,%rcx,4),%r13
test %rax,%rax
je 1858 <_Z5func0RKSt6vectorIiSaIiEE+0x158>
mov 0x0(%r13),%ecx
mov %rbp,%r8
jmp 177c <_Z5func0RKSt6vectorIiSaIiEE+0x7c>
mov %rax,%r8
mov 0x10(%rax),%rax
test %rax,%rax
je 178a <_Z5func0RKSt6vectorIiSaIiEE+0x8a>
cmp %ecx,0x20(%rax)
jge 1770 <_Z5func0RKSt6vectorIiSaIiEE+0x70>
mov 0x18(%rax),%rax
test %rax,%rax
jne 177c <_Z5func0RKSt6vectorIiSaIiEE+0x7c>
cmp %r8,%rbp
je 1795 <_Z5func0RKSt6vectorIiSaIiEE+0x95>
cmp 0x20(%r8),%ecx
jge 1803 <_Z5func0RKSt6vectorIiSaIiEE+0x103>
mov $0x28,%edi
mov %r8,(%rsp)
callq 1150 <_Znwm@plt>
mov %rax,%r8
mov 0x0(%r13),%eax
mov (%rsp),%rsi
mov %r12,%rdi
movl $0x0,0x24(%r8)
lea 0x20(%r8),%rdx
mov %eax,0x20(%r8)
mov %r8,0x8(%rsp)
callq 1a20 <_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_>
mov 0x8(%rsp),%r8
test %rdx,%rdx
mov %rax,%r13
je 1828 <_Z5func0RKSt6vectorIiSaIiEE+0x128>
test %rax,%rax
jne 17e2 <_Z5func0RKSt6vectorIiSaIiEE+0xe2>
cmp %rdx,%rbp
jne 1860 <_Z5func0RKSt6vectorIiSaIiEE+0x160>
mov $0x1,%edi
mov %r8,%rsi
mov %rbp,%rcx
mov %r8,(%rsp)
callq 10f0 <_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_@plt>
addq $0x1,0x28(%r12)
mov (%r14),%rdx
mov (%rsp),%r8
mov 0x8(%r14),%rax
add $0x2,%rbx
mov %r15d,0x24(%r8)
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 1840 <_Z5func0RKSt6vectorIiSaIiEE+0x140>
mov 0x10(%r12),%rax
jmpq 1750 <_Z5func0RKSt6vectorIiSaIiEE+0x50>
nopl (%rax)
mov %r8,%rdi
callq 1140 <_ZdlPv@plt>
mov (%r14),%rdx
mov %r13,%r8
jmp 1803 <_Z5func0RKSt6vectorIiSaIiEE+0x103>
nopl 0x0(%rax,%rax,1)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %rbp,%r8
jmpq 1795 <_Z5func0RKSt6vectorIiSaIiEE+0x95>
xor %edi,%edi
mov 0x20(%rdx),%eax
cmp %eax,0x20(%r8)
setl %dil
jmpq 17e7 <_Z5func0RKSt6vectorIiSaIiEE+0xe7>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0RKSt6vectorIiSaIiEE.cold>
xchg %ax,%ax
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
lea r13, [rdi+8]
push r12
mov r12, rdi
push rbp
push rbx
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]
cmp [rsi+8], rdi
jz loc_1A58
mov r14, rsi
xor eax, eax
xor ebp, ebp
nop dword ptr [rax+00h]
loc_1960:
lea rbx, ds:0[rbp*4]
mov r15d, [rdi+rbx+4]
add rbx, rdi
test rax, rax
jz loc_1A70
mov esi, [rbx]
mov r8, r13
jmp short loc_1988
loc_1980:
mov rax, rcx
test rax, rax
jz short loc_19A0
loc_1988:
mov rdx, [rax+10h]
mov rcx, [rax+18h]
cmp esi, [rax+20h]
jg short loc_1980
mov r8, rax
mov rax, rdx
test rax, rax
jnz short loc_1988
loc_19A0:
cmp r13, r8
jz short loc_19AB
cmp esi, [r8+20h]
jge short loc_1A11
loc_19AB:
mov edi, 28h ; '('; unsigned __int64
mov [rsp+48h+var_48], r8
call __Znwm; operator new(ulong)
mov ebx, [rbx]
mov rsi, [rsp+48h+var_48]
mov dword ptr [rax+24h], 0
mov rdi, r12
mov [rsp+48h+var_40], rax
mov [rax+20h], ebx
mov edx, ebx
call _ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1__isra_0; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::_M_get_insert_hint_unique_pos(std::_Rb_tree_const_iterator<std::pair<int const,int>>,int const&) [clone]
mov r8, [rsp+48h+var_40]
test rdx, rdx
jz short loc_1A38
cmp r13, rdx
jz short loc_19F0
test rax, rax
jz loc_1A78
loc_19F0:
mov edi, 1
loc_19F5:
mov rsi, r8
mov rcx, r13
mov [rsp+48h+var_48], r8
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
mov rdi, [r14]
mov r8, [rsp+48h+var_48]
loc_1A11:
mov rax, [r14+8]
add rbp, 2
mov [r8+24h], r15d
sub rax, rdi
sar rax, 2
cmp rbp, rax
jnb short loc_1A58
mov rax, [r12+10h]
jmp loc_1960
loc_1A38:
mov rdi, r8; void *
mov esi, 28h ; '('; unsigned __int64
mov [rsp+48h+var_48], rax
call __ZdlPvm; operator delete(void *,ulong)
mov r8, [rsp+48h+var_48]
mov rdi, [r14]
jmp short loc_1A11
loc_1A58:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1A70:
mov r8, r13
jmp loc_19AB
loc_1A78:
xor edi, edi
cmp ebx, [rdx+20h]
setl dil
jmp loc_19F5
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEE_cold; func0(std::vector<int> const&) [clone] | _QWORD * func0(_QWORD *a1, long long *a2)
{
_DWORD *v2; // r13
long long v4; // rdi
long long v6; // rax
unsigned long long v7; // rbp
int v8; // r15d
unsigned int *v9; // rbx
int v10; // esi
_DWORD *v11; // r8
long long v12; // rdx
long long v13; // rcx
_DWORD *v14; // rax
unsigned int v15; // ebx
long long insert_hint_unique_pos; // rax
_DWORD *v17; // rdx
_BOOL8 v18; // rdi
long long v19; // rax
_DWORD *v21; // [rsp+0h] [rbp-48h]
long long v22; // [rsp+0h] [rbp-48h]
_DWORD *v23; // [rsp+8h] [rbp-40h]
v2 = a1 + 1;
*((_DWORD *)a1 + 2) = 0;
a1[2] = 0LL;
a1[3] = a1 + 1;
a1[4] = a1 + 1;
a1[5] = 0LL;
v4 = *a2;
if ( a2[1] != *a2 )
{
v6 = 0LL;
v7 = 0LL;
while ( 1 )
{
v8 = *(_DWORD *)(v4 + 4 * v7 + 4);
v9 = (unsigned int *)(v4 + 4 * v7);
if ( !v6 )
break;
v10 = *v9;
v11 = v2;
do
{
while ( 1 )
{
v12 = *(_QWORD *)(v6 + 16);
v13 = *(_QWORD *)(v6 + 24);
if ( v10 <= *(_DWORD *)(v6 + 32) )
break;
v6 = *(_QWORD *)(v6 + 24);
if ( !v13 )
goto LABEL_8;
}
v11 = (_DWORD *)v6;
v6 = *(_QWORD *)(v6 + 16);
}
while ( v12 );
LABEL_8:
if ( v2 == v11 || v10 < v11[8] )
goto LABEL_10;
LABEL_15:
v19 = a2[1];
v7 += 2LL;
v11[9] = v8;
if ( v7 >= (v19 - v4) >> 2 )
return a1;
v6 = a1[2];
}
v11 = v2;
LABEL_10:
v21 = v11;
v14 = (_DWORD *)operator new(0x28uLL);
v15 = *v9;
v14[9] = 0;
v23 = v14;
v14[8] = v15;
insert_hint_unique_pos = std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::_M_get_insert_hint_unique_pos(
a1,
v21,
v15);
if ( v17 )
{
v18 = v2 == v17 || insert_hint_unique_pos || (int)v15 < v17[8];
std::_Rb_tree_insert_and_rebalance(v18, v23, v17, v2);
++a1[5];
v4 = *a2;
v11 = v23;
}
else
{
v22 = insert_hint_unique_pos;
operator delete(v23, 0x28uLL);
v11 = (_DWORD *)v22;
v4 = *a2;
}
goto LABEL_15;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
LEA R13,[RDI + 0x8]
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
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]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x00101a58
MOV R14,RSI
XOR EAX,EAX
XOR EBP,EBP
NOP dword ptr [RAX]
LAB_00101960:
LEA RBX,[RBP*0x4]
MOV R15D,dword ptr [RDI + RBX*0x1 + 0x4]
ADD RBX,RDI
TEST RAX,RAX
JZ 0x00101a70
MOV ESI,dword ptr [RBX]
MOV R8,R13
JMP 0x00101988
LAB_00101980:
MOV RAX,RCX
TEST RAX,RAX
JZ 0x001019a0
LAB_00101988:
MOV RDX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RAX + 0x18]
CMP ESI,dword ptr [RAX + 0x20]
JG 0x00101980
MOV R8,RAX
MOV RAX,RDX
TEST RAX,RAX
JNZ 0x00101988
LAB_001019a0:
CMP R13,R8
JZ 0x001019ab
CMP ESI,dword ptr [R8 + 0x20]
JGE 0x00101a11
LAB_001019ab:
MOV EDI,0x28
MOV qword ptr [RSP],R8
LAB_001019b4:
CALL 0x00101140
MOV EBX,dword ptr [RBX]
MOV RSI,qword ptr [RSP]
MOV dword ptr [RAX + 0x24],0x0
MOV RDI,R12
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RAX + 0x20],EBX
MOV EDX,EBX
CALL 0x00101660
MOV R8,qword ptr [RSP + 0x8]
TEST RDX,RDX
JZ 0x00101a38
CMP R13,RDX
JZ 0x001019f0
TEST RAX,RAX
JZ 0x00101a78
LAB_001019f0:
MOV EDI,0x1
LAB_001019f5:
MOV RSI,R8
MOV RCX,R13
MOV qword ptr [RSP],R8
CALL 0x001010f0
ADD qword ptr [R12 + 0x28],0x1
MOV RDI,qword ptr [R14]
MOV R8,qword ptr [RSP]
LAB_00101a11:
MOV RAX,qword ptr [R14 + 0x8]
ADD RBP,0x2
MOV dword ptr [R8 + 0x24],R15D
SUB RAX,RDI
SAR RAX,0x2
CMP RBP,RAX
JNC 0x00101a58
MOV RAX,qword ptr [R12 + 0x10]
JMP 0x00101960
LAB_00101a38:
MOV RDI,R8
MOV ESI,0x28
MOV qword ptr [RSP],RAX
CALL 0x00101150
MOV R8,qword ptr [RSP]
MOV RDI,qword ptr [R14]
JMP 0x00101a11
LAB_00101a58:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101a70:
MOV R8,R13
JMP 0x001019ab
LAB_00101a78:
XOR EDI,EDI
CMP EBX,dword ptr [RDX + 0x20]
SETL DIL
JMP 0x001019f5 | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int4 uVar2;
uint uVar3;
long lVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
uint *puVar7;
ulong uVar8;
long *in_RSI;
bool bVar9;
long lVar10;
_Rb_tree_node_base *p_Var11;
int auVar12 [16];
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
*(int4 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(_Rb_tree_node_base **)(param_1 + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(param_1 + 0x20) = p_Var1;
*(int8 *)(param_1 + 0x28) = 0;
lVar10 = *in_RSI;
if (in_RSI[1] == lVar10) {
return param_1;
}
p_Var5 = (_Rb_tree_node_base *)0x0;
uVar8 = 0;
do {
uVar2 = *(int4 *)(lVar10 + 4 + uVar8 * 4);
puVar7 = (uint *)(uVar8 * 4 + lVar10);
p_Var11 = p_Var1;
if (p_Var5 == (_Rb_tree_node_base *)0x0) {
LAB_001019ab:
/* try { // try from 001019b4 to 001019b8 has its CatchHandler @ 00101a86 */
p_Var5 = (_Rb_tree_node_base *)operator_new(0x28);
uVar3 = *puVar7;
*(int4 *)(p_Var5 + 0x24) = 0;
*(uint *)(p_Var5 + 0x20) = uVar3;
auVar12 = std::
_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
::_M_get_insert_hint_unique_pos
((_Rb_tree<int,std::pair<int_const,int>,std::_Select1st<std::pair<int_const,int>>,std::less<int>,std::allocator<std::pair<int_const,int>>>
*)param_1,(_Rb_tree_const_iterator)p_Var11,(int *)(ulong)uVar3);
p_Var6 = auVar12._8_8_;
p_Var11 = auVar12._0_8_;
if (p_Var6 == (_Rb_tree_node_base *)0x0) {
operator_delete(p_Var5,0x28);
lVar10 = *in_RSI;
}
else {
if ((p_Var1 == p_Var6) || (p_Var11 != (_Rb_tree_node_base *)0x0)) {
bVar9 = true;
}
else {
bVar9 = (int)uVar3 < *(int *)(p_Var6 + 0x20);
}
std::_Rb_tree_insert_and_rebalance(bVar9,p_Var5,p_Var6,p_Var1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
lVar10 = *in_RSI;
p_Var11 = p_Var5;
}
}
else {
uVar3 = *puVar7;
do {
while( true ) {
p_Var6 = p_Var5;
if (*(int *)(p_Var6 + 0x20) < (int)uVar3) break;
p_Var5 = *(_Rb_tree_node_base **)(p_Var6 + 0x10);
p_Var11 = p_Var6;
if (*(_Rb_tree_node_base **)(p_Var6 + 0x10) == (_Rb_tree_node_base *)0x0)
goto LAB_001019a0;
}
p_Var5 = *(_Rb_tree_node_base **)(p_Var6 + 0x18);
} while (*(_Rb_tree_node_base **)(p_Var6 + 0x18) != (_Rb_tree_node_base *)0x0);
LAB_001019a0:
if ((p_Var1 == p_Var11) || ((int)uVar3 < *(int *)(p_Var11 + 0x20))) goto LAB_001019ab;
}
lVar4 = in_RSI[1];
uVar8 = uVar8 + 2;
*(int4 *)(p_Var11 + 0x24) = uVar2;
if ((ulong)(lVar4 - lVar10 >> 2) <= uVar8) {
return param_1;
}
p_Var5 = *(_Rb_tree_node_base **)(param_1 + 0x10);
} while( true );
} |
2,959 | func0 | #include <cassert>
#include <map>
#include <vector>
| std::map<int, int> func0(const std::vector<int>& test_tup) {
std::map<int, int> res;
for (size_t i = 0; i < test_tup.size(); i += 2) {
res[test_tup[i]] = test_tup[i + 1];
}
return res;
}
| int main() {
{
std::map<int, int> expected = {{1, 5}, {7, 10}, {13, 5}};
assert(func0({1, 5, 7, 10, 13, 5}) == expected);
}
{
std::map<int, int> expected = {{1, 2}, {3, 4}, {5, 6}};
assert(func0({1, 2, 3, 4, 5, 6}) == expected);
}
{
std::map<int, int> expected = {{7, 8}, {9, 10}, {11, 12}};
assert(func0({7, 8, 9, 10, 11, 12}) == expected);
}
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
lea 0x8(%rdi),%rbp
push %rbx
sub $0x18,%rsp
mov (%rsi),%rdx
movl $0x0,0x8(%rdi)
mov %rsi,0x8(%rsp)
mov 0x8(%rsi),%rsi
movq $0x0,0x10(%rdi)
mov %rbp,0x18(%rdi)
mov %rbp,0x20(%rdi)
movq $0x0,0x28(%rdi)
cmp %rsi,%rdx
je 17d0 <_Z5func0RKSt6vectorIiSaIiEE+0x140>
xor %eax,%eax
xor %ebx,%ebx
nopl 0x0(%rax)
lea 0x1(%rbx),%rcx
mov (%rdx,%rcx,4),%r14d
lea -0x4(%rdx,%rcx,4),%r13
test %rax,%rax
je 17e8 <_Z5func0RKSt6vectorIiSaIiEE+0x158>
mov 0x0(%r13),%ecx
mov %rbp,%r15
jmp 171c <_Z5func0RKSt6vectorIiSaIiEE+0x8c>
nopw 0x0(%rax,%rax,1)
mov %rax,%r15
mov 0x10(%rax),%rax
test %rax,%rax
je 172a <_Z5func0RKSt6vectorIiSaIiEE+0x9a>
cmp %ecx,0x20(%rax)
jge 1710 <_Z5func0RKSt6vectorIiSaIiEE+0x80>
mov 0x18(%rax),%rax
test %rax,%rax
jne 171c <_Z5func0RKSt6vectorIiSaIiEE+0x8c>
cmp %r15,%rbp
je 1735 <_Z5func0RKSt6vectorIiSaIiEE+0xa5>
cmp 0x20(%r15),%ecx
jge 179a <_Z5func0RKSt6vectorIiSaIiEE+0x10a>
mov $0x28,%edi
mov %r15,(%rsp)
callq 1150 <_Znwm@plt>
mov %rax,%r15
mov 0x0(%r13),%eax
mov (%rsp),%rsi
mov %r12,%rdi
movl $0x0,0x24(%r15)
lea 0x20(%r15),%rdx
mov %eax,0x20(%r15)
callq 1a60 <_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_>
mov %rax,%r13
test %rdx,%rdx
je 17c0 <_Z5func0RKSt6vectorIiSaIiEE+0x130>
test %rax,%rax
jne 1778 <_Z5func0RKSt6vectorIiSaIiEE+0xe8>
cmp %rdx,%rbp
jne 17f0 <_Z5func0RKSt6vectorIiSaIiEE+0x160>
mov $0x1,%edi
mov %rbp,%rcx
mov %r15,%rsi
callq 10f0 <_ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS0_RS_@plt>
addq $0x1,0x28(%r12)
mov 0x8(%rsp),%rax
mov (%rax),%rdx
mov 0x8(%rax),%rsi
mov %rsi,%rax
add $0x2,%rbx
mov %r14d,0x24(%r15)
sub %rdx,%rax
sar $0x2,%rax
cmp %rax,%rbx
jae 17d0 <_Z5func0RKSt6vectorIiSaIiEE+0x140>
mov 0x10(%r12),%rax
jmpq 16e8 <_Z5func0RKSt6vectorIiSaIiEE+0x58>
nopl 0x0(%rax,%rax,1)
mov %r15,%rdi
mov %r13,%r15
callq 1140 <_ZdlPv@plt>
jmp 178e <_Z5func0RKSt6vectorIiSaIiEE+0xfe>
nopl (%rax)
add $0x18,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov %rbp,%r15
jmpq 1735 <_Z5func0RKSt6vectorIiSaIiEE+0xa5>
xor %edi,%edi
mov 0x20(%rdx),%eax
cmp %eax,0x20(%r15)
setl %dil
jmpq 177d <_Z5func0RKSt6vectorIiSaIiEE+0xed>
endbr64
mov %rax,%rbp
jmpq 11a0 <_Z5func0RKSt6vectorIiSaIiEE.cold>
xchg %ax,%ax
| _Z5func0RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
lea r14, [rdi+8]
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov dword ptr [rdi+8], 0
mov r8, [rsi+8]
mov qword ptr [rdi+10h], 0
mov [rdi+18h], r14
mov [rdi+20h], r14
mov qword ptr [rdi+28h], 0
mov rdi, [rsi]
mov [rsp+58h+var_50], rsi
cmp r8, rdi
jz loc_1A48
xor ebx, ebx
xor r12d, r12d
nop word ptr [rax+rax+00h]
loc_17F8:
lea rbp, ds:0[r12*4]
mov r15d, [rdi+rbp+4]
add rbp, rdi
test rbx, rbx
jz loc_19E0
mov ecx, [rbp+0]
mov rsi, r14
nop word ptr [rax+rax+00000000h]
loc_1820:
mov rdx, [rbx+10h]
mov rax, [rbx+18h]
cmp ecx, [rbx+20h]
jle short loc_1842
loc_182D:
test rax, rax
jz short loc_1850
mov rbx, rax
mov rdx, [rbx+10h]
mov rax, [rbx+18h]
cmp ecx, [rbx+20h]
jg short loc_182D
loc_1842:
test rdx, rdx
jz short loc_1853
mov rsi, rbx
mov rbx, rdx
jmp short loc_1820
loc_1850:
mov rbx, rsi
loc_1853:
cmp r14, rbx
jz loc_19E0
cmp ecx, [rbx+20h]
jge loc_1919
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov edx, [rbp+0]
mov dword ptr [rax+24h], 0
mov rcx, rax
mov [rax+20h], edx
cmp edx, [rbx+20h]
jge loc_1940
mov rbp, [r13+18h]
mov dword ptr [rsp+58h+var_48], edx
cmp rbp, rbx
jz loc_1A65
mov rdi, rbx
mov [rsp+58h+var_40], rax
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
mov edx, dword ptr [rsp+58h+var_48]
mov rcx, [rsp+58h+var_40]
cmp edx, [rax+20h]
mov rsi, rax
jg loc_1A5A
mov rbx, [r13+10h]
test rbx, rbx
jnz short loc_18D3
jmp loc_1B62
loc_18D0:
mov rbx, rax
loc_18D3:
mov edi, [rbx+20h]
mov rax, [rbx+18h]
cmp edx, edi
cmovl rax, [rbx+10h]
setl r8b
test rax, rax
jnz short loc_18D0
mov rsi, rbx
test r8b, r8b
jnz loc_1AE2
cmp edi, edx
jl loc_19AE
xchg ax, ax
loc_1900:
mov esi, 28h ; '('; unsigned __int64
mov rdi, rcx; void *
call __ZdlPvm; operator delete(void *,ulong)
loc_190D:
mov rax, [rsp+58h+var_50]
mov r8, [rax+8]
mov rdi, [rax]
loc_1919:
mov rax, r8
add r12, 2
mov [rbx+24h], r15d
sub rax, rdi
sar rax, 2
cmp r12, rax
jnb loc_1A48
mov rbx, [r13+10h]
jmp loc_17F8
loc_1940:
jle short loc_1900
cmp [r13+20h], rbx
jz loc_1ABA
mov rdi, rbx
mov dword ptr [rsp+58h+var_40], edx
mov [rsp+58h+var_48], rax
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov edx, dword ptr [rsp+58h+var_40]
mov rcx, [rsp+58h+var_48]
cmp edx, [rax+20h]
mov rsi, rax
jl loc_1ACE
mov rbx, [r13+10h]
test rbx, rbx
jnz short loc_1983
jmp loc_1B6F
loc_1980:
mov rbx, rax
loc_1983:
mov edi, [rbx+20h]
mov rax, [rbx+18h]
cmp edx, edi
cmovl rax, [rbx+10h]
setl r8b
test rax, rax
jnz short loc_1980
mov rsi, rbx
test r8b, r8b
jnz loc_1B30
loc_19A6:
cmp edx, edi
jle loc_1900
loc_19AE:
mov rbx, rcx
loc_19B1:
xor eax, eax
loc_19B3:
cmp r14, rsi
jz short loc_19C0
test al, al
jz loc_1AB4
loc_19C0:
mov edi, 1
loc_19C5:
mov rdx, rsi
mov rcx, r14
mov rsi, rbx
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 [r13+28h], 1
jmp loc_190D
loc_19E0:
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov edx, [rbp+0]
cmp qword ptr [r13+28h], 0
mov rbx, rax
mov dword ptr [rax+24h], 0
mov [rax+20h], edx
jnz short loc_1A75
loc_1A01:
mov rbp, [r13+10h]
test rbp, rbp
jnz short loc_1A13
jmp loc_1B1B
loc_1A10:
mov rbp, rax
loc_1A13:
mov ecx, [rbp+20h]
mov rax, [rbp+18h]
cmp ecx, edx
cmovg rax, [rbp+10h]
setnle dil
test rax, rax
jnz short loc_1A10
mov rsi, rbp
test dil, dil
jnz short loc_1A87
cmp edx, ecx
jg loc_19B1
loc_1A3A:
mov rcx, rbx
mov rbx, rbp
jmp loc_1900
loc_1A48:
add rsp, 28h
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1A5A:
cmp qword ptr [rax+18h], 0
jz loc_19AE
loc_1A65:
mov rsi, rbx
mov edi, 1
mov rbx, rcx
jmp loc_19C5
loc_1A75:
mov rsi, [r13+20h]
cmp [rsi+20h], edx
jl loc_19B1
jmp loc_1A01
loc_1A87:
cmp [r13+18h], rbp
jz loc_19B1
loc_1A91:
mov rdi, rbp
mov dword ptr [rsp+58h+var_48], edx
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
mov edx, dword ptr [rsp+58h+var_48]
mov rsi, rbp
mov ecx, [rax+20h]
mov rbp, rax
cmp edx, ecx
jg loc_19B1
jmp short loc_1A3A
loc_1AB4:
mov rcx, rbx
mov rbx, rsi
loc_1ABA:
xor edi, edi
cmp [rbx+20h], edx
mov rsi, rbx
mov rbx, rcx
setnle dil
jmp loc_19C5
loc_1ACE:
cmp qword ptr [rbx+18h], 0
jz short loc_1ABA
mov rbx, rcx
mov eax, 1
jmp loc_19B3
loc_1AE2:
cmp rbp, rbx
jz loc_19AE
loc_1AEB:
mov rdi, rbx
mov dword ptr [rsp+58h+var_40], edx
mov [rsp+58h+var_48], rcx
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
mov edx, dword ptr [rsp+58h+var_40]
mov rsi, rbx
mov rcx, [rsp+58h+var_48]
mov edi, [rax+20h]
mov rbx, rax
cmp edi, edx
jl loc_19AE
jmp loc_1900
loc_1B1B:
mov rbp, r14
cmp r14, [r13+18h]
jnz loc_1A91
loc_1B28:
mov rsi, r14
jmp loc_19C0
loc_1B30:
cmp rbx, [r13+18h]
jz loc_19AE
loc_1B3A:
mov rdi, rbx
mov dword ptr [rsp+58h+var_40], edx
mov [rsp+58h+var_48], rcx
call __ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base *)
mov rsi, rbx
mov edx, dword ptr [rsp+58h+var_40]
mov rcx, [rsp+58h+var_48]
mov edi, [rax+20h]
mov rbx, rax
jmp loc_19A6
loc_1B62:
mov rbx, r14
cmp r14, rbp
jnz short loc_1AEB
loc_1B6A:
mov rbx, rcx
jmp short loc_1B28
loc_1B6F:
mov rbx, r14
cmp r14, [r13+18h]
jnz short loc_1B3A
jmp short loc_1B6A
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEE_cold; func0(std::vector<int> const&) [clone] | long long func0(long long a1, long long a2)
{
long long v2; // r14
long long v4; // r8
long long v5; // rdi
void *v6; // rbx
unsigned long long v7; // r12
int v8; // r15d
unsigned int *v9; // rbp
int v10; // ecx
void *v11; // rdx
_QWORD *v12; // rax
_DWORD *v13; // rax
long long v14; // rdx
void *v15; // rcx
void *v16; // rbp
long long v17; // rax
int v18; // edi
void *v19; // rax
long long v20; // rax
int v21; // edi
void *v22; // rax
char v23; // al
_BOOL8 v24; // rdi
long long v25; // rdx
_QWORD *v26; // rax
bool v27; // zf
long long v28; // rbp
int v29; // ecx
long long v30; // rax
long long v32; // rax
bool v33; // sf
bool v34; // of
long long v35; // rax
long long v36; // rax
long long *v37; // [rsp+8h] [rbp-50h]
int v38; // [rsp+10h] [rbp-48h]
void *v39; // [rsp+10h] [rbp-48h]
int v40; // [rsp+10h] [rbp-48h]
void *v41; // [rsp+10h] [rbp-48h]
void *v42; // [rsp+18h] [rbp-40h]
int v43; // [rsp+18h] [rbp-40h]
int v44; // [rsp+18h] [rbp-40h]
v2 = a1 + 8;
*(_DWORD *)(a1 + 8) = 0;
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a1 + 16) = 0LL;
*(_QWORD *)(a1 + 24) = a1 + 8;
*(_QWORD *)(a1 + 32) = a1 + 8;
*(_QWORD *)(a1 + 40) = 0LL;
v5 = *(_QWORD *)a2;
v37 = (long long *)a2;
if ( v4 != *(_QWORD *)a2 )
{
v6 = 0LL;
v7 = 0LL;
while ( 1 )
{
v8 = *(_DWORD *)(v5 + 4 * v7 + 4);
v9 = (unsigned int *)(v5 + 4 * v7);
if ( !v6 )
goto LABEL_45;
v10 = *v9;
a2 = v2;
while ( 1 )
{
v11 = (void *)*((_QWORD *)v6 + 2);
v12 = (_QWORD *)*((_QWORD *)v6 + 3);
if ( v10 > *((_DWORD *)v6 + 8) )
break;
LABEL_8:
if ( !v11 )
goto LABEL_11;
a2 = (long long)v6;
v6 = v11;
}
while ( v12 )
{
v6 = v12;
v11 = (void *)v12[2];
v12 = (_QWORD *)v12[3];
if ( v10 <= *((_DWORD *)v6 + 8) )
goto LABEL_8;
}
v6 = (void *)a2;
LABEL_11:
if ( (void *)v2 == v6 )
{
LABEL_45:
v26 = (_QWORD *)operator new(0x28uLL);
LODWORD(v14) = *v9;
v27 = *(_QWORD *)(a1 + 40) == 0LL;
v6 = v26;
v26[4] = *v9;
if ( !v27 )
{
a2 = *(_QWORD *)(a1 + 32);
if ( *(_DWORD *)(a2 + 32) < (int)v14 )
goto LABEL_40;
}
v28 = *(_QWORD *)(a1 + 16);
if ( v28 )
{
while ( 1 )
{
v29 = *(_DWORD *)(v28 + 32);
v30 = *(_QWORD *)(v28 + 24);
if ( v29 > (int)v14 )
v30 = *(_QWORD *)(v28 + 16);
if ( !v30 )
break;
v28 = v30;
}
a2 = v28;
if ( v29 > (int)v14 )
{
if ( *(_QWORD *)(a1 + 24) == v28 )
goto LABEL_40;
goto LABEL_61;
}
if ( (int)v14 > v29 )
goto LABEL_40;
}
else
{
v28 = v2;
if ( v2 == *(_QWORD *)(a1 + 24) )
goto LABEL_71;
LABEL_61:
v40 = v14;
v32 = std::_Rb_tree_decrement(v28, a2);
LODWORD(v14) = v40;
a2 = v28;
v28 = v32;
if ( v40 > *(_DWORD *)(v32 + 32) )
goto LABEL_40;
}
v15 = v6;
v6 = (void *)v28;
goto LABEL_24;
}
if ( v10 >= *((_DWORD *)v6 + 8) )
goto LABEL_26;
v13 = (_DWORD *)operator new(0x28uLL);
v14 = *v9;
v13[9] = 0;
v15 = v13;
v13[8] = v14;
if ( (int)v14 >= *((_DWORD *)v6 + 8) )
break;
v16 = *(void **)(a1 + 24);
v38 = v14;
if ( v16 == v6 )
goto LABEL_57;
v42 = v13;
v17 = std::_Rb_tree_decrement(v6, a2);
LODWORD(v14) = v38;
v15 = v42;
a2 = v17;
if ( v38 > *(_DWORD *)(v17 + 32) )
{
if ( *(_QWORD *)(v17 + 24) )
{
LABEL_57:
a2 = (long long)v6;
v24 = 1LL;
v6 = v15;
goto LABEL_44;
}
LABEL_39:
v6 = v15;
LABEL_40:
v23 = 0;
LABEL_41:
if ( v2 != a2 && !v23 )
{
v15 = v6;
v6 = (void *)a2;
goto LABEL_64;
}
goto LABEL_43;
}
v6 = *(void **)(a1 + 16);
if ( v6 )
{
while ( 1 )
{
v18 = *((_DWORD *)v6 + 8);
v19 = (void *)*((_QWORD *)v6 + 3);
if ( v38 < v18 )
v19 = (void *)*((_QWORD *)v6 + 2);
if ( !v19 )
break;
v6 = v19;
}
a2 = (long long)v6;
if ( v38 >= v18 )
{
if ( v18 < v38 )
goto LABEL_39;
goto LABEL_24;
}
if ( v16 == v6 )
goto LABEL_39;
}
else
{
v6 = (void *)v2;
if ( (void *)v2 == v16 )
goto LABEL_75;
}
v44 = v38;
v41 = v15;
v35 = std::_Rb_tree_decrement(v6, a2);
LODWORD(v14) = v44;
a2 = (long long)v6;
v15 = v41;
v6 = (void *)v35;
if ( *(_DWORD *)(v35 + 32) < v44 )
goto LABEL_39;
LABEL_24:
a2 = 40LL;
operator delete(v15, 0x28uLL);
LABEL_25:
v4 = v37[1];
v5 = *v37;
LABEL_26:
v7 += 2LL;
*((_DWORD *)v6 + 9) = v8;
if ( v7 >= (v4 - v5) >> 2 )
return a1;
v6 = *(void **)(a1 + 16);
}
if ( (int)v14 <= *((_DWORD *)v6 + 8) )
goto LABEL_24;
if ( *(void **)(a1 + 32) == v6 )
goto LABEL_64;
v43 = v14;
v39 = v13;
v20 = std::_Rb_tree_increment(v6, a2, v14, v13);
LODWORD(v14) = v43;
v15 = v39;
a2 = v20;
if ( v43 < *(_DWORD *)(v20 + 32) )
{
if ( *((_QWORD *)v6 + 3) )
{
v6 = v39;
v23 = 1;
goto LABEL_41;
}
LABEL_64:
v34 = __OFSUB__(*((_DWORD *)v6 + 8), (_DWORD)v14);
v27 = *((_DWORD *)v6 + 8) == (_DWORD)v14;
v33 = *((_DWORD *)v6 + 8) - (int)v14 < 0;
a2 = (long long)v6;
v6 = v15;
v24 = !(v33 ^ v34 | v27);
LABEL_44:
v25 = a2;
a2 = (long long)v6;
std::_Rb_tree_insert_and_rebalance(v24, v6, v25, v2);
++*(_QWORD *)(a1 + 40);
goto LABEL_25;
}
v6 = *(void **)(a1 + 16);
if ( v6 )
{
while ( 1 )
{
v21 = *((_DWORD *)v6 + 8);
v22 = (void *)*((_QWORD *)v6 + 3);
if ( v43 < v21 )
v22 = (void *)*((_QWORD *)v6 + 2);
if ( !v22 )
break;
v6 = v22;
}
a2 = (long long)v6;
if ( v43 >= v21 )
{
LABEL_38:
if ( (int)v14 > v21 )
goto LABEL_39;
goto LABEL_24;
}
if ( v6 == *(void **)(a1 + 24) )
goto LABEL_39;
}
else
{
v6 = (void *)v2;
if ( v2 == *(_QWORD *)(a1 + 24) )
{
LABEL_75:
v6 = v15;
LABEL_71:
a2 = v2;
LABEL_43:
v24 = 1LL;
goto LABEL_44;
}
}
v36 = std::_Rb_tree_decrement(v6, a2);
a2 = (long long)v6;
LODWORD(v14) = v43;
v15 = v39;
v21 = *(_DWORD *)(v36 + 32);
v6 = (void *)v36;
goto LABEL_38;
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
LEA R14,[RDI + 0x8]
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV dword ptr [RDI + 0x8],0x0
MOV R8,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],0x0
MOV qword ptr [RDI + 0x18],R14
MOV qword ptr [RDI + 0x20],R14
MOV qword ptr [RDI + 0x28],0x0
MOV RDI,qword ptr [RSI]
MOV qword ptr [RSP + 0x8],RSI
CMP R8,RDI
JZ 0x00101a48
XOR EBX,EBX
XOR R12D,R12D
NOP word ptr [RAX + RAX*0x1]
LAB_001017f8:
LEA RBP,[R12*0x4]
MOV R15D,dword ptr [RDI + RBP*0x1 + 0x4]
ADD RBP,RDI
TEST RBX,RBX
JZ 0x001019e0
MOV ECX,dword ptr [RBP]
MOV RSI,R14
NOP word ptr [RAX + RAX*0x1]
LAB_00101820:
MOV RDX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x18]
CMP ECX,dword ptr [RBX + 0x20]
JLE 0x00101842
LAB_0010182d:
TEST RAX,RAX
JZ 0x00101850
MOV RBX,RAX
MOV RDX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RBX + 0x18]
CMP ECX,dword ptr [RBX + 0x20]
JG 0x0010182d
LAB_00101842:
TEST RDX,RDX
JZ 0x00101853
MOV RSI,RBX
MOV RBX,RDX
JMP 0x00101820
LAB_00101850:
MOV RBX,RSI
LAB_00101853:
CMP R14,RBX
JZ 0x001019e0
CMP ECX,dword ptr [RBX + 0x20]
JGE 0x00101919
MOV EDI,0x28
LAB_0010186a:
CALL 0x00101140
MOV EDX,dword ptr [RBP]
MOV dword ptr [RAX + 0x24],0x0
MOV RCX,RAX
MOV dword ptr [RAX + 0x20],EDX
CMP EDX,dword ptr [RBX + 0x20]
JGE 0x00101940
MOV RBP,qword ptr [R13 + 0x18]
MOV dword ptr [RSP + 0x10],EDX
CMP RBP,RBX
JZ 0x00101a65
MOV RDI,RBX
MOV qword ptr [RSP + 0x18],RAX
CALL 0x00101160
MOV EDX,dword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
CMP EDX,dword ptr [RAX + 0x20]
MOV RSI,RAX
JG 0x00101a5a
MOV RBX,qword ptr [R13 + 0x10]
TEST RBX,RBX
JNZ 0x001018d3
JMP 0x00101b62
LAB_001018d0:
MOV RBX,RAX
LAB_001018d3:
MOV EDI,dword ptr [RBX + 0x20]
MOV RAX,qword ptr [RBX + 0x18]
CMP EDX,EDI
CMOVL RAX,qword ptr [RBX + 0x10]
SETL R8B
TEST RAX,RAX
JNZ 0x001018d0
MOV RSI,RBX
TEST R8B,R8B
JNZ 0x00101ae2
CMP EDI,EDX
JL 0x001019ae
NOP
LAB_00101900:
MOV ESI,0x28
MOV RDI,RCX
CALL 0x00101150
LAB_0010190d:
MOV RAX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX]
LAB_00101919:
MOV RAX,R8
ADD R12,0x2
MOV dword ptr [RBX + 0x24],R15D
SUB RAX,RDI
SAR RAX,0x2
CMP R12,RAX
JNC 0x00101a48
MOV RBX,qword ptr [R13 + 0x10]
JMP 0x001017f8
LAB_00101940:
JLE 0x00101900
CMP qword ptr [R13 + 0x20],RBX
JZ 0x00101aba
MOV RDI,RBX
MOV dword ptr [RSP + 0x18],EDX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00101120
MOV EDX,dword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
CMP EDX,dword ptr [RAX + 0x20]
MOV RSI,RAX
JL 0x00101ace
MOV RBX,qword ptr [R13 + 0x10]
TEST RBX,RBX
JNZ 0x00101983
JMP 0x00101b6f
LAB_00101980:
MOV RBX,RAX
LAB_00101983:
MOV EDI,dword ptr [RBX + 0x20]
MOV RAX,qword ptr [RBX + 0x18]
CMP EDX,EDI
CMOVL RAX,qword ptr [RBX + 0x10]
SETL R8B
TEST RAX,RAX
JNZ 0x00101980
MOV RSI,RBX
TEST R8B,R8B
JNZ 0x00101b30
LAB_001019a6:
CMP EDX,EDI
JLE 0x00101900
LAB_001019ae:
MOV RBX,RCX
LAB_001019b1:
XOR EAX,EAX
LAB_001019b3:
CMP R14,RSI
JZ 0x001019c0
TEST AL,AL
JZ 0x00101ab4
LAB_001019c0:
MOV EDI,0x1
LAB_001019c5:
MOV RDX,RSI
MOV RCX,R14
MOV RSI,RBX
CALL 0x001010f0
ADD qword ptr [R13 + 0x28],0x1
JMP 0x0010190d
LAB_001019e0:
MOV EDI,0x28
CALL 0x00101140
MOV EDX,dword ptr [RBP]
CMP qword ptr [R13 + 0x28],0x0
MOV RBX,RAX
MOV dword ptr [RAX + 0x24],0x0
MOV dword ptr [RAX + 0x20],EDX
JNZ 0x00101a75
LAB_00101a01:
MOV RBP,qword ptr [R13 + 0x10]
TEST RBP,RBP
JNZ 0x00101a13
JMP 0x00101b1b
LAB_00101a10:
MOV RBP,RAX
LAB_00101a13:
MOV ECX,dword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
CMP ECX,EDX
CMOVG RAX,qword ptr [RBP + 0x10]
SETG DIL
TEST RAX,RAX
JNZ 0x00101a10
MOV RSI,RBP
TEST DIL,DIL
JNZ 0x00101a87
CMP EDX,ECX
JG 0x001019b1
LAB_00101a3a:
MOV RCX,RBX
MOV RBX,RBP
JMP 0x00101900
LAB_00101a48:
ADD RSP,0x28
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101a5a:
CMP qword ptr [RAX + 0x18],0x0
JZ 0x001019ae
LAB_00101a65:
MOV RSI,RBX
MOV EDI,0x1
MOV RBX,RCX
JMP 0x001019c5
LAB_00101a75:
MOV RSI,qword ptr [R13 + 0x20]
CMP dword ptr [RSI + 0x20],EDX
JL 0x001019b1
JMP 0x00101a01
LAB_00101a87:
CMP qword ptr [R13 + 0x18],RBP
JZ 0x001019b1
LAB_00101a91:
MOV RDI,RBP
MOV dword ptr [RSP + 0x10],EDX
CALL 0x00101160
MOV EDX,dword ptr [RSP + 0x10]
MOV RSI,RBP
MOV ECX,dword ptr [RAX + 0x20]
MOV RBP,RAX
CMP EDX,ECX
JG 0x001019b1
JMP 0x00101a3a
LAB_00101ab4:
MOV RCX,RBX
MOV RBX,RSI
LAB_00101aba:
XOR EDI,EDI
CMP dword ptr [RBX + 0x20],EDX
MOV RSI,RBX
MOV RBX,RCX
SETG DIL
JMP 0x001019c5
LAB_00101ace:
CMP qword ptr [RBX + 0x18],0x0
JZ 0x00101aba
MOV RBX,RCX
MOV EAX,0x1
JMP 0x001019b3
LAB_00101ae2:
CMP RBP,RBX
JZ 0x001019ae
LAB_00101aeb:
MOV RDI,RBX
MOV dword ptr [RSP + 0x18],EDX
MOV qword ptr [RSP + 0x10],RCX
CALL 0x00101160
MOV EDX,dword ptr [RSP + 0x18]
MOV RSI,RBX
MOV RCX,qword ptr [RSP + 0x10]
MOV EDI,dword ptr [RAX + 0x20]
MOV RBX,RAX
CMP EDI,EDX
JL 0x001019ae
JMP 0x00101900
LAB_00101b1b:
MOV RBP,R14
CMP R14,qword ptr [R13 + 0x18]
JNZ 0x00101a91
LAB_00101b28:
MOV RSI,R14
JMP 0x001019c0
LAB_00101b30:
CMP RBX,qword ptr [R13 + 0x18]
JZ 0x001019ae
LAB_00101b3a:
MOV RDI,RBX
MOV dword ptr [RSP + 0x18],EDX
MOV qword ptr [RSP + 0x10],RCX
CALL 0x00101160
MOV RSI,RBX
MOV EDX,dword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV EDI,dword ptr [RAX + 0x20]
MOV RBX,RAX
JMP 0x001019a6
LAB_00101b62:
MOV RBX,R14
CMP R14,RBP
JNZ 0x00101aeb
LAB_00101b6a:
MOV RBX,RCX
JMP 0x00101b28
LAB_00101b6f:
MOV RBX,R14
CMP R14,qword ptr [R13 + 0x18]
JNZ 0x00101b3a
JMP 0x00101b6a | /* func0(std::vector<int, std::allocator<int> > const&) */
vector * func0(vector *param_1)
{
_Rb_tree_node_base *p_Var1;
int4 uVar2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
_Rb_tree_node_base *p_Var8;
int iVar9;
int *piVar10;
long *in_RSI;
bool bVar11;
int iVar12;
long lVar13;
long lVar14;
ulong uVar15;
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
*(int4 *)(param_1 + 8) = 0;
lVar14 = in_RSI[1];
*(int8 *)(param_1 + 0x10) = 0;
*(_Rb_tree_node_base **)(param_1 + 0x18) = p_Var1;
*(_Rb_tree_node_base **)(param_1 + 0x20) = p_Var1;
*(int8 *)(param_1 + 0x28) = 0;
lVar13 = *in_RSI;
if (lVar14 == lVar13) {
return param_1;
}
p_Var6 = (_Rb_tree_node_base *)0x0;
uVar15 = 0;
do {
uVar2 = *(int4 *)(lVar13 + 4 + uVar15 * 4);
piVar10 = (int *)(uVar15 * 4 + lVar13);
if (p_Var6 == (_Rb_tree_node_base *)0x0) {
LAB_001019e0:
p_Var6 = (_Rb_tree_node_base *)operator_new(0x28);
iVar9 = *piVar10;
lVar14 = *(long *)(param_1 + 0x28);
*(int4 *)(p_Var6 + 0x24) = 0;
*(int *)(p_Var6 + 0x20) = iVar9;
if ((lVar14 == 0) ||
(p_Var7 = *(_Rb_tree_node_base **)(param_1 + 0x20), iVar9 <= *(int *)(p_Var7 + 0x20))) {
p_Var8 = *(_Rb_tree_node_base **)(param_1 + 0x10);
if (*(_Rb_tree_node_base **)(param_1 + 0x10) != (_Rb_tree_node_base *)0x0) {
do {
p_Var7 = p_Var8;
iVar12 = *(int *)(p_Var7 + 0x20);
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x18);
if (iVar9 < iVar12) {
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x10);
}
} while (p_Var8 != (_Rb_tree_node_base *)0x0);
p_Var8 = p_Var7;
if (iVar12 <= iVar9) goto joined_r0x00101a34;
if (*(_Rb_tree_node_base **)(param_1 + 0x18) != p_Var7) goto LAB_00101a91;
goto LAB_001019b1;
}
p_Var7 = p_Var1;
p_Var8 = p_Var1;
if (p_Var1 != *(_Rb_tree_node_base **)(param_1 + 0x18)) {
LAB_00101a91:
p_Var8 = (_Rb_tree_node_base *)std::_Rb_tree_decrement(p_Var7);
iVar12 = *(int *)(p_Var8 + 0x20);
joined_r0x00101a34:
if (iVar9 <= iVar12) goto LAB_00101900;
goto LAB_001019b1;
}
LAB_001019c0:
bVar11 = true;
}
else {
LAB_001019b1:
bVar11 = false;
p_Var8 = p_Var7;
LAB_001019b3:
if ((p_Var1 == p_Var8) || (bVar11)) goto LAB_001019c0;
LAB_00101aba:
bVar11 = iVar9 < *(int *)(p_Var8 + 0x20);
}
LAB_001019c5:
std::_Rb_tree_insert_and_rebalance(bVar11,p_Var6,p_Var8,p_Var1);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + 1;
p_Var8 = p_Var6;
LAB_0010190d:
lVar14 = in_RSI[1];
lVar13 = *in_RSI;
}
else {
p_Var8 = p_Var1;
do {
iVar9 = *(int *)(p_Var6 + 0x20);
p_Var3 = *(_Rb_tree_node_base **)(p_Var6 + 0x10);
p_Var5 = *(_Rb_tree_node_base **)(p_Var6 + 0x18);
p_Var7 = p_Var6;
while (p_Var4 = p_Var5, p_Var6 = p_Var3, iVar9 < *piVar10) {
if (p_Var4 == (_Rb_tree_node_base *)0x0) goto LAB_00101853;
p_Var3 = *(_Rb_tree_node_base **)(p_Var4 + 0x10);
p_Var5 = *(_Rb_tree_node_base **)(p_Var4 + 0x18);
p_Var7 = p_Var4;
iVar9 = *(int *)(p_Var4 + 0x20);
}
p_Var8 = p_Var7;
} while (p_Var6 != (_Rb_tree_node_base *)0x0);
LAB_00101853:
if (p_Var1 == p_Var8) goto LAB_001019e0;
if (*piVar10 < *(int *)(p_Var8 + 0x20)) {
/* try { // try from 0010186a to 001019e9 has its CatchHandler @ 00101b7a */
p_Var6 = (_Rb_tree_node_base *)operator_new(0x28);
iVar9 = *piVar10;
*(int4 *)(p_Var6 + 0x24) = 0;
*(int *)(p_Var6 + 0x20) = iVar9;
if (iVar9 < *(int *)(p_Var8 + 0x20)) {
p_Var3 = *(_Rb_tree_node_base **)(param_1 + 0x18);
if (p_Var3 != p_Var8) {
p_Var7 = (_Rb_tree_node_base *)std::_Rb_tree_decrement(p_Var8);
if (iVar9 <= *(int *)(p_Var7 + 0x20)) {
p_Var8 = *(_Rb_tree_node_base **)(param_1 + 0x10);
if (*(_Rb_tree_node_base **)(param_1 + 0x10) != (_Rb_tree_node_base *)0x0) {
do {
p_Var7 = p_Var8;
iVar12 = *(int *)(p_Var7 + 0x20);
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x18);
if (iVar9 < iVar12) {
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x10);
}
} while (p_Var8 != (_Rb_tree_node_base *)0x0);
p_Var8 = p_Var7;
if (iVar9 < iVar12) {
if (p_Var3 == p_Var7) goto LAB_001019b1;
goto LAB_00101aeb;
}
joined_r0x001018f8:
if (iVar9 <= iVar12) goto LAB_00101900;
goto LAB_001019b1;
}
p_Var7 = p_Var1;
p_Var8 = p_Var1;
if (p_Var1 != p_Var3) {
LAB_00101aeb:
p_Var8 = (_Rb_tree_node_base *)std::_Rb_tree_decrement(p_Var7);
iVar12 = *(int *)(p_Var8 + 0x20);
goto joined_r0x001018f8;
}
goto LAB_001019c0;
}
if (*(long *)(p_Var7 + 0x18) != 0) goto LAB_00101a65;
goto LAB_001019b1;
}
LAB_00101a65:
bVar11 = true;
goto LAB_001019c5;
}
if (*(int *)(p_Var8 + 0x20) < iVar9) {
if (*(_Rb_tree_node_base **)(param_1 + 0x20) != p_Var8) {
p_Var7 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var8);
if (*(int *)(p_Var7 + 0x20) <= iVar9) {
p_Var8 = *(_Rb_tree_node_base **)(param_1 + 0x10);
if (*(_Rb_tree_node_base **)(param_1 + 0x10) == (_Rb_tree_node_base *)0x0) {
p_Var7 = p_Var1;
p_Var8 = p_Var1;
if (p_Var1 == *(_Rb_tree_node_base **)(param_1 + 0x18)) goto LAB_001019c0;
LAB_00101b3a:
p_Var8 = (_Rb_tree_node_base *)std::_Rb_tree_decrement(p_Var7);
iVar12 = *(int *)(p_Var8 + 0x20);
}
else {
do {
p_Var7 = p_Var8;
iVar12 = *(int *)(p_Var7 + 0x20);
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x18);
if (iVar9 < iVar12) {
p_Var8 = *(_Rb_tree_node_base **)(p_Var7 + 0x10);
}
} while (p_Var8 != (_Rb_tree_node_base *)0x0);
p_Var8 = p_Var7;
if (iVar9 < iVar12) {
if (p_Var7 == *(_Rb_tree_node_base **)(param_1 + 0x18)) goto LAB_001019b1;
goto LAB_00101b3a;
}
}
if (iVar12 < iVar9) goto LAB_001019b1;
goto LAB_00101900;
}
if (*(long *)(p_Var8 + 0x18) == 0) goto LAB_00101aba;
bVar11 = true;
p_Var8 = p_Var7;
goto LAB_001019b3;
}
goto LAB_00101aba;
}
LAB_00101900:
operator_delete(p_Var6,0x28);
goto LAB_0010190d;
}
}
uVar15 = uVar15 + 2;
*(int4 *)(p_Var8 + 0x24) = uVar2;
if ((ulong)(lVar14 - lVar13 >> 2) <= uVar15) {
return param_1;
}
p_Var6 = *(_Rb_tree_node_base **)(param_1 + 0x10);
} while( true );
} |
2,960 | func0 |
#include <string>
#include <assert.h>
| bool func0(std::string s) {
int n = s.length();
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1290 <_ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv@plt>
mov %eax,-0x14(%rbp)
movl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 145a <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x71>
mov -0x18(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 12f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%ebx
mov -0x28(%rbp),%rax
mov $0x0,%esi
mov %rax,%rdi
callq 12f0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm@plt>
movzbl (%rax),%eax
cmp %al,%bl
setne %al
test %al,%al
je 1454 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x6b>
mov $0x0,%eax
jmp 145f <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x76>
addl $0x1,-0x18(%rbp)
jmp 1410 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x27>
mov $0x1,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov rax, [rbp+var_28]
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6lengthEv; std::string::length(void)
mov [rbp+var_14], eax
mov [rbp+var_18], 1
jmp short loc_13B2
loc_1372:
mov eax, [rbp+var_18]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx ebx, byte ptr [rax]
mov rax, [rbp+var_28]
mov esi, 0
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixEm; std::string::operator[](ulong)
movzx eax, byte ptr [rax]
cmp bl, al
setnz al
test al, al
jz short loc_13AE
mov eax, 0
jmp short loc_13BF
loc_13AE:
add [rbp+var_18], 1
loc_13B2:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_14]
jl short loc_1372
mov eax, 1
loc_13BF:
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1)
{
char v1; // bl
int i; // [rsp+18h] [rbp-18h]
int v4; // [rsp+1Ch] [rbp-14h]
v4 = std::string::length(a1);
for ( i = 1; i < v4; ++i )
{
v1 = *(_BYTE *)std::string::operator[](a1, i);
if ( v1 != *(_BYTE *)std::string::operator[](a1, 0LL) )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101210
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x18],0x1
JMP 0x001013b2
LAB_00101372:
MOV EAX,dword ptr [RBP + -0x18]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101250
MOVZX EBX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00101250
MOVZX EAX,byte ptr [RAX]
CMP BL,AL
SETNZ AL
TEST AL,AL
JZ 0x001013ae
MOV EAX,0x0
JMP 0x001013bf
LAB_001013ae:
ADD dword ptr [RBP + -0x18],0x1
LAB_001013b2:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x00101372
MOV EAX,0x1
LAB_001013bf:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(std::string) */
int8 func0(ulong param_1)
{
char cVar1;
int iVar2;
char *pcVar3;
int local_20;
iVar2 = std::string::length();
local_20 = 1;
while( true ) {
if (iVar2 <= local_20) {
return 1;
}
pcVar3 = (char *)std::string::operator[](param_1);
cVar1 = *pcVar3;
pcVar3 = (char *)std::string::operator[](param_1);
if (cVar1 != *pcVar3) break;
local_20 = local_20 + 1;
}
return 0;
} |
2,961 | func0 |
#include <string>
#include <assert.h>
| bool func0(std::string s) {
int n = s.length();
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
cmp $0x1,%esi
jle 121b <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x32>
mov (%rdi),%rcx
movzbl (%rcx),%edx
lea 0x1(%rcx),%rax
lea -0x2(%rsi),%esi
lea 0x2(%rcx,%rsi,1),%rcx
cmp %dl,(%rax)
jne 1221 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x38>
add $0x1,%rax
cmp %rcx,%rax
jne 1208 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x1f>
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
cmp esi, 1
jle short loc_123B
mov rcx, [rdi]
movzx edx, byte ptr [rcx]
lea rax, [rcx+1]
lea esi, [rsi-2]
lea rcx, [rcx+rsi+2]
loc_1228:
cmp [rax], dl
jnz short loc_1241
add rax, 1
cmp rax, rcx
jnz short loc_1228
mov eax, 1
retn
loc_123B:
mov eax, 1
retn
loc_1241:
mov eax, 0
retn | long long func0(_QWORD *a1)
{
long long v1; // rsi
_BYTE *v2; // rax
v1 = a1[1];
if ( (int)v1 <= 1 )
return 1LL;
v2 = (_BYTE *)(*a1 + 1LL);
while ( *v2 == *(_BYTE *)*a1 )
{
if ( ++v2 == (_BYTE *)(*a1 + (unsigned int)(v1 - 2) + 2LL) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
CMP ESI,0x1
JLE 0x0010123b
MOV RCX,qword ptr [RDI]
MOVZX EDX,byte ptr [RCX]
LEA RAX,[RCX + 0x1]
LEA ESI,[RSI + -0x2]
LEA RCX,[RCX + RSI*0x1 + 0x2]
LAB_00101228:
CMP byte ptr [RAX],DL
JNZ 0x00101241
ADD RAX,0x1
CMP RAX,RCX
JNZ 0x00101228
MOV EAX,0x1
RET
LAB_0010123b:
MOV EAX,0x1
RET
LAB_00101241:
MOV EAX,0x0
RET | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if ((int)param_1[1] < 2) {
return 1;
}
pcVar1 = (char *)*param_1;
pcVar2 = pcVar1 + 1;
do {
if (*pcVar2 != *pcVar1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar1 + (ulong)((int)param_1[1] - 2) + 2);
return 1;
} |
2,962 | func0 |
#include <string>
#include <assert.h>
| bool func0(std::string s) {
int n = s.length();
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
cmp $0x1,%esi
jle 1400 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
mov (%rdi),%rcx
sub $0x2,%esi
movzbl (%rcx),%edx
lea 0x1(%rcx),%rax
lea 0x2(%rcx,%rsi,1),%rcx
jmp 13f1 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x31>
nopl 0x0(%rax)
add $0x1,%rax
cmp %rcx,%rax
je 1400 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
cmp %dl,(%rax)
je 13e8 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
cmp esi, 1
jle short loc_13F0
mov rcx, [rdi]
sub esi, 2
movzx edx, byte ptr [rcx]
lea rax, [rcx+1]
lea rcx, [rcx+rsi+2]
jmp short loc_13E1
loc_13D8:
add rax, 1
cmp rax, rcx
jz short loc_13F0
loc_13E1:
cmp [rax], dl
jz short loc_13D8
xor eax, eax
retn
loc_13F0:
mov eax, 1
retn | long long func0(_QWORD *a1)
{
long long v1; // rsi
_BYTE *v2; // rax
v1 = a1[1];
if ( (int)v1 <= 1 )
return 1LL;
v2 = (_BYTE *)(*a1 + 1LL);
while ( *v2 == *(_BYTE *)*a1 )
{
if ( ++v2 == (_BYTE *)(*a1 + (unsigned int)(v1 - 2) + 2LL) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
CMP ESI,0x1
JLE 0x001013f0
MOV RCX,qword ptr [RDI]
SUB ESI,0x2
MOVZX EDX,byte ptr [RCX]
LEA RAX,[RCX + 0x1]
LEA RCX,[RCX + RSI*0x1 + 0x2]
JMP 0x001013e1
LAB_001013d8:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001013f0
LAB_001013e1:
CMP byte ptr [RAX],DL
JZ 0x001013d8
XOR EAX,EAX
RET
LAB_001013f0:
MOV EAX,0x1
RET | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if (1 < (int)param_1[1]) {
pcVar1 = (char *)*param_1;
pcVar2 = pcVar1 + 1;
do {
if (*pcVar2 != *pcVar1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar1 + (ulong)((int)param_1[1] - 2) + 2);
}
return 1;
} |
2,963 | func0 |
#include <string>
#include <assert.h>
| bool func0(std::string s) {
int n = s.length();
for (int i = 1; i < n; i++) {
if (s[i] != s[0]) {
return false;
}
}
return true;
}
| int main() {
assert(func0("python") == false);
assert(func0("aaa") == true);
assert(func0("data") == false);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
mov 0x8(%rdi),%rsi
cmp $0x1,%esi
jle 1400 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
mov (%rdi),%rcx
sub $0x2,%esi
movzbl (%rcx),%edx
lea 0x1(%rcx),%rax
lea 0x2(%rcx,%rsi,1),%rcx
jmp 13f1 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x31>
nopl 0x0(%rax)
add $0x1,%rax
cmp %rcx,%rax
je 1400 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x40>
cmp %dl,(%rax)
je 13e8 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE+0x28>
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
mov rsi, [rdi+8]
cmp esi, 1
jle short loc_13F0
mov rcx, [rdi]
sub esi, 2
movzx edx, byte ptr [rcx]
lea rax, [rcx+1]
lea rcx, [rcx+rsi+2]
jmp short loc_13E1
loc_13D8:
add rax, 1
cmp rax, rcx
jz short loc_13F0
loc_13E1:
cmp [rax], dl
jz short loc_13D8
xor eax, eax
retn
loc_13F0:
mov eax, 1
retn | long long func0(_QWORD *a1)
{
long long v1; // rsi
_BYTE *v2; // rax
v1 = a1[1];
if ( (int)v1 <= 1 )
return 1LL;
v2 = (_BYTE *)(*a1 + 1LL);
while ( *v2 == *(_BYTE *)*a1 )
{
if ( ++v2 == (_BYTE *)(*a1 + (unsigned int)(v1 - 2) + 2LL) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
MOV RSI,qword ptr [RDI + 0x8]
CMP ESI,0x1
JLE 0x001013f0
MOV RCX,qword ptr [RDI]
SUB ESI,0x2
MOVZX EDX,byte ptr [RCX]
LEA RAX,[RCX + 0x1]
LEA RCX,[RCX + RSI*0x1 + 0x2]
JMP 0x001013e1
LAB_001013d8:
ADD RAX,0x1
CMP RAX,RCX
JZ 0x001013f0
LAB_001013e1:
CMP byte ptr [RAX],DL
JZ 0x001013d8
XOR EAX,EAX
RET
LAB_001013f0:
MOV EAX,0x1
RET | /* func0(std::string) */
int8 func0(int8 *param_1)
{
char *pcVar1;
char *pcVar2;
if (1 < (int)param_1[1]) {
pcVar1 = (char *)*param_1;
pcVar2 = pcVar1 + 1;
do {
if (*pcVar2 != *pcVar1) {
return 0;
}
pcVar2 = pcVar2 + 1;
} while (pcVar2 != pcVar1 + (ulong)((int)param_1[1] - 2) + 2);
}
return 1;
} |
2,964 | func0 |
#include <cmath>
#include <cassert>
using namespace std;
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O0 | cpp | func0(double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
mov $0x3,%edi
callq 127c <_ZSt4sqrtIiEN9__gnu_cxx11__enable_ifIXsrSt12__is_integerIT_E7__valueEdE6__typeES3_>
movapd %xmm0,%xmm1
movsd -0x18(%rbp),%xmm0
mulsd %xmm0,%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| _Z5func0d:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+var_18], xmm0
mov edi, 3
call _ZSt4sqrtIiEN9__gnu_cxx11__enable_ifIXsrSt12__is_integerIT_E7__valueEdE6__typeES3_; std::sqrt<int>(int)
movapd xmm1, xmm0
movsd xmm0, [rbp+var_18]
mulsd xmm0, xmm0
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
leave
retn | double func0(double a1)
{
return a1 * a1 * std::sqrt<int>(3LL);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOV EDI,0x3
CALL 0x001012c4
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [RBP + -0x18]
MULSD XMM0,XMM0
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(double) */
double func0(double param_1)
{
double extraout_XMM0_Qa;
std::sqrt<int>(3);
return param_1 * param_1 * extraout_XMM0_Qa;
} |
2,965 | func0 |
#include <cmath>
#include <cassert>
using namespace std;
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O1 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
2,966 | func0 |
#include <cmath>
#include <cassert>
using namespace std;
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O2 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
2,967 | func0 |
#include <cmath>
#include <cassert>
using namespace std;
| double func0(double side) {
double area = sqrt(3) * (side * side);
return area;
}
| int main() {
assert(func0(3) == 15.588457268119894);
assert(func0(20) == 692.8203230275509);
assert(func0(10) == 173.20508075688772);
return 0;
}
| O3 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
retn | double func0(double a1)
{
return a1 * a1 * 1.732050807568877;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double) */
double func0(double param_1)
{
return param_1 * param_1 * _DAT_00102008;
} |
2,968 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list1, int m, int n) {
std::vector<int> result;
result.insert(result.end(), list1.end() - m, list1.end());
result.insert(result.end(), list1.begin(), list1.end() - n);
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, 4) == std::vector<int>{8, 9, 10, 1, 2, 3, 4, 5, 6}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2, 2) == std::vector<int>{9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 5, 2) == std::vector<int>{6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %edx,-0x44(%rbp)
mov %ecx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1bec <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1d42 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,%r12
mov -0x44(%rbp),%eax
movslq %eax,%rbx
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1d42 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x28(%rbp)
lea -0x28(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 1d9a <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEmiEl>
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1cf2 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e04 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC1IPiEERKNS0_IT_NS_11__enable_ifIXsrSt10__are_sameIS9_S8_E7__valueES5_E6__typeEEE>
mov -0x20(%rbp),%rsi
mov -0x38(%rbp),%rax
mov %r12,%rcx
mov %rbx,%rdx
mov %rax,%rdi
callq 1e32 <_ZNSt6vectorIiSaIiEE6insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEENS4_IPiS1_EES7_T_SA_>
mov -0x48(%rbp),%eax
movslq %eax,%rbx
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1d42 <_ZNKSt6vectorIiSaIiEE3endEv>
mov %rax,-0x28(%rbp)
lea -0x28(%rbp),%rax
mov %rbx,%rsi
mov %rax,%rdi
callq 1d9a <_ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEmiEl>
mov %rax,%r12
mov -0x40(%rbp),%rax
mov %rax,%rdi
callq 1ef8 <_ZNKSt6vectorIiSaIiEE5beginEv>
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1cf2 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,-0x30(%rbp)
lea -0x30(%rbp),%rdx
lea -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1e04 <_ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC1IPiEERKNS0_IT_NS_11__enable_ifIXsrSt10__are_sameIS9_S8_E7__valueES5_E6__typeEEE>
mov -0x20(%rbp),%rsi
mov -0x38(%rbp),%rax
mov %r12,%rcx
mov %rbx,%rdx
mov %rax,%rdi
callq 1e32 <_ZNSt6vectorIiSaIiEE6insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEENS4_IPiS1_EES7_T_SA_>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 13f6 <_Z5func0RKSt6vectorIiSaIiEEii+0x14d>
jmp 13f1 <_Z5func0RKSt6vectorIiSaIiEEii+0x148>
endbr64
mov %rax,%rbx
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1caa <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 11b0 <_Unwind_Resume@plt>
callq 1170 <__stack_chk_fail@plt>
mov -0x38(%rbp),%rax
add $0x40,%rsp
pop %rbx
pop %r12
pop %rbp
retq
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_44], edx
mov [rbp+var_48], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov r12, rax
mov eax, [rbp+var_44]
movsxd rbx, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_28], rax
lea rax, [rbp+var_28]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEmiEl; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator-(long)
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_30], rax
lea rdx, [rbp+var_30]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC2IPivEERKNS0_IT_S5_EE; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
mov rsi, [rbp+var_20]
mov rax, [rbp+var_38]
mov rcx, r12
mov rdx, rbx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE6insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEENS4_IPiS1_EES7_T_SA_; std::vector<int>::insert<__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>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>)
mov eax, [rbp+var_48]
movsxd rbx, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_28], rax
lea rax, [rbp+var_28]
mov rsi, rbx
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEmiEl; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator-(long)
mov r12, rax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov [rbp+var_30], rax
lea rdx, [rbp+var_30]
lea rax, [rbp+var_20]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKiSt6vectorIiSaIiEEEC2IPivEERKNS0_IT_S5_EE; __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(__gnu_cxx::__normal_iterator<int *,std::vector<int>> const&)
mov rsi, [rbp+var_20]
mov rax, [rbp+var_38]
mov rcx, r12
mov rdx, rbx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE6insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEvEENS4_IPiS1_EES7_T_SA_; std::vector<int>::insert<__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>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>)
nop
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_142A
jmp short loc_1425
endbr64
mov rbx, rax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_141D
call ___stack_chk_fail
loc_141D:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1425:
call ___stack_chk_fail
loc_142A:
mov rax, [rbp+var_38]
add rsp, 40h
pop rbx
pop r12
pop rbp
retn | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v4; // r12
long long v5; // rbx
long long v6; // r12
long long v7; // rbx
long long v11; // [rsp+20h] [rbp-30h] BYREF
long long v12; // [rsp+28h] [rbp-28h] BYREF
_QWORD v13[4]; // [rsp+30h] [rbp-20h] BYREF
v13[1] = __readfsqword(0x28u);
std::vector<int>::vector(a1);
v4 = std::vector<int>::end(a2);
v12 = std::vector<int>::end(a2);
v5 = __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator-(&v12, a3);
v11 = std::vector<int>::end(a1);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(v13, &v11);
std::vector<int>::insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(a1, v13[0], v5, v4);
v12 = std::vector<int>::end(a2);
v6 = __gnu_cxx::__normal_iterator<int const*,std::vector<int>>::operator-(&v12, a4);
v7 = std::vector<int>::begin(a2);
v11 = std::vector<int>::end(a1);
__gnu_cxx::__normal_iterator<int const*,std::vector<int>>::__normal_iterator<int *,void>(v13, &v11);
std::vector<int>::insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,void>(a1, v13[0], v7, v6);
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV dword ptr [RBP + -0x44],EDX
MOV dword ptr [RBP + -0x48],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101c70
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101dbe
MOV R12,RAX
MOV EAX,dword ptr [RBP + -0x44]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101dbe
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[RBP + -0x28]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101e0e
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101d6e
MOV qword ptr [RBP + -0x30],RAX
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e78
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,R12
MOV RDX,RBX
MOV RDI,RAX
LAB_0010136c:
CALL 0x00101ea6
MOV EAX,dword ptr [RBP + -0x48]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101dbe
MOV qword ptr [RBP + -0x28],RAX
LEA RAX,[RBP + -0x28]
MOV RSI,RBX
MOV RDI,RAX
CALL 0x00101e0e
MOV R12,RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x00101f6c
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101d6e
MOV qword ptr [RBP + -0x30],RAX
LEA RDX,[RBP + -0x30]
LEA RAX,[RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101e78
MOV RSI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,R12
MOV RDX,RBX
MOV RDI,RAX
CALL 0x00101ea6
NOP
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x0010142a
JMP 0x00101425
LAB_00101425:
CALL 0x00101190
LAB_0010142a:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x40
POP RBX
POP R12
POP RBP
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
vector * func0(vector *param_1,int param_2,int param_3)
{
int8 uVar1;
int8 uVar2;
int in_ECX;
int4 in_register_00000034;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int8 local_38;
int8 local_30;
int8 local_28;
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_00000034,param_2);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector((vector<int,std::allocator<int>> *)param_1);
uVar1 = std::vector<int,std::allocator<int>>::end(this);
local_30 = std::vector<int,std::allocator<int>>::end(this);
uVar2 = __normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator-
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_30
,(long)param_3);
local_38 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_1);
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator<int*,void>
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_28,
(__normal_iterator *)&local_38);
/* try { // try from 0010136c to 001013e0 has its CatchHandler @ 001013f3 */
std::vector<int,std::allocator<int>>::
insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,void>
((vector<int,std::allocator<int>> *)param_1,local_28,uVar2,uVar1);
local_30 = std::vector<int,std::allocator<int>>::end(this);
uVar1 = __normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::operator-
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_30
,(long)in_ECX);
uVar2 = std::vector<int,std::allocator<int>>::begin(this);
local_38 = std::vector<int,std::allocator<int>>::end((vector<int,std::allocator<int>> *)param_1);
__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>::__normal_iterator<int*,void>
((__normal_iterator<int_const*,std::vector<int,std::allocator<int>>> *)&local_28,
(__normal_iterator *)&local_38);
std::vector<int,std::allocator<int>>::
insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>,void>
((vector<int,std::allocator<int>> *)param_1,local_28,uVar2,uVar1);
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_1;
} |
2,969 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list1, int m, int n) {
std::vector<int> result;
result.insert(result.end(), list1.end() - m, list1.end());
result.insert(result.end(), list1.begin(), list1.end() - n);
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, 4) == std::vector<int>{8, 9, 10, 1, 2, 3, 4, 5, 6}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2, 2) == std::vector<int>{9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 5, 2) == std::vector<int>{6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %rsi,%r12
mov %ecx,%ebp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rcx
movslq %edx,%rdx
shl $0x2,%rdx
mov %rcx,%rax
sub %rdx,%rax
mov %rax,%rdx
mov $0x0,%esi
callq 1956 <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag>
movslq %ebp,%rbp
shl $0x2,%rbp
mov 0x8(%r12),%rcx
sub %rbp,%rcx
mov (%r12),%rdx
mov 0x8(%rbx),%rsi
mov %rbx,%rdi
callq 1956 <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag>
jmp 12cb <_Z5func0RKSt6vectorIiSaIiEEii+0x82>
endbr64
mov %rax,%rbp
mov (%rbx),%rdi
test %rdi,%rdi
je 12c3 <_Z5func0RKSt6vectorIiSaIiEEii+0x7a>
callq 1110 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1150 <_Unwind_Resume@plt>
mov %rbx,%rax
pop %rbx
pop %rbp
pop %r12
retq
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r12
push rbp
push rbx
mov rbx, rdi
mov r12, rsi
mov ebp, ecx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rcx, [rsi+8]
movsxd rdx, edx
shl rdx, 2
mov rax, rcx
sub rax, rdx
mov rdx, rax
mov esi, 0
call _ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag; std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::forward_iterator_tag)
movsxd rbp, ebp
shl rbp, 2
mov rcx, [r12+8]
sub rcx, rbp
mov rsi, [rbx+8]
mov rdx, [r12]
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag; std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::forward_iterator_tag)
jmp short loc_12C6
endbr64
mov rbp, rax
mov rdi, rbx
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rdi, rbp; struct _Unwind_Exception *
call __Unwind_Resume
loc_12C6:
mov rax, rbx
pop rbx
pop rbp
pop r12
retn | _QWORD * func0(_QWORD *a1, _QWORD *a2, int a3)
{
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(
a1,
0LL,
a2[1] - 4LL * a3);
std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(a1, a1[1], *a2);
return a1;
} | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV R12,RSI
MOV EBP,ECX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RCX,qword ptr [RSI + 0x8]
MOVSXD RDX,EDX
SHL RDX,0x2
MOV RAX,RCX
SUB RAX,RDX
MOV RDX,RAX
MOV ESI,0x0
LAB_00101289:
CALL 0x0010198c
MOVSXD RBP,EBP
SHL RBP,0x2
MOV RCX,qword ptr [R12 + 0x8]
SUB RCX,RBP
MOV RSI,qword ptr [RBX + 0x8]
MOV RDX,qword ptr [R12]
MOV RDI,RBX
CALL 0x0010198c
JMP 0x001012c6
LAB_001012c6:
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
vector * func0(vector *param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_00000034;
int8 *puVar1;
puVar1 = (int8 *)CONCAT44(in_register_00000034,param_2);
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
/* try { // try from 00101289 to 001012ac has its CatchHandler @ 001012af */
std::vector<int,std::allocator<int>>::
_M_range_insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
((__normal_iterator)param_1,0,(forward_iterator_tag)puVar1[1] + param_3 * -4,
(forward_iterator_tag)puVar1[1]);
std::vector<int,std::allocator<int>>::
_M_range_insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
((__normal_iterator)param_1,(__normal_iterator)*(int8 *)(param_1 + 8),
(__normal_iterator)*puVar1,(int)puVar1[1] - (int)((long)in_ECX << 2));
return param_1;
} |
2,970 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list1, int m, int n) {
std::vector<int> result;
result.insert(result.end(), list1.end() - m, list1.end());
result.insert(result.end(), list1.begin(), list1.end() - n);
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, 4) == std::vector<int>{8, 9, 10, 1, 2, 3, 4, 5, 6}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2, 2) == std::vector<int>{9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 5, 2) == std::vector<int>{6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r12
movslq %edx,%rdx
mov %rdi,%r12
push %rbp
shl $0x2,%rdx
mov %rsi,%rbp
push %rbx
movslq %ecx,%rbx
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov 0x8(%rsi),%rcx
xor %esi,%esi
mov %rcx,%rax
sub %rdx,%rax
mov %rax,%rdx
callq 1900 <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag>
mov 0x8(%rbp),%rcx
shl $0x2,%rbx
mov 0x0(%rbp),%rdx
mov %r12,%rdi
mov 0x8(%r12),%rsi
sub %rbx,%rcx
callq 1900 <_ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag>
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
retq
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEEii.cold>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
pxor xmm0, xmm0
push r12
movsxd rdx, edx
mov r12, rsi
push rbp
movsxd rbp, ecx
shl rdx, 2
push rbx
mov rbx, rdi
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi+8]
xor esi, esi
mov rax, rcx
sub rax, rdx
mov rdx, rax
call _ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag_isra_0; std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::forward_iterator_tag) [clone]
mov rcx, [r12+8]
shl rbp, 2
mov rsi, [rbx+8]
mov rdi, rbx
mov rdx, [r12]
sub rcx, rbp
call _ZNSt6vectorIiSaIiEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKiS1_EEEEvNS4_IPiS1_EET_SA_St20forward_iterator_tag_isra_0; std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(__gnu_cxx::__normal_iterator<int *,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,__gnu_cxx::__normal_iterator<int const*,std::vector<int>>,std::forward_iterator_tag) [clone]
mov rax, rbx
pop rbx
pop rbp
pop r12
retn
endbr64
mov rbp, rax
jmp _Z5func0RKSt6vectorIiSaIiEEii_cold; func0(std::vector<int> const&,int,int) [clone] | long long func0(long long a1, _QWORD *a2, int a3)
{
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(
a1,
0LL,
a2[1] - 4LL * a3);
std::vector<int>::_M_range_insert<__gnu_cxx::__normal_iterator<int const*,std::vector<int>>>(
a1,
*(_QWORD *)(a1 + 8),
*a2);
return a1;
} | func0:
ENDBR64
PXOR XMM0,XMM0
PUSH R12
MOVSXD RDX,EDX
MOV R12,RSI
PUSH RBP
MOVSXD RBP,ECX
SHL RDX,0x2
PUSH RBX
MOV RBX,RDI
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI + 0x8]
XOR ESI,ESI
MOV RAX,RCX
SUB RAX,RDX
MOV RDX,RAX
LAB_00101a16:
CALL 0x00101690
MOV RCX,qword ptr [R12 + 0x8]
SHL RBP,0x2
MOV RSI,qword ptr [RBX + 0x8]
MOV RDI,RBX
MOV RDX,qword ptr [R12]
SUB RCX,RBP
CALL 0x00101690
MOV RAX,RBX
POP RBX
POP RBP
POP R12
RET | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
vector * func0(vector *param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_00000034;
int8 *puVar1;
puVar1 = (int8 *)CONCAT44(in_register_00000034,param_2);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
/* try { // try from 00101a16 to 00101a36 has its CatchHandler @ 00101a3f */
std::vector<int,std::allocator<int>>::
_M_range_insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
((__normal_iterator)param_1,0,(forward_iterator_tag)puVar1[1] + param_3 * -4,
(forward_iterator_tag)puVar1[1]);
std::vector<int,std::allocator<int>>::
_M_range_insert<__normal_iterator<int_const*,std::vector<int,std::allocator<int>>>>
((__normal_iterator)param_1,(__normal_iterator)*(int8 *)(param_1 + 8),
(__normal_iterator)*puVar1,(int)puVar1[1] - (int)((long)in_ECX << 2));
return param_1;
} |
2,971 | func0 |
#include <vector>
#include <cassert>
| std::vector<int> func0(const std::vector<int>& list1, int m, int n) {
std::vector<int> result;
result.insert(result.end(), list1.end() - m, list1.end());
result.insert(result.end(), list1.begin(), list1.end() - n);
return result;
}
| int main() {
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, 4) == std::vector<int>{8, 9, 10, 1, 2, 3, 4, 5, 6}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 2, 2) == std::vector<int>{9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
assert((func0({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 5, 2) == std::vector<int>{6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r15
pxor %xmm0,%xmm0
movslq %edx,%rdx
push %r14
mov %rsi,%r14
push %r13
movslq %ecx,%r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
lea 0x0(,%rdx,4),%rbx
sub $0x28,%rsp
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov 0x8(%rsi),%rax
mov %rax,%rbp
sub %rbx,%rbp
cmp %rbp,%rax
je 17a0 <_Z5func0RKSt6vectorIiSaIiEEii+0x120>
movabs $0x7ffffffffffffffc,%rax
cmp %rax,%rbx
ja 19b9 <_Z5func0RKSt6vectorIiSaIiEEii+0x339>
mov %rbx,%rdi
callq 1120 <_Znwm@plt>
mov (%r12),%r9
mov %rax,%r10
mov %r9,%rdx
sub %r9,%r10
neg %rdx
lea (%r10,%rbx,1),%r15
test %r9,%r9
je 1920 <_Z5func0RKSt6vectorIiSaIiEEii+0x2a0>
mov %r9,%rsi
mov %rax,%rdi
mov %r9,0x10(%rsp)
mov %r10,0x18(%rsp)
mov %rax,0x8(%rsp)
callq 1140 <memmove@plt>
mov 0x18(%rsp),%r10
mov %rbp,%rsi
mov %rbx,%rdx
mov %r10,%rdi
callq 1100 <memcpy@plt>
mov 0x8(%r12),%rbp
mov 0x8(%rsp),%r8
mov 0x10(%rsp),%r9
test %rbp,%rbp
je 1765 <_Z5func0RKSt6vectorIiSaIiEEii+0xe5>
mov %r15,%rdi
mov %rbp,%rdx
xor %esi,%esi
mov %r8,0x10(%rsp)
mov %r9,0x8(%rsp)
add %rbp,%r15
callq 1100 <memcpy@plt>
mov 0x10(%rsp),%r8
mov 0x8(%rsp),%r9
mov %r9,%rdi
mov %r8,0x8(%rsp)
callq 1110 <_ZdlPv@plt>
mov 0x8(%rsp),%r8
movq %r8,%xmm0
movq %r15,%xmm1
add %r8,%rbx
mov %r15,%rdx
punpcklqdq %xmm1,%xmm0
mov %rbx,0x10(%r12)
sub %r8,%rdx
movups %xmm0,(%r12)
mov 0x8(%r14),%rbp
jmp 17aa <_Z5func0RKSt6vectorIiSaIiEEii+0x12a>
xchg %ax,%ax
xor %ebx,%ebx
xor %edx,%edx
xor %r8d,%r8d
xor %r15d,%r15d
shl $0x2,%r13
mov (%r14),%r14
sub %r13,%rbp
cmp %rbp,%r14
je 17e5 <_Z5func0RKSt6vectorIiSaIiEEii+0x165>
sub %r14,%rbp
sub %r15,%rbx
mov %rbp,%rax
sar $0x2,%rbx
mov %rbp,%r13
sar $0x2,%rax
cmp %rbx,%rax
ja 1800 <_Z5func0RKSt6vectorIiSaIiEEii+0x180>
mov %rbp,%rdx
mov %r14,%rsi
mov %r15,%rdi
callq 1140 <memmove@plt>
add %rbp,0x8(%r12)
add $0x28,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
movabs $0x1fffffffffffffff,%rcx
mov %rdx,%rbp
sar $0x2,%rbp
mov %rcx,%rsi
sub %rbp,%rsi
cmp %rsi,%rax
ja 19c5 <_Z5func0RKSt6vectorIiSaIiEEii+0x345>
cmp %rbp,%rax
cmovb %rbp,%rax
add %rbp,%rax
jb 19ad <_Z5func0RKSt6vectorIiSaIiEEii+0x32d>
xor %ebp,%ebp
xor %ebx,%ebx
test %rax,%rax
jne 1960 <_Z5func0RKSt6vectorIiSaIiEEii+0x2e0>
lea (%rbx,%rdx,1),%r9
lea (%r9,%r13,1),%r10
cmp %r15,%r8
je 18e0 <_Z5func0RKSt6vectorIiSaIiEEii+0x260>
mov %r8,%rsi
mov %rbx,%rdi
mov %r10,0x18(%rsp)
mov %r8,0x8(%rsp)
mov %r9,0x10(%rsp)
callq 1140 <memmove@plt>
mov 0x10(%rsp),%r9
mov %r13,%rdx
mov %r14,%rsi
mov %r9,%rdi
callq 1100 <memcpy@plt>
mov 0x8(%r12),%rax
mov 0x18(%rsp),%r10
mov 0x8(%rsp),%r8
mov %rax,%rdx
sub %r15,%rdx
cmp %rax,%r15
lea (%r10,%rdx,1),%r13
je 19a0 <_Z5func0RKSt6vectorIiSaIiEEii+0x320>
mov %r15,%rsi
mov %r10,%rdi
mov %r8,0x8(%rsp)
callq 1100 <memcpy@plt>
mov 0x8(%rsp),%r8
test %r8,%r8
jne 19a0 <_Z5func0RKSt6vectorIiSaIiEEii+0x320>
movq %rbx,%xmm0
movq %r13,%xmm2
mov %rbp,0x10(%r12)
punpcklqdq %xmm2,%xmm0
movups %xmm0,(%r12)
jmpq 17e5 <_Z5func0RKSt6vectorIiSaIiEEii+0x165>
nopl 0x0(%rax,%rax,1)
mov %r13,%rdx
mov %r14,%rsi
mov %r9,%rdi
mov %r8,0x10(%rsp)
mov %r10,0x8(%rsp)
callq 1100 <memcpy@plt>
mov 0x8(%r12),%rax
mov 0x10(%rsp),%r8
mov 0x8(%rsp),%r10
mov %rax,%rdx
sub %r8,%rdx
lea (%r10,%rdx,1),%r13
cmp %rax,%r8
jne 189d <_Z5func0RKSt6vectorIiSaIiEEii+0x21d>
jmp 18b2 <_Z5func0RKSt6vectorIiSaIiEEii+0x232>
nopl 0x0(%rax,%rax,1)
mov %rbp,%rsi
mov %rbx,%rdx
mov %r10,%rdi
mov %rax,0x8(%rsp)
callq 1100 <memcpy@plt>
mov 0x8(%r12),%rbp
mov 0x8(%rsp),%r8
test %rbp,%rbp
je 1777 <_Z5func0RKSt6vectorIiSaIiEEii+0xf7>
mov %r15,%rdi
mov %rbp,%rdx
xor %esi,%esi
add %rbp,%r15
callq 1100 <memcpy@plt>
mov 0x8(%rsp),%r8
jmpq 1777 <_Z5func0RKSt6vectorIiSaIiEEii+0xf7>
cmp %rcx,%rax
cmova %rcx,%rax
lea 0x0(,%rax,4),%rbp
mov %rbp,%rdi
callq 1120 <_Znwm@plt>
mov (%r12),%r8
mov %r15,%rdx
mov %rax,%rbx
add %rax,%rbp
sub %r8,%rdx
lea (%rbx,%rdx,1),%r9
lea (%r9,%r13,1),%r10
cmp %r15,%r8
jne 184e <_Z5func0RKSt6vectorIiSaIiEEii+0x1ce>
jmpq 18e0 <_Z5func0RKSt6vectorIiSaIiEEii+0x260>
nopl (%rax)
mov %r8,%rdi
callq 1110 <_ZdlPv@plt>
jmpq 18bb <_Z5func0RKSt6vectorIiSaIiEEii+0x23b>
movabs $0x7ffffffffffffffc,%rbp
jmp 196f <_Z5func0RKSt6vectorIiSaIiEEii+0x2ef>
lea 0x644(%rip),%rdi
callq 10e0 <_ZSt20__throw_length_errorPKc@plt>
lea 0x638(%rip),%rdi
callq 10e0 <_ZSt20__throw_length_errorPKc@plt>
endbr64
mov %rax,%rbp
jmpq 1160 <_Z5func0RKSt6vectorIiSaIiEEii.cold>
nopl (%rax)
| _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r15
pxor xmm0, xmm0
movsxd rdx, edx
push r14
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
movsxd rbp, ecx
push rbx
lea rbx, ds:0[rdx*4]
sub rsp, 18h
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rax, [rsi+8]
mov r14, rax
sub r14, rbx
cmp r14, rax
jz short loc_1750
mov rax, 7FFFFFFFFFFFFFFCh
cmp rax, rbx
jb loc_18AC
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
mov [rsp+48h+var_48], rbx
mov r15, rax
cmp rbx, 4
jz loc_1840
mov rdx, rbx; n
mov rsi, r14; src
mov rdi, rax; dest
call _memmove
loc_170E:
lea rax, [r15+rbx]
mov [r12], r15
shl rbp, 2
mov rcx, rbx
mov [r12+8], rax
sar rcx, 2
mov [r12+10h], rax
mov rax, [r13+8]
mov r13, [r13+0]
sub rax, rbp
cmp r13, rax
jnz short loc_176F
loc_173B:
add rsp, 18h
mov rax, r12
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1750:
shl rbp, 2
mov r13, [r13+0]
xor ecx, ecx
xor ebx, ebx
sub rax, rbp
mov [rsp+48h+var_48], 0
xor r15d, r15d
cmp r13, rax
jz short loc_173B
loc_176F:
mov rdx, 1FFFFFFFFFFFFFFFh
sub rax, r13
mov rbp, rax
sub rdx, rcx
sar rax, 2
cmp rdx, rax
jb loc_18A0
cmp rbx, rbp
cmovnb rax, rcx
add rax, rcx
jnz short loc_1806
mov [rsp+48h+var_40], 0
xor r14d, r14d
loc_17A7:
cmp [rsp+48h+var_48], 4
jle loc_1850
mov rdx, rbx; n
mov rsi, r15; src
mov rdi, r14; dest
add rbx, r14
call _memmove
cmp rbp, 4
jle loc_1890
loc_17CD:
mov rdi, rbx; dest
mov rdx, rbp; n
mov rsi, r13; src
add rbx, rbp
call _memmove
loc_17DE:
mov rsi, [r12+10h]
mov rdi, r15; void *
sub rsi, r15; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_17EE:
mov rax, [rsp+48h+var_40]
mov [r12], r14
mov [r12+8], rbx
mov [r12+10h], rax
jmp loc_173B
loc_1806:
mov rdx, 1FFFFFFFFFFFFFFFh
cmp rax, rdx
cmova rax, rdx
shl rax, 2
mov rdi, rax; unsigned __int64
mov [rsp+48h+var_40], rax
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, [rsp+48h+var_40]
add rax, r14
mov [rsp+48h+var_40], rax
jmp loc_17A7
loc_1840:
mov eax, [r14]
mov [r15], eax
jmp loc_170E
loc_1850:
jz short loc_187A
add rbx, r14
cmp rbp, 4
jle short loc_18B8
mov rdx, rbp; n
mov rsi, r13; src
mov rdi, rbx; dest
call _memmove
loc_1869:
add rbx, rbp
test r15, r15
jz loc_17EE
jmp loc_17DE
loc_187A:
mov eax, [r15]
add rbx, r14
mov [r14], eax
cmp rbp, 4
jg loc_17CD
nop dword ptr [rax]
loc_1890:
mov eax, [r13+0]
add rbx, 4
mov [rbx-4], eax
jmp loc_17DE
loc_18A0:
lea rdi, aVectorMRangeIn; "vector::_M_range_insert"
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_18AC:
lea rdi, aVectorMRangeIn; "vector::_M_range_insert"
call __ZSt20__throw_length_errorPKc; std::__throw_length_error(char const*)
loc_18B8:
mov eax, [r13+0]
mov [rbx], eax
jmp short loc_1869
endbr64
mov rbx, rax
jmp _Z5func0RKSt6vectorIiSaIiEEii_cold; func0(std::vector<int> const&,int,int) [clone] | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v5; // rbp
size_t v6; // rbx
long long v7; // rax
_DWORD *v8; // r14
_DWORD *v9; // rax
_DWORD *v10; // r15
long long v11; // rcx
_DWORD *v12; // r13
long long v13; // rax
long long v15; // rbp
signed long long v16; // rbp
unsigned long long v17; // rax
unsigned long long v18; // rax
_DWORD *v19; // r14
size_t v20; // rdx
char *v21; // rbx
char *v22; // rdi
char *v23; // rbx
_DWORD *v24; // rbx
long long v25; // [rsp+0h] [rbp-48h]
_DWORD *v26; // [rsp+8h] [rbp-40h]
long long v27; // [rsp+8h] [rbp-40h]
v5 = a4;
v6 = 4LL * a3;
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v7 = *(_QWORD *)(a2 + 8);
v8 = (_DWORD *)(v7 - v6);
if ( v7 - v6 == v7 )
{
v15 = 4LL * a4;
v12 = *(_DWORD **)a2;
v11 = 0LL;
v6 = 0LL;
v13 = v7 - v15;
v25 = 0LL;
v10 = 0LL;
if ( *(_QWORD *)a2 == v13 )
return a1;
LABEL_8:
v16 = v13 - (_QWORD)v12;
v17 = (v13 - (long long)v12) >> 2;
if ( 0x1FFFFFFFFFFFFFFFLL - v11 < v17 )
std::__throw_length_error("vector::_M_range_insert");
if ( v6 >= v16 )
v17 = v11;
v18 = v11 + v17;
if ( v18 )
{
if ( v18 > 0x1FFFFFFFFFFFFFFFLL )
v18 = 0x1FFFFFFFFFFFFFFFLL;
v27 = v18;
v19 = (_DWORD *)operator new(4 * v18);
v26 = &v19[v27];
}
else
{
v26 = 0LL;
v19 = 0LL;
}
if ( v25 <= 4 )
{
if ( v25 != 4 )
{
v24 = &v19[v6 / 4];
if ( v16 <= 4 )
*v24 = *v12;
else
memmove(v24, v12, v16);
v23 = (char *)v24 + v16;
if ( !v10 )
goto LABEL_17;
goto LABEL_16;
}
v21 = (char *)&v19[v6 / 4];
*v19 = *v10;
if ( v16 > 4 )
goto LABEL_15;
}
else
{
v20 = v6;
v21 = (char *)&v19[v6 / 4];
memmove(v19, v10, v20);
if ( v16 > 4 )
{
LABEL_15:
v22 = v21;
v23 = &v21[v16];
memmove(v22, v12, v16);
LABEL_16:
operator delete(v10, *(_QWORD *)(a1 + 16) - (_QWORD)v10);
LABEL_17:
*(_QWORD *)a1 = v19;
*(_QWORD *)(a1 + 8) = v23;
*(_QWORD *)(a1 + 16) = v26;
return a1;
}
}
v23 = v21 + 4;
*((_DWORD *)v23 - 1) = *v12;
goto LABEL_16;
}
if ( v6 > 0x7FFFFFFFFFFFFFFCLL )
std::__throw_length_error("vector::_M_range_insert");
v9 = (_DWORD *)operator new(4LL * a3);
v25 = v6;
v10 = v9;
if ( v6 == 4 )
*v9 = *v8;
else
memmove(v9, v8, v6);
*(_QWORD *)a1 = v10;
*(_QWORD *)(a1 + 8) = &v10[v6 / 4];
v11 = (long long)v6 >> 2;
*(_QWORD *)(a1 + 16) = &v10[v6 / 4];
v12 = *(_DWORD **)a2;
v13 = *(_QWORD *)(a2 + 8) - 4 * v5;
if ( *(_QWORD *)a2 != v13 )
goto LABEL_8;
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOVSXD RDX,EDX
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
MOVSXD RBP,ECX
PUSH RBX
LEA RBX,[RDX*0x4]
SUB RSP,0x18
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI + 0x8]
MOV R14,RAX
SUB R14,RBX
CMP R14,RAX
JZ 0x00101750
MOV RAX,0x7ffffffffffffffc
CMP RAX,RBX
JC 0x001018ac
MOV RDI,RBX
LAB_001016ea:
CALL 0x00101110
MOV qword ptr [RSP],RBX
MOV R15,RAX
CMP RBX,0x4
JZ 0x00101840
MOV RDX,RBX
MOV RSI,R14
MOV RDI,RAX
CALL 0x00101140
LAB_0010170e:
LEA RAX,[R15 + RBX*0x1]
MOV qword ptr [R12],R15
SHL RBP,0x2
MOV RCX,RBX
MOV qword ptr [R12 + 0x8],RAX
SAR RCX,0x2
MOV qword ptr [R12 + 0x10],RAX
MOV RAX,qword ptr [R13 + 0x8]
MOV R13,qword ptr [R13]
SUB RAX,RBP
CMP R13,RAX
JNZ 0x0010176f
LAB_0010173b:
ADD RSP,0x18
MOV RAX,R12
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101750:
SHL RBP,0x2
MOV R13,qword ptr [R13]
XOR ECX,ECX
XOR EBX,EBX
SUB RAX,RBP
MOV qword ptr [RSP],0x0
XOR R15D,R15D
CMP R13,RAX
JZ 0x0010173b
LAB_0010176f:
MOV RDX,0x1fffffffffffffff
SUB RAX,R13
MOV RBP,RAX
SUB RDX,RCX
SAR RAX,0x2
CMP RDX,RAX
JC 0x001018a0
CMP RBX,RBP
CMOVNC RAX,RCX
ADD RAX,RCX
JNZ 0x00101806
MOV qword ptr [RSP + 0x8],0x0
XOR R14D,R14D
LAB_001017a7:
CMP qword ptr [RSP],0x4
JLE 0x00101850
MOV RDX,RBX
MOV RSI,R15
MOV RDI,R14
ADD RBX,R14
CALL 0x00101140
CMP RBP,0x4
JLE 0x00101890
LAB_001017cd:
MOV RDI,RBX
MOV RDX,RBP
MOV RSI,R13
ADD RBX,RBP
CALL 0x00101140
LAB_001017de:
MOV RSI,qword ptr [R12 + 0x10]
MOV RDI,R15
SUB RSI,R15
CALL 0x00101120
LAB_001017ee:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [R12],R14
MOV qword ptr [R12 + 0x8],RBX
MOV qword ptr [R12 + 0x10],RAX
JMP 0x0010173b
LAB_00101806:
MOV RDX,0x1fffffffffffffff
CMP RAX,RDX
CMOVA RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00101110
MOV R14,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,R14
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001017a7
LAB_00101840:
MOV EAX,dword ptr [R14]
MOV dword ptr [R15],EAX
JMP 0x0010170e
LAB_00101850:
JZ 0x0010187a
ADD RBX,R14
CMP RBP,0x4
JLE 0x001018b8
MOV RDX,RBP
MOV RSI,R13
MOV RDI,RBX
CALL 0x00101140
LAB_00101869:
ADD RBX,RBP
TEST R15,R15
JZ 0x001017ee
JMP 0x001017de
LAB_0010187a:
MOV EAX,dword ptr [R15]
ADD RBX,R14
MOV dword ptr [R14],EAX
CMP RBP,0x4
JG 0x001017cd
NOP dword ptr [RAX]
LAB_00101890:
MOV EAX,dword ptr [R13]
ADD RBX,0x4
MOV dword ptr [RBX + -0x4],EAX
JMP 0x001017de
LAB_001018a0:
LEA RDI,[0x102004]
CALL 0x001010e0
LAB_001018ac:
LEA RDI,[0x102004]
CALL 0x001010e0
LAB_001018b8:
MOV EAX,dword ptr [R13]
MOV dword ptr [RBX],EAX
JMP 0x00101869 | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
vector * func0(vector *param_1,int param_2,int param_3)
{
long *plVar1;
int8 *puVar2;
ulong uVar3;
int4 *__src;
int in_ECX;
ulong uVar4;
long lVar5;
int4 *puVar6;
int4 *__n;
int4 in_register_00000034;
int8 *__src_00;
int4 *unaff_R15;
int4 *local_48;
int4 *local_40;
__src_00 = (int8 *)CONCAT44(in_register_00000034,param_2);
lVar5 = (long)param_3;
__n = (int4 *)(long)in_ECX;
local_48 = (int4 *)(lVar5 * 4);
*(int8 *)(param_1 + 0x10) = 0;
*(int (*) [16])param_1 = (int [16])0x0;
puVar6 = (int4 *)__src_00[1];
__src = puVar6 + -lVar5;
if (__src == puVar6) {
__src_00 = (int8 *)*__src_00;
uVar4 = 0;
puVar2 = (int8 *)(puVar6 + -(long)__n);
local_48 = (int4 *)0x0;
unaff_R15 = (int4 *)0x0;
if (__src_00 == puVar2) {
return param_1;
}
LAB_0010176f:
__n = (int4 *)((long)puVar2 - (long)__src_00);
if (0x1fffffffffffffff - uVar4 < (ulong)((long)__n >> 2)) {
std::__throw_length_error("vector::_M_range_insert");
goto LAB_001018ac;
}
uVar3 = (long)__n >> 2;
if (__n <= local_48) {
uVar3 = uVar4;
}
uVar3 = uVar3 + uVar4;
if (uVar3 == 0) {
local_40 = (int4 *)0x0;
__src = (int4 *)0x0;
}
else {
if (0x1fffffffffffffff < uVar3) {
uVar3 = 0x1fffffffffffffff;
}
__src = (int4 *)operator_new(uVar3 * 4);
local_40 = __src + uVar3;
}
if ((long)local_48 < 5) {
if (local_48 == (int4 *)0x4) {
*__src = *unaff_R15;
goto joined_r0x00101887;
}
local_48 = (int4 *)((long)local_48 + (long)__src);
if ((long)__n < 5) goto LAB_001018b8;
memmove(local_48,__src_00,(size_t)__n);
goto LAB_00101869;
}
memmove(__src,unaff_R15,(size_t)local_48);
joined_r0x00101887:
if ((long)__n < 5) {
puVar6 = (int4 *)((long)local_48 + (long)__src) + 1;
*(int4 *)((long)local_48 + (long)__src) = *(int4 *)__src_00;
}
else {
puVar6 = (int4 *)((long)local_48 + (long)__src + (long)__n);
memmove((void *)((long)local_48 + (long)__src),__src_00,(size_t)__n);
}
}
else {
if (local_48 < (int4 *)0x7ffffffffffffffd) {
/* try { // try from 001016ea to 001018b7 has its CatchHandler @ 001018c0 */
unaff_R15 = (int4 *)operator_new((ulong)local_48);
if (local_48 == (int4 *)0x4) {
*unaff_R15 = *__src;
}
else {
memmove(unaff_R15,__src,(size_t)local_48);
}
*(int4 **)param_1 = unaff_R15;
*(int4 **)(param_1 + 8) = unaff_R15 + lVar5;
uVar4 = (long)local_48 >> 2;
*(int4 **)(param_1 + 0x10) = unaff_R15 + lVar5;
plVar1 = __src_00 + 1;
__src_00 = (int8 *)*__src_00;
puVar2 = (int8 *)(*plVar1 + (long)__n * -4);
if (__src_00 == puVar2) {
return param_1;
}
goto LAB_0010176f;
}
LAB_001018ac:
std::__throw_length_error("vector::_M_range_insert");
LAB_001018b8:
*local_48 = *(int4 *)__src_00;
LAB_00101869:
puVar6 = (int4 *)((long)local_48 + (long)__n);
if (unaff_R15 == (int4 *)0x0) goto LAB_001017ee;
}
operator_delete(unaff_R15,*(long *)(param_1 + 0x10) - (long)unaff_R15);
LAB_001017ee:
*(int4 **)param_1 = __src;
*(int4 **)(param_1 + 8) = puVar6;
*(int4 **)(param_1 + 0x10) = local_40;
return param_1;
} |
2,972 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<int*>& test_tup) {
for (auto ele : test_tup) {
if (ele == nullptr) {
return true;
}
}
return false;
}
| int main() {
int a = 10, b = 4, c = 5, d = 6;
int e = 7, f = 8, g = 9, h = 11, i = 14;
int j = 1, k = 2, l = 3, m = 4;
assert(func0({&a, &b, &c, &d, nullptr}) == true);
assert(func0({&e, &f, &g, &h, &i}) == false);
assert(func0({&j, &k, &l, &m, nullptr}) == true);
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
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1716 <_ZNKSt6vectorIPiSaIS0_EE5beginEv>
mov %rax,-0x28(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 176e <_ZNKSt6vectorIPiSaIS0_EE3endEv>
mov %rax,-0x20(%rbp)
lea -0x20(%rbp),%rdx
lea -0x28(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 17c6 <_ZN9__gnu_cxxneIPKPiSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_>
test %al,%al
je 12f6 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x8d>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 182a <_ZNK9__gnu_cxx17__normal_iteratorIPKPiSt6vectorIS1_SaIS1_EEEdeEv>
mov (%rax),%rax
mov %rax,-0x10(%rbp)
cmpq $0x0,-0x10(%rbp)
jne 12e8 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x7f>
mov $0x1,%eax
jmp 12fb <_Z5func0RKSt6vectorIPiSaIS0_EE+0x92>
lea -0x28(%rbp),%rax
mov %rax,%rdi
callq 1806 <_ZN9__gnu_cxx17__normal_iteratorIPKPiSt6vectorIS1_SaIS1_EEEppEv>
jmp 12b0 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x47>
mov $0x0,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 130f <_Z5func0RKSt6vectorIPiSaIS0_EE+0xa6>
callq 1140 <__stack_chk_fail@plt>
leaveq
retq
| _Z5func0RKSt6vectorIPiSaIS0_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIPiSaIS0_EE5beginEv; std::vector<int *>::begin(void)
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIPiSaIS0_EE3endEv; std::vector<int *>::end(void)
mov [rbp+var_20], rax
jmp short loc_12BF
loc_1292:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPKPiSt6vectorIS1_SaIS1_EEEdeEv; __gnu_cxx::__normal_iterator<int * const*,std::vector<int *>>::operator*(void)
mov rax, [rax]
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jnz short loc_12B3
mov eax, 1
jmp short loc_12DB
loc_12B3:
lea rax, [rbp+var_28]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPKPiSt6vectorIS1_SaIS1_EEEppEv; __gnu_cxx::__normal_iterator<int * const*,std::vector<int *>>::operator++(void)
loc_12BF:
lea rdx, [rbp+var_20]
lea rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPKPiSt6vectorIS1_SaIS1_EEEEbRKNS_17__normal_iteratorIT_T0_EESC_; __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_1292
mov eax, 0
loc_12DB:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_12EF
call ___stack_chk_fail
locret_12EF:
leave
retn | long long func0(long long a1)
{
long long v2; // [rsp+18h] [rbp-28h] BYREF
_QWORD v3[2]; // [rsp+20h] [rbp-20h] BYREF
unsigned long long v5; // [rsp+38h] [rbp-8h]
v5 = __readfsqword(0x28u);
v3[1] = a1;
v2 = std::vector<int *>::begin(a1);
v3[0] = std::vector<int *>::end(a1);
while ( (unsigned __int8)__gnu_cxx::operator!=<int * const*,std::vector<int *>>(&v2, v3) )
{
if ( !*(_QWORD *)__gnu_cxx::__normal_iterator<int * const*,std::vector<int *>>::operator*(&v2) )
return 1LL;
__gnu_cxx::__normal_iterator<int * const*,std::vector<int *>>::operator++(&v2);
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001016d6
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101722
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001012bf
LAB_00101292:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001017d6
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001012b3
MOV EAX,0x1
JMP 0x001012db
LAB_001012b3:
LEA RAX,[RBP + -0x28]
MOV RDI,RAX
CALL 0x001017b2
LAB_001012bf:
LEA RDX,[RBP + -0x20]
LEA RAX,[RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101772
TEST AL,AL
JNZ 0x00101292
MOV EAX,0x0
LAB_001012db:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001012ef
CALL 0x00101130
LAB_001012ef:
LEAVE
RET | /* func0(std::vector<int*, std::allocator<int*> > const&) */
int8 func0(vector *param_1)
{
bool bVar1;
long *plVar2;
int8 uVar3;
long in_FS_OFFSET;
int8 local_30;
int8 local_28;
vector<int*,std::allocator<int*>> *local_20;
long local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_20 = (vector<int*,std::allocator<int*>> *)param_1;
local_30 = std::vector<int*,std::allocator<int*>>::begin
((vector<int*,std::allocator<int*>> *)param_1);
local_28 = std::vector<int*,std::allocator<int*>>::end(local_20);
do {
bVar1 = operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_28);
if (!bVar1) {
uVar3 = 0;
LAB_001012db:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
plVar2 = (long *)__normal_iterator<int*const*,std::vector<int*,std::allocator<int*>>>::operator*
((__normal_iterator<int*const*,std::vector<int*,std::allocator<int*>>>
*)&local_30);
local_18 = *plVar2;
if (local_18 == 0) {
uVar3 = 1;
goto LAB_001012db;
}
__normal_iterator<int*const*,std::vector<int*,std::allocator<int*>>>::operator++
((__normal_iterator<int*const*,std::vector<int*,std::allocator<int*>>> *)&local_30);
} while( true );
} |
2,973 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<int*>& test_tup) {
for (auto ele : test_tup) {
if (ele == nullptr) {
return true;
}
}
return false;
}
| int main() {
int a = 10, b = 4, c = 5, d = 6;
int e = 7, f = 8, g = 9, h = 11, i = 14;
int j = 1, k = 2, l = 3, m = 4;
assert(func0({&a, &b, &c, &d, nullptr}) == true);
assert(func0({&e, &f, &g, &h, &i}) == false);
assert(func0({&j, &k, &l, &m, nullptr}) == true);
return 0;
}
| O1 | cpp | func0(std::vector<int*, std::allocator<int*> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
je 126e <_Z5func0RKSt6vectorIPiSaIS0_EE+0x25>
cmpq $0x0,(%rax)
je 1274 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x2b>
add $0x8,%rax
cmp %rax,%rdx
jne 1259 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x10>
mov $0x0,%eax
retq
mov $0x0,%eax
retq
mov $0x1,%eax
retq
| _Z5func0RKSt6vectorIPiSaIS0_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jz short loc_122E
loc_1219:
cmp qword ptr [rax], 0
jz short loc_1234
add rax, 8
cmp rdx, rax
jnz short loc_1219
mov eax, 0
retn
loc_122E:
mov eax, 0
retn
loc_1234:
mov eax, 1
retn | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 0LL;
while ( *v1 )
{
if ( v2 == ++v1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JZ 0x0010122e
LAB_00101219:
CMP qword ptr [RAX],0x0
JZ 0x00101234
ADD RAX,0x8
CMP RDX,RAX
JNZ 0x00101219
MOV EAX,0x0
RET
LAB_0010122e:
MOV EAX,0x0
RET
LAB_00101234:
MOV EAX,0x1
RET | /* func0(std::vector<int*, std::allocator<int*> > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
if (*(long **)(param_1 + 8) == plVar1) {
return 0;
}
do {
if (*plVar1 == 0) {
return 1;
}
plVar1 = plVar1 + 1;
} while (*(long **)(param_1 + 8) != plVar1);
return 0;
} |
2,974 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<int*>& test_tup) {
for (auto ele : test_tup) {
if (ele == nullptr) {
return true;
}
}
return false;
}
| int main() {
int a = 10, b = 4, c = 5, d = 6;
int e = 7, f = 8, g = 9, h = 11, i = 14;
int j = 1, k = 2, l = 3, m = 4;
assert(func0({&a, &b, &c, &d, nullptr}) == true);
assert(func0({&e, &f, &g, &h, &i}) == false);
assert(func0({&j, &k, &l, &m, nullptr}) == true);
return 0;
}
| O2 | cpp | func0(std::vector<int*, std::allocator<int*> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1551 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x21>
jmp 1560 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x30>
nopw 0x0(%rax,%rax,1)
add $0x8,%rax
cmp %rax,%rdx
je 1560 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x30>
cmpq $0x0,(%rax)
jne 1548 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x18>
mov $0x1,%eax
retq
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt6vectorIPiSaIS0_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_1541
jmp short loc_1550
loc_1538:
add rax, 8
cmp rdx, rax
jz short loc_1550
loc_1541:
cmp qword ptr [rax], 0
jnz short loc_1538
mov eax, 1
retn
loc_1550:
xor eax, eax
retn | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 0LL;
while ( *v1 )
{
if ( v2 == ++v1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x00101541
JMP 0x00101550
LAB_00101538:
ADD RAX,0x8
CMP RDX,RAX
JZ 0x00101550
LAB_00101541:
CMP qword ptr [RAX],0x0
JNZ 0x00101538
MOV EAX,0x1
RET
LAB_00101550:
XOR EAX,EAX
RET | /* func0(std::vector<int*, std::allocator<int*> > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
while( true ) {
if (*(long **)(param_1 + 8) == plVar1) {
return 0;
}
if (*plVar1 == 0) break;
plVar1 = plVar1 + 1;
}
return 1;
} |
2,975 | func0 |
#include <iostream>
#include <vector>
#include <cassert>
| bool func0(const std::vector<int*>& test_tup) {
for (auto ele : test_tup) {
if (ele == nullptr) {
return true;
}
}
return false;
}
| int main() {
int a = 10, b = 4, c = 5, d = 6;
int e = 7, f = 8, g = 9, h = 11, i = 14;
int j = 1, k = 2, l = 3, m = 4;
assert(func0({&a, &b, &c, &d, nullptr}) == true);
assert(func0({&e, &f, &g, &h, &i}) == false);
assert(func0({&j, &k, &l, &m, nullptr}) == true);
return 0;
}
| O3 | cpp | func0(std::vector<int*, std::allocator<int*> > const&):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1581 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x21>
jmp 1590 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x30>
nopw 0x0(%rax,%rax,1)
add $0x8,%rax
cmp %rax,%rdx
je 1590 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x30>
cmpq $0x0,(%rax)
jne 1578 <_Z5func0RKSt6vectorIPiSaIS0_EE+0x18>
mov $0x1,%eax
retq
nopl (%rax)
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0RKSt6vectorIPiSaIS0_EE:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_1541
jmp short loc_1550
loc_1538:
add rax, 8
cmp rdx, rax
jz short loc_1550
loc_1541:
cmp qword ptr [rax], 0
jnz short loc_1538
mov eax, 1
retn
loc_1550:
xor eax, eax
retn | long long func0(long long a1)
{
_QWORD *v1; // rax
_QWORD *v2; // rdx
v1 = *(_QWORD **)a1;
v2 = *(_QWORD **)(a1 + 8);
if ( v2 == *(_QWORD **)a1 )
return 0LL;
while ( *v1 )
{
if ( v2 == ++v1 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x00101541
JMP 0x00101550
LAB_00101538:
ADD RAX,0x8
CMP RDX,RAX
JZ 0x00101550
LAB_00101541:
CMP qword ptr [RAX],0x0
JNZ 0x00101538
MOV EAX,0x1
RET
LAB_00101550:
XOR EAX,EAX
RET | /* func0(std::vector<int*, std::allocator<int*> > const&) */
int8 func0(vector *param_1)
{
long *plVar1;
plVar1 = *(long **)param_1;
while( true ) {
if (*(long **)(param_1 + 8) == plVar1) {
return 0;
}
if (*plVar1 == 0) break;
plVar1 = plVar1 + 1;
}
return 1;
} |
2,976 | func0 |
#include <vector>
#include <string>
#include <assert.h>
| std::vector<int> func0(int startnum, int endnum) {
std::vector<int> result;
for (int n = startnum; n <= endnum; n++) {
bool divisible = true;
std::string s = std::to_string(n);
for (char c : s) {
int digit = c - '0';
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
}
if (divisible) {
result.push_back(n);
}
}
return result;
}
| int main() {
std::vector<int> vec1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
std::vector<int> vec2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
std::vector<int> vec3 = {22, 24};
assert(func0(1, 22) == vec1);
assert(func0(1, 15) == vec2);
assert(func0(20, 25) == vec3);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %edx,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 2b2a <_ZNSt6vectorIiSaIiEEC1Ev>
mov -0x7c(%rbp),%eax
mov %eax,-0x60(%rbp)
mov -0x60(%rbp),%eax
cmp %eax,-0x80(%rbp)
jl 25ed <_Z5func0ii+0x144>
movb $0x1,-0x62(%rbp)
mov -0x60(%rbp),%edx
lea -0x40(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 2a84 <_ZNSt7__cxx119to_stringEi>
lea -0x40(%rbp),%rax
mov %rax,-0x48(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 22d0 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv@plt>
mov %rax,-0x58(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 2260 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv@plt>
mov %rax,-0x50(%rbp)
lea -0x50(%rbp),%rdx
lea -0x58(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2e4c <_ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_>
test %al,%al
je 2584 <_Z5func0ii+0xdb>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 2eb0 <_ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv>
movzbl (%rax),%eax
mov %al,-0x61(%rbp)
movsbl -0x61(%rbp),%eax
sub $0x30,%eax
mov %eax,-0x5c(%rbp)
cmpl $0x0,-0x5c(%rbp)
je 2570 <_Z5func0ii+0xc7>
mov -0x60(%rbp),%eax
cltd
idivl -0x5c(%rbp)
mov %edx,%eax
test %eax,%eax
je 2576 <_Z5func0ii+0xcd>
movb $0x0,-0x62(%rbp)
jmp 2584 <_Z5func0ii+0xdb>
lea -0x58(%rbp),%rax
mov %rax,%rdi
callq 2e8c <_ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv>
jmp 252a <_Z5func0ii+0x81>
cmpb $0x0,-0x62(%rbp)
je 259d <_Z5func0ii+0xf4>
lea -0x60(%rbp),%rdx
mov -0x78(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 2ec6 <_ZNSt6vectorIiSaIiEE9push_backERKi>
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2270 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov -0x60(%rbp),%eax
add $0x1,%eax
mov %eax,-0x60(%rbp)
jmpq 24e1 <_Z5func0ii+0x38>
endbr64
mov %rax,%rbx
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 2270 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev@plt>
mov %rbx,%rax
jmp 25d3 <_Z5func0ii+0x12a>
endbr64
mov %rax,%rbx
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq 2e04 <_ZNSt6vectorIiSaIiEED1Ev>
mov %rbx,%rax
mov %rax,%rdi
callq 2380 <_Unwind_Resume@plt>
mov -0x18(%rbp),%rax
xor %fs:0x28,%rax
je 2602 <_Z5func0ii+0x159>
callq 2330 <__stack_chk_fail@plt>
mov -0x78(%rbp),%rax
add $0x78,%rsp
pop %rbx
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov [rbp+var_80], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov eax, [rbp+var_7C]
mov [rbp+var_60], eax
jmp loc_144B
loc_1386:
mov [rbp+var_62], 1
mov edx, [rbp+var_60]
lea rax, [rbp+var_40]
mov esi, edx; int
mov rdi, rax; this
call _ZNSt7__cxx119to_stringEi; std::to_string(int)
lea rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rbp+var_58], rax
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rbp+var_50], rax
jmp short loc_1406
loc_13C5:
lea rax, [rbp+var_58]
mov rdi, rax
call _ZNK9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEdeEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator*(void)
movzx eax, byte ptr [rax]
mov [rbp+var_61], al
movsx eax, [rbp+var_61]
sub eax, 30h ; '0'
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jz short loc_13F4
mov eax, [rbp+var_60]
cdq
idiv [rbp+var_5C]
mov eax, edx
test eax, eax
jz short loc_13FA
loc_13F4:
mov [rbp+var_62], 0
jmp short loc_141D
loc_13FA:
lea rax, [rbp+var_58]
mov rdi, rax
call _ZN9__gnu_cxx17__normal_iteratorIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEppEv; __gnu_cxx::__normal_iterator<char *,std::string>::operator++(void)
loc_1406:
lea rdx, [rbp+var_50]
lea rax, [rbp+var_58]
mov rsi, rdx
mov rdi, rax
call _ZN9__gnu_cxxneIPcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEbRKNS_17__normal_iteratorIT_T0_EESD_; __gnu_cxx::operator!=<char *,std::string>(__gnu_cxx::__normal_iterator<char *,std::string> const&,__gnu_cxx::__normal_iterator<char *,std::string> const&)
test al, al
jnz short loc_13C5
loc_141D:
cmp [rbp+var_62], 0
jz short loc_1436
lea rdx, [rbp+var_60]
mov rax, [rbp+var_78]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
loc_1436:
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov eax, [rbp+var_60]
add eax, 1
mov [rbp+var_60], eax
loc_144B:
mov eax, [rbp+var_60]
cmp [rbp+var_80], eax
jge loc_1386
jmp short loc_1497
endbr64
mov rbx, rax
lea rax, [rbp+var_40]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, rbx
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_148F
call ___stack_chk_fail
loc_148F:
mov rdi, rax; struct _Unwind_Exception *
call __Unwind_Resume
loc_1497:
mov rax, [rbp+var_18]
sub rax, fs:28h
jz short loc_14AB
call ___stack_chk_fail
loc_14AB:
mov rax, [rbp+var_78]
mov rbx, [rbp+var_8]
leave
retn | long long func0(long long a1, int a2, int a3)
{
char v5; // [rsp+1Eh] [rbp-62h]
char v6; // [rsp+1Fh] [rbp-61h]
int i; // [rsp+20h] [rbp-60h] BYREF
int v8; // [rsp+24h] [rbp-5Ch]
long long v9; // [rsp+28h] [rbp-58h] BYREF
long long v10; // [rsp+30h] [rbp-50h] BYREF
_BYTE *v11; // [rsp+38h] [rbp-48h]
_BYTE v12[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v13; // [rsp+68h] [rbp-18h]
v13 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i = a2; a3 >= i; ++i )
{
v5 = 1;
std::to_string((std::__cxx11 *)v12, i);
v11 = v12;
v9 = std::string::begin(v12);
v10 = std::string::end(v11);
while ( (unsigned __int8)__gnu_cxx::operator!=<char *,std::string>(&v9, &v10) )
{
v6 = *(_BYTE *)__gnu_cxx::__normal_iterator<char *,std::string>::operator*(&v9);
v8 = v6 - 48;
if ( v6 == 48 || i % v8 )
{
v5 = 0;
break;
}
__gnu_cxx::__normal_iterator<char *,std::string>::operator++(&v9);
}
if ( v5 )
std::vector<int>::push_back(a1, &i);
std::string::~string(v12);
}
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV dword ptr [RBP + -0x80],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x00101a6a
MOV EAX,dword ptr [RBP + -0x7c]
MOV dword ptr [RBP + -0x60],EAX
JMP 0x0010144b
LAB_00101386:
MOV byte ptr [RBP + -0x62],0x1
MOV EDX,dword ptr [RBP + -0x60]
LEA RAX,[RBP + -0x40]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101957
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001011d0
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101180
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00101406
LAB_001013c5:
LEA RAX,[RBP + -0x58]
MOV RDI,RAX
CALL 0x00101ff0
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x61],AL
MOVSX EAX,byte ptr [RBP + -0x61]
SUB EAX,0x30
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x001013f4
MOV EAX,dword ptr [RBP + -0x60]
CDQ
IDIV dword ptr [RBP + -0x5c]
MOV EAX,EDX
TEST EAX,EAX
JZ 0x001013fa
LAB_001013f4:
MOV byte ptr [RBP + -0x62],0x0
JMP 0x0010141d
LAB_001013fa:
LEA RAX,[RBP + -0x58]
MOV RDI,RAX
CALL 0x00101fcc
LAB_00101406:
LEA RDX,[RBP + -0x50]
LEA RAX,[RBP + -0x58]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101f8c
TEST AL,AL
JNZ 0x001013c5
LAB_0010141d:
CMP byte ptr [RBP + -0x62],0x0
JZ 0x00101436
LEA RDX,[RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x78]
MOV RSI,RDX
MOV RDI,RAX
LAB_00101431:
CALL 0x00102006
LAB_00101436:
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101190
MOV EAX,dword ptr [RBP + -0x60]
ADD EAX,0x1
MOV dword ptr [RBP + -0x60],EAX
LAB_0010144b:
MOV EAX,dword ptr [RBP + -0x60]
CMP dword ptr [RBP + -0x80],EAX
JGE 0x00101386
JMP 0x00101497
LAB_00101497:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001014ab
CALL 0x00101210
LAB_001014ab:
MOV RAX,qword ptr [RBP + -0x78]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
bool bVar1;
bool bVar2;
char *pcVar3;
int in_EDX;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_68;
int local_64;
int8 local_60;
int8 local_58;
string *local_50;
string local_48 [40];
long local_20;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::vector<int,std::allocator<int>>::vector(this);
local_68 = param_2;
do {
if (in_EDX < local_68) {
if (local_20 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
}
bVar1 = true;
std::to_string((int)local_48);
local_50 = local_48;
local_60 = std::string::begin();
local_58 = std::string::end();
while( true ) {
bVar2 = operator!=((__normal_iterator *)&local_60,(__normal_iterator *)&local_58);
if (!bVar2) break;
pcVar3 = (char *)__normal_iterator<char*,std::string>::operator*
((__normal_iterator<char*,std::string> *)&local_60);
local_64 = *pcVar3 + -0x30;
if ((local_64 == 0) || (local_68 % local_64 != 0)) {
bVar1 = false;
break;
}
__normal_iterator<char*,std::string>::operator++
((__normal_iterator<char*,std::string> *)&local_60);
}
if (bVar1) {
/* try { // try from 00101431 to 00101435 has its CatchHandler @ 00101459 */
std::vector<int,std::allocator<int>>::push_back(this,&local_68);
}
std::string::~string(local_48);
local_68 = local_68 + 1;
} while( true );
} |
2,977 | func0 |
#include <vector>
#include <string>
#include <assert.h>
| std::vector<int> func0(int startnum, int endnum) {
std::vector<int> result;
for (int n = startnum; n <= endnum; n++) {
bool divisible = true;
std::string s = std::to_string(n);
for (char c : s) {
int digit = c - '0';
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
}
if (divisible) {
result.push_back(n);
}
}
return result;
}
| int main() {
std::vector<int> vec1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
std::vector<int> vec2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
std::vector<int> vec3 = {22, 24};
assert(func0(1, 22) == vec1);
assert(func0(1, 15) == vec2);
assert(func0(20, 25) == vec3);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %esi,0xc(%rsp)
cmp %edx,%esi
jg 1391 <_Z5func0ii+0x128>
mov %esi,%r8d
mov %edx,%ebp
lea 0x10(%rsp),%r12
jmp 1324 <_Z5func0ii+0xbb>
mov 0x10(%rsp),%rsi
mov %rsi,%r8
add 0x18(%rsp),%r8
cmp %rsi,%r8
je 12e9 <_Z5func0ii+0x80>
mov 0xc(%rsp),%edi
movsbl (%rsi),%eax
sub $0x30,%eax
mov %eax,%ecx
je 12fe <_Z5func0ii+0x95>
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 12fe <_Z5func0ii+0x95>
add $0x1,%rsi
cmp %rsi,%r8
jne 12cd <_Z5func0ii+0x64>
mov 0x8(%rbx),%rsi
cmp 0x10(%rbx),%rsi
je 1349 <_Z5func0ii+0xe0>
mov 0xc(%rsp),%eax
mov %eax,(%rsi)
addq $0x4,0x8(%rbx)
mov 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
cmp %rax,%rdi
je 1312 <_Z5func0ii+0xa9>
callq 1120 <_ZdlPv@plt>
mov 0xc(%rsp),%eax
lea 0x1(%rax),%r8d
mov %r8d,0xc(%rsp)
cmp %ebp,%r8d
jg 1391 <_Z5func0ii+0x128>
lea 0xd28(%rip),%rcx
mov $0x10,%edx
mov 0x2ca1(%rip),%rsi
mov %r12,%rdi
mov $0x0,%eax
callq 1705 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPKS8_P13__va_list_tagEmSB_z>
jmpq 12b7 <_Z5func0ii+0x4e>
lea 0xc(%rsp),%rdx
mov %rbx,%rdi
callq 198e <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
jmp 12fe <_Z5func0ii+0x95>
endbr64
mov %rax,%rbp
mov 0x10(%rsp),%rdi
lea 0x20(%rsp),%rax
cmp %rax,%rdi
je 1373 <_Z5func0ii+0x10a>
callq 1120 <_ZdlPv@plt>
mov (%rbx),%rdi
test %rdi,%rdi
je 1380 <_Z5func0ii+0x117>
callq 1120 <_ZdlPv@plt>
mov %rbp,%rdi
callq 1160 <_Unwind_Resume@plt>
endbr64
mov %rax,%rbp
jmp 1373 <_Z5func0ii+0x10a>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 13ad <_Z5func0ii+0x144>
mov %rbx,%rax
add $0x40,%rsp
pop %rbx
pop %rbp
pop %r12
retq
callq 1140 <__stack_chk_fail@plt>
| _Z5func0ii:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 118h
mov r14, rdi
mov r12d, esi
mov r15d, edx
mov rax, fs:28h
mov [rsp+148h+var_40], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov [rsp+148h+var_13C], esi
cmp esi, edx
jle loc_1581
loc_12DD:
mov rax, [rsp+148h+var_40]
sub rax, fs:28h
jnz loc_18BA
mov rax, r14
add rsp, 118h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1309:
mov ebx, 1
loc_130E:
lea rdi, [rsp+148h+var_138]
lea rax, [rsp+148h+var_128]
mov [rsp+148h+var_138], rax
lea esi, [rbx+r13+1]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r13d, r13b
add r13, [rsp+148h+var_138]
mov rax, 3330323031303030h
mov rdx, 3730363035303430h
mov [rsp+148h+var_118], rax
mov [rsp+148h+var_110], rdx
mov rax, 3131303139303830h
mov rdx, 3531343133313231h
mov [rsp+148h+var_108], rax
mov [rsp+148h+var_100], rdx
mov rax, 3931383137313631h
mov rdx, 3332323231323032h
mov [rsp+148h+var_F8], rax
mov [rsp+148h+var_F0], rdx
mov rax, 3732363235323432h
mov rdx, 3133303339323832h
mov [rsp+148h+var_E8], rax
mov [rsp+148h+var_E0], rdx
mov rax, 3533343333333233h
mov rdx, 3933383337333633h
mov [rsp+148h+var_D8], rax
mov [rsp+148h+var_D0], rdx
mov rax, 3334323431343034h
mov rdx, 3734363435343434h
mov [rsp+148h+var_C8], rax
mov [rsp+148h+var_C0], rdx
mov rax, 3135303539343834h
mov rdx, 3535343533353235h
mov [rsp+148h+var_B8], rax
mov [rsp+148h+var_B0], rdx
mov rax, 3935383537353635h
mov rdx, 3336323631363036h
mov [rsp+148h+var_A8], rax
mov [rsp+148h+var_A0], rdx
mov rax, 3736363635363436h
mov rdx, 3137303739363836h
mov [rsp+148h+var_98], rax
mov [rsp+148h+var_90], rdx
mov rax, 3537343733373237h
mov rdx, 3937383737373637h
mov [rsp+148h+var_88], rax
mov [rsp+148h+var_80], rdx
mov rax, 3338323831383038h
mov rdx, 3738363835383438h
mov [rsp+148h+var_78], rax
mov [rsp+148h+var_70], rdx
mov rax, 3139303939383838h
mov rdx, 3539343933393239h
mov [rsp+148h+var_68], rax
mov [rsp+148h+var_60], rdx
mov rax, 3935393439333932h
mov rdx, 39393839373936h
mov [rsp+148h+var_60+1], rax
mov [rsp+148h+var_57], rdx
cmp ebp, 63h ; 'c'
ja loc_17E1
loc_14F4:
add ebp, ebp
lea eax, [rbp+1]
movzx eax, byte ptr [rsp+rax+148h+var_118]
mov [r13+1], al
mov ebp, ebp
movzx ebp, byte ptr [rsp+rbp+148h+var_118]
loc_1509:
mov [r13+0], bpl
mov rsi, [rsp+148h+var_138]
mov rdi, rsi
add rdi, [rsp+148h+var_130]
cmp rdi, rsi
jz short loc_153C
loc_151F:
movsx eax, byte ptr [rsi]
sub eax, 30h ; '0'
mov ecx, eax
jz short loc_1552
mov eax, r12d
cdq
idiv ecx
test edx, edx
jnz short loc_1552
add rsi, 1
cmp rdi, rsi
jnz short loc_151F
loc_153C:
mov rsi, [r14+8]
cmp rsi, [r14+10h]
jz loc_1842
mov [rsi], r12d
add qword ptr [r14+8], 4
loc_1552:
mov rdi, [rsp+148h+var_138]; void *
lea rax, [rsp+148h+var_128]
cmp rdi, rax
jz short loc_156F
mov rax, [rsp+148h+var_128]
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_156F:
add r12d, 1
mov [rsp+148h+var_13C], r12d
cmp r12d, r15d
jg loc_12DD
loc_1581:
mov r13d, r12d
shr r13d, 1Fh
mov ebp, r12d
neg ebp
cmovs ebp, r12d
cmp ebp, 9
jbe loc_188D
cmp ebp, 63h ; 'c'
jbe loc_1309
cmp ebp, 3E7h
jbe short loc_15F9
cmp ebp, 270Fh
jbe loc_1838
mov eax, ebp
mov ebx, 1
mov rcx, 346DC5D63886594Bh
loc_15C8:
mov eax, eax
mul rcx
shr rdx, 0Bh
mov eax, edx
add ebx, 4
cmp edx, 9
jbe short loc_1601
cmp edx, 63h ; 'c'
jbe loc_130E
cmp edx, 3E7h
jbe short loc_15FE
cmp edx, 270Fh
ja short loc_15C8
loc_15F4:
add ebx, 3
jmp short loc_1601
loc_15F9:
mov ebx, 1
loc_15FE:
add ebx, 2
loc_1601:
lea rdi, [rsp+148h+var_138]
lea rax, [rsp+148h+var_128]
mov [rsp+148h+var_138], rax
lea esi, [r13+rbx+0]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r13d, r13b
add r13, [rsp+148h+var_138]
mov rax, 3330323031303030h
mov rdx, 3730363035303430h
mov [rsp+148h+var_118], rax
mov [rsp+148h+var_110], rdx
mov rax, 3131303139303830h
mov rdx, 3531343133313231h
mov [rsp+148h+var_108], rax
mov [rsp+148h+var_100], rdx
mov rax, 3931383137313631h
mov rdx, 3332323231323032h
mov [rsp+148h+var_F8], rax
mov [rsp+148h+var_F0], rdx
mov rax, 3732363235323432h
mov rdx, 3133303339323832h
mov [rsp+148h+var_E8], rax
mov [rsp+148h+var_E0], rdx
mov rax, 3533343333333233h
mov rdx, 3933383337333633h
mov [rsp+148h+var_D8], rax
mov [rsp+148h+var_D0], rdx
mov rax, 3334323431343034h
mov rdx, 3734363435343434h
mov [rsp+148h+var_C8], rax
mov [rsp+148h+var_C0], rdx
mov rax, 3135303539343834h
mov rdx, 3535343533353235h
mov [rsp+148h+var_B8], rax
mov [rsp+148h+var_B0], rdx
mov rax, 3935383537353635h
mov rdx, 3336323631363036h
mov [rsp+148h+var_A8], rax
mov [rsp+148h+var_A0], rdx
mov rax, 3736363635363436h
mov rdx, 3137303739363836h
mov [rsp+148h+var_98], rax
mov [rsp+148h+var_90], rdx
mov rax, 3537343733373237h
mov rdx, 3937383737373637h
mov [rsp+148h+var_88], rax
mov [rsp+148h+var_80], rdx
mov rax, 3338323831383038h
mov rdx, 3738363835383438h
mov [rsp+148h+var_78], rax
mov [rsp+148h+var_70], rdx
mov rax, 3139303939383838h
mov rdx, 3539343933393239h
mov [rsp+148h+var_68], rax
mov [rsp+148h+var_60], rdx
mov rax, 3935393439333932h
mov rdx, 39393839373936h
mov [rsp+148h+var_60+1], rax
mov [rsp+148h+var_57], rdx
sub ebx, 1
loc_17E1:
mov edx, ebp
imul rdx, 51EB851Fh
shr rdx, 25h
imul ecx, edx, 64h ; 'd'
mov eax, ebp
sub eax, ecx
add eax, eax
mov ecx, ebp
mov ebp, edx
mov edx, ebx
lea esi, [rax+1]
movzx esi, byte ptr [rsp+rsi+148h+var_118]
mov [r13+rdx+0], sil
lea edx, [rbx-1]
mov eax, eax
movzx eax, byte ptr [rsp+rax+148h+var_118]
mov [r13+rdx+0], al
sub ebx, 2
cmp ecx, 270Fh
ja short loc_17E1
cmp ecx, 3E7h
ja loc_14F4
loc_1830:
add ebp, 30h ; '0'
jmp loc_1509
loc_1838:
mov ebx, 1
jmp loc_15F4
loc_1842:
lea rdx, [rsp+148h+var_13C]
mov rdi, r14
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_1552
endbr64
mov rbx, rax
lea rdi, [rsp+arg_8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_disposeEv; std::string::_M_dispose(void)
mov rdi, r14
call _ZNSt6vectorIiSaIiEED2Ev; std::vector<int>::~vector()
mov rax, [rsp+arg_100]
sub rax, fs:28h
jz short loc_1885
call ___stack_chk_fail
loc_1885:
mov rdi, rbx; struct _Unwind_Exception *
call __Unwind_Resume
loc_188D:
lea rdi, [rsp+148h+var_138]
lea rax, [rsp+148h+var_128]
mov [rsp+148h+var_138], rax
lea esi, [r13+1]
mov esi, esi
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movzx r13d, r13b
add r13, [rsp+148h+var_138]
jmp loc_1830
loc_18BA:
call ___stack_chk_fail | _QWORD * func0(_QWORD *a1, int a2, int a3)
{
int v3; // r12d
unsigned int v6; // ebx
char *v7; // r13
int v8; // ebp
char v9; // bp
_BYTE *v10; // rsi
int *v11; // rsi
unsigned int v12; // r13d
unsigned int v13; // ebp
unsigned int v14; // eax
unsigned int v15; // edx
unsigned int v16; // eax
unsigned int v17; // ecx
int i; // [rsp+Ch] [rbp-13Ch] BYREF
void *v19; // [rsp+10h] [rbp-138h] BYREF
long long v20; // [rsp+18h] [rbp-130h]
_QWORD v21[2]; // [rsp+20h] [rbp-128h] BYREF
char v22[216]; // [rsp+30h] [rbp-118h] BYREF
unsigned long long v23; // [rsp+108h] [rbp-40h]
v3 = a2;
v23 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
for ( i = a2; v3 <= a3; i = ++v3 )
{
v12 = (unsigned int)v3 >> 31;
v13 = -v3;
if ( v3 > 0 )
v13 = v3;
if ( v13 <= 9 )
{
v19 = v21;
std::string::_M_construct(&v19, v12 + 1, 45LL);
v7 = (char *)v19 + (v3 < 0);
LABEL_32:
v9 = v13 + 48;
goto LABEL_6;
}
if ( v13 <= 0x63 )
{
v6 = 1;
LABEL_4:
v19 = v21;
std::string::_M_construct(&v19, v6 + v12 + 1, 45LL);
v7 = (char *)v19 + (v3 < 0);
strcpy(
v22,
"0001020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455"
"5657585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
if ( v13 <= 0x63 )
goto LABEL_5;
}
else
{
if ( v13 <= 0x3E7 )
{
v6 = 1;
LABEL_28:
v6 += 2;
}
else if ( v13 <= 0x270F )
{
v6 = 1;
LABEL_26:
v6 += 3;
}
else
{
v14 = v13;
v6 = 1;
while ( 1 )
{
v15 = v14 / 0x2710;
v14 = v15;
v6 += 4;
if ( v15 <= 9 )
break;
if ( v15 <= 0x63 )
goto LABEL_4;
if ( v15 <= 0x3E7 )
goto LABEL_28;
if ( v15 <= 0x270F )
goto LABEL_26;
}
}
v19 = v21;
std::string::_M_construct(&v19, v12 + v6, 45LL);
v7 = (char *)v19 + (v3 < 0);
strcpy(
v22,
"0001020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455"
"5657585960616263646566676869707172737475767778798081828384858687888990919293949596979899");
--v6;
}
do
{
v16 = 2 * (v13 % 0x64);
v17 = v13;
v13 /= 0x64u;
v7[v6] = v22[v16 + 1];
v7[v6 - 1] = v22[v16];
v6 -= 2;
}
while ( v17 > 0x270F );
if ( v17 <= 0x3E7 )
goto LABEL_32;
LABEL_5:
v8 = 2 * v13;
v7[1] = v22[v8 + 1];
v9 = v22[v8];
LABEL_6:
*v7 = v9;
v10 = v19;
if ( (char *)v19 + v20 == v19 )
{
LABEL_10:
v11 = (int *)a1[1];
if ( v11 == (int *)a1[2] )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v11, &i);
}
else
{
*v11 = v3;
a1[1] += 4LL;
}
}
else
{
while ( *v10 != 48 && !(v3 % ((char)*v10 - 48)) )
{
if ( (char *)v19 + v20 == ++v10 )
goto LABEL_10;
}
}
if ( v19 != v21 )
operator delete(v19, v21[0] + 1LL);
}
return a1;
} | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x118
MOV R14,RDI
MOV R12D,ESI
MOV R15D,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x108],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0xc],ESI
CMP ESI,EDX
JLE 0x00101581
LAB_001012dd:
MOV RAX,qword ptr [RSP + 0x108]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x001018ba
MOV RAX,R14
ADD RSP,0x118
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101309:
MOV EBX,0x1
LAB_0010130e:
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA ESI,[RBX + R13*0x1 + 0x1]
MOV EDX,0x2d
CALL 0x00101160
MOVZX R13D,R13B
ADD R13,qword ptr [RSP + 0x10]
MOV RAX,0x3330323031303030
MOV RDX,0x3730363035303430
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,0x3131303139303830
MOV RDX,0x3531343133313231
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,0x3931383137313631
MOV RDX,0x3332323231323032
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,0x3732363235323432
MOV RDX,0x3133303339323832
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,0x3533343333333233
MOV RDX,0x3933383337333633
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,0x3334323431343034
MOV RDX,0x3734363435343434
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,0x3135303539343834
MOV RDX,0x3535343533353235
MOV qword ptr [RSP + 0x90],RAX
MOV qword ptr [RSP + 0x98],RDX
MOV RAX,0x3935383537353635
MOV RDX,0x3336323631363036
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0xa8],RDX
MOV RAX,0x3736363635363436
MOV RDX,0x3137303739363836
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOV RAX,0x3537343733373237
MOV RDX,0x3937383737373637
MOV qword ptr [RSP + 0xc0],RAX
MOV qword ptr [RSP + 0xc8],RDX
MOV RAX,0x3338323831383038
MOV RDX,0x3738363835383438
MOV qword ptr [RSP + 0xd0],RAX
MOV qword ptr [RSP + 0xd8],RDX
MOV RAX,0x3139303939383838
MOV RDX,0x3539343933393239
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xe8],RDX
MOV RAX,0x3935393439333932
MOV RDX,0x39393839373936
MOV qword ptr [RSP + 0xe9],RAX
MOV qword ptr [RSP + 0xf1],RDX
CMP EBP,0x63
JA 0x001017e1
LAB_001014f4:
ADD EBP,EBP
LEA EAX,[RBP + 0x1]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x30]
MOV byte ptr [R13 + 0x1],AL
MOV EBP,EBP
MOVZX EBP,byte ptr [RSP + RBP*0x1 + 0x30]
LAB_00101509:
MOV byte ptr [R13],BPL
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,RSI
ADD RDI,qword ptr [RSP + 0x18]
CMP RDI,RSI
JZ 0x0010153c
LAB_0010151f:
MOVSX EAX,byte ptr [RSI]
SUB EAX,0x30
MOV ECX,EAX
JZ 0x00101552
MOV EAX,R12D
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101552
ADD RSI,0x1
CMP RDI,RSI
JNZ 0x0010151f
LAB_0010153c:
MOV RSI,qword ptr [R14 + 0x8]
CMP RSI,qword ptr [R14 + 0x10]
JZ 0x00101842
MOV dword ptr [RSI],R12D
ADD qword ptr [R14 + 0x8],0x4
LAB_00101552:
MOV RDI,qword ptr [RSP + 0x10]
LEA RAX,[RSP + 0x20]
CMP RDI,RAX
JZ 0x0010156f
MOV RAX,qword ptr [RSP + 0x20]
LEA RSI,[RAX + 0x1]
CALL 0x00101140
LAB_0010156f:
ADD R12D,0x1
MOV dword ptr [RSP + 0xc],R12D
CMP R12D,R15D
JG 0x001012dd
LAB_00101581:
MOV R13D,R12D
SHR R13D,0x1f
MOV EBP,R12D
NEG EBP
CMOVS EBP,R12D
CMP EBP,0x9
JBE 0x0010188d
CMP EBP,0x63
JBE 0x00101309
CMP EBP,0x3e7
JBE 0x001015f9
CMP EBP,0x270f
JBE 0x00101838
MOV EAX,EBP
MOV EBX,0x1
MOV RCX,0x346dc5d63886594b
LAB_001015c8:
MOV EAX,EAX
MUL RCX
SHR RDX,0xb
MOV EAX,EDX
ADD EBX,0x4
CMP EDX,0x9
JBE 0x00101601
CMP EDX,0x63
JBE 0x0010130e
CMP EDX,0x3e7
JBE 0x001015fe
CMP EDX,0x270f
JA 0x001015c8
LAB_001015f4:
ADD EBX,0x3
JMP 0x00101601
LAB_001015f9:
MOV EBX,0x1
LAB_001015fe:
ADD EBX,0x2
LAB_00101601:
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA ESI,[R13 + RBX*0x1]
MOV EDX,0x2d
CALL 0x00101160
MOVZX R13D,R13B
ADD R13,qword ptr [RSP + 0x10]
MOV RAX,0x3330323031303030
MOV RDX,0x3730363035303430
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,0x3131303139303830
MOV RDX,0x3531343133313231
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,0x3931383137313631
MOV RDX,0x3332323231323032
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,0x3732363235323432
MOV RDX,0x3133303339323832
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,0x3533343333333233
MOV RDX,0x3933383337333633
MOV qword ptr [RSP + 0x70],RAX
MOV qword ptr [RSP + 0x78],RDX
MOV RAX,0x3334323431343034
MOV RDX,0x3734363435343434
MOV qword ptr [RSP + 0x80],RAX
MOV qword ptr [RSP + 0x88],RDX
MOV RAX,0x3135303539343834
MOV RDX,0x3535343533353235
MOV qword ptr [RSP + 0x90],RAX
MOV qword ptr [RSP + 0x98],RDX
MOV RAX,0x3935383537353635
MOV RDX,0x3336323631363036
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0xa8],RDX
MOV RAX,0x3736363635363436
MOV RDX,0x3137303739363836
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOV RAX,0x3537343733373237
MOV RDX,0x3937383737373637
MOV qword ptr [RSP + 0xc0],RAX
MOV qword ptr [RSP + 0xc8],RDX
MOV RAX,0x3338323831383038
MOV RDX,0x3738363835383438
MOV qword ptr [RSP + 0xd0],RAX
MOV qword ptr [RSP + 0xd8],RDX
MOV RAX,0x3139303939383838
MOV RDX,0x3539343933393239
MOV qword ptr [RSP + 0xe0],RAX
MOV qword ptr [RSP + 0xe8],RDX
MOV RAX,0x3935393439333932
MOV RDX,0x39393839373936
MOV qword ptr [RSP + 0xe9],RAX
MOV qword ptr [RSP + 0xf1],RDX
SUB EBX,0x1
LAB_001017e1:
MOV EDX,EBP
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x25
IMUL ECX,EDX,0x64
MOV EAX,EBP
SUB EAX,ECX
ADD EAX,EAX
MOV ECX,EBP
MOV EBP,EDX
MOV EDX,EBX
LEA ESI,[RAX + 0x1]
MOVZX ESI,byte ptr [RSP + RSI*0x1 + 0x30]
MOV byte ptr [R13 + RDX*0x1],SIL
LEA EDX,[RBX + -0x1]
MOV EAX,EAX
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x30]
MOV byte ptr [R13 + RDX*0x1],AL
SUB EBX,0x2
CMP ECX,0x270f
JA 0x001017e1
CMP ECX,0x3e7
JA 0x001014f4
LAB_00101830:
ADD EBP,0x30
JMP 0x00101509
LAB_00101838:
MOV EBX,0x1
JMP 0x001015f4
LAB_00101842:
LEA RDX,[RSP + 0xc]
MOV RDI,R14
LAB_0010184a:
CALL 0x00101d18
JMP 0x00101552
LAB_0010188d:
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA ESI,[R13 + 0x1]
MOV ESI,ESI
MOV EDX,0x2d
CALL 0x00101160
MOVZX R13D,R13B
ADD R13,qword ptr [RSP + 0x10]
JMP 0x00101830
LAB_001018ba:
CALL 0x00101150 | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint *puVar1;
byte bVar2;
int iVar3;
uint uVar4;
uint uVar5;
int in_EDX;
uint uVar6;
uint uVar7;
ulong uVar8;
uint uVar9;
char cVar10;
ulong uVar11;
long *plVar12;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
byte bVar13;
char *pcVar14;
long in_FS_OFFSET;
uint local_13c;
long *local_138;
long local_130;
long local_128 [2];
char local_118 [216];
long local_40;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
local_13c = param_2;
if (param_2 <= in_EDX) {
do {
uVar4 = local_13c;
iVar3 = (int)local_13c >> 0x1f;
uVar7 = -local_13c;
if (0 < (int)local_13c) {
uVar7 = local_13c;
}
uVar11 = (ulong)uVar7;
bVar2 = (byte)(local_13c >> 0x18);
bVar13 = bVar2 >> 7;
cVar10 = (char)-iVar3;
if (uVar7 < 10) {
local_138 = local_128;
std::string::_M_construct((ulong)&local_138,cVar10 + '\x01');
pcVar14 = (char *)((long)local_138 + (ulong)bVar13);
LAB_00101830:
cVar10 = (char)uVar7 + '0';
}
else {
if (uVar7 < 100) {
uVar9 = 1;
LAB_0010130e:
local_138 = local_128;
std::string::_M_construct((ulong)&local_138,((char)uVar9 + '\x01') - ((char)bVar2 >> 7));
pcVar14 = (char *)((long)local_138 + (ulong)(-iVar3 & 0xff));
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
if (99 < uVar7) goto LAB_001017e1;
}
else {
if (uVar7 < 1000) {
uVar9 = 1;
LAB_001015fe:
uVar9 = uVar9 + 2;
}
else {
if (uVar7 < 10000) {
uVar9 = 1;
}
else {
uVar9 = 1;
uVar8 = uVar11;
do {
uVar8 = uVar8 / 10000;
uVar6 = (uint)uVar8;
uVar9 = uVar9 + 4;
if (uVar6 < 10) goto LAB_00101601;
if (uVar6 < 100) goto LAB_0010130e;
if (uVar6 < 1000) goto LAB_001015fe;
} while (9999 < uVar6);
}
uVar9 = uVar9 + 3;
}
LAB_00101601:
local_138 = local_128;
std::string::_M_construct((ulong)&local_138,cVar10 + (char)uVar9);
pcVar14 = (char *)((long)local_138 + (ulong)bVar13);
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
uVar9 = uVar9 - 1;
LAB_001017e1:
do {
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
uVar7 = (uint)(uVar11 / 100);
uVar5 = (uint)uVar11;
uVar6 = (uVar5 + uVar7 * -100) * 2;
pcVar14[uVar9] = local_118[uVar6 + 1];
pcVar14[uVar9 - 1] = local_118[uVar6];
uVar9 = uVar9 - 2;
uVar11 = uVar11 / 100;
} while (9999 < uVar5);
if (uVar5 < 1000) goto LAB_00101830;
}
builtin_strncpy(local_118,
"00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899"
,0xc9);
pcVar14[1] = local_118[uVar7 * 2 + 1];
cVar10 = local_118[uVar7 * 2];
}
*pcVar14 = cVar10;
for (plVar12 = local_138; (long *)((long)local_138 + local_130) != plVar12;
plVar12 = (long *)((long)plVar12 + 1)) {
if ((*(char *)plVar12 + -0x30 == 0) || ((int)uVar4 % (*(char *)plVar12 + -0x30) != 0))
goto LAB_00101552;
}
puVar1 = *(uint **)(this + 8);
if (puVar1 == *(uint **)(this + 0x10)) {
/* try { // try from 0010184a to 0010184e has its CatchHandler @ 00101854 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)puVar1,(int *)&local_13c);
}
else {
*puVar1 = uVar4;
*(long *)(this + 8) = *(long *)(this + 8) + 4;
}
LAB_00101552:
if (local_138 != local_128) {
operator_delete(local_138,local_128[0] + 1);
}
local_13c = uVar4 + 1;
} while ((int)local_13c <= in_EDX);
}
if (local_40 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return this;
} |
2,978 | func0 |
#include <vector>
#include <string>
#include <assert.h>
| std::vector<int> func0(int startnum, int endnum) {
std::vector<int> result;
for (int n = startnum; n <= endnum; n++) {
bool divisible = true;
std::string s = std::to_string(n);
for (char c : s) {
int digit = c - '0';
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
}
if (divisible) {
result.push_back(n);
}
}
return result;
}
| int main() {
std::vector<int> vec1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
std::vector<int> vec2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
std::vector<int> vec3 = {22, 24};
assert(func0(1, 22) == vec1);
assert(func0(1, 15) == vec2);
assert(func0(20, 25) == vec3);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %esi,0xc(%rsp)
cmp %edx,%esi
jg 1688 <_Z5func0ii+0xd8>
mov %esi,%r8d
lea 0x10(%rsp),%r13
lea 0xc(%rsp),%r14
mov %edx,%ebx
mov 0x29cc(%rip),%rbp
nopl 0x0(%rax)
lea 0xa3c(%rip),%rcx
mov %rbp,%rsi
mov %r13,%rdi
xor %eax,%eax
mov $0x10,%edx
callq 1700 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPKS8_P13__va_list_tagEmSB_z>
mov 0x10(%rsp),%r9
mov 0x18(%rsp),%r8
add %r9,%r8
cmp %r9,%r8
je 16b0 <_Z5func0ii+0x100>
mov 0xc(%rsp),%edi
mov %r9,%rsi
jmp 165a <_Z5func0ii+0xaa>
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 1664 <_Z5func0ii+0xb4>
add $0x1,%rsi
cmp %rsi,%r8
je 16b0 <_Z5func0ii+0x100>
movsbl (%rsi),%eax
sub $0x30,%eax
mov %eax,%ecx
jne 1648 <_Z5func0ii+0x98>
lea 0x20(%rsp),%rax
cmp %rax,%r9
je 1676 <_Z5func0ii+0xc6>
mov %r9,%rdi
callq 1120 <_ZdlPv@plt>
mov 0xc(%rsp),%eax
lea 0x1(%rax),%r8d
mov %r8d,0xc(%rsp)
cmp %ebx,%r8d
jle 1610 <_Z5func0ii+0x60>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 16e0 <_Z5func0ii+0x130>
add $0x40,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
nopl 0x0(%rax,%rax,1)
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 16ce <_Z5func0ii+0x11e>
mov 0xc(%rsp),%eax
add $0x4,%rsi
mov %eax,-0x4(%rsi)
mov %rsi,0x8(%r12)
jmp 1664 <_Z5func0ii+0xb4>
mov %r14,%rdx
mov %r12,%rdi
callq 19c0 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x10(%rsp),%r9
jmp 1664 <_Z5func0ii+0xb4>
callq 1140 <__stack_chk_fail@plt>
endbr64
mov %rax,%rbp
jmpq 1194 <_Z5func0ii.cold+0x14>
endbr64
mov %rax,%rbp
jmpq 1180 <_Z5func0ii.cold>
nopl (%rax)
| _Z5func0ii:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 138h
mov [rsp+168h+var_14C], edx
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea rax, [rsp+168h+var_138]
mov qword ptr [rdi+10h], 0
mov [rsp+168h+var_13C], esi
mov [rsp+168h+var_158], rax
movups xmmword ptr [rdi], xmm0
cmp esi, edx
jg loc_1861
mov ebx, esi
lea r12, [rsp+168h+var_128]
nop dword ptr [rax+rax+00h]
loc_1610:
mov r15d, ebx
mov ecx, ebx
shr r15d, 1Fh
neg ecx
cmovs ecx, ebx
mov edx, r15d
movzx r15d, r15b
mov r13d, ecx
cmp ecx, 9
jbe loc_1A03
cmp ecx, 63h ; 'c'
jbe loc_18CD
cmp ecx, 3E7h
jbe loc_1A42
cmp ecx, 270Fh
jbe loc_1A24
mov eax, ecx
mov esi, 5
cmp ecx, 1869Fh
jbe loc_1895
cmp r13d, 0F423Fh
jbe loc_1A60
mov r14d, 6
mov esi, 7
cmp r13d, 98967Fh
jbe loc_1899
cmp r13d, 5F5E0FFh
jbe loc_19D0
cmp rax, 3B9AC9FFh
jbe loc_1890
mov r14d, 9
loc_16A9:
mov [rsp+168h+var_160], rax
lea esi, [r14+rdx+1]
mov [rsp+168h+var_138], r12
loc_16B8:
mov rdi, [rsp+168h+var_158]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movdqa xmm0, cs:xmmword_2110
movdqa xmm1, cs:xmmword_20D0
movdqa xmm2, cs:xmmword_20E0
movdqa xmm3, cs:xmmword_20F0
mov rax, [rsp+168h+var_160]
add r15, [rsp+168h+var_138]
movaps [rsp+168h+var_118], xmm1
movaps [rsp+168h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2120
movdqa xmm4, cs:xmmword_2100
movaps [rsp+168h+var_108], xmm2
movaps [rsp+168h+var_C8], xmm0
movdqa xmm0, cs:xmmword_2130
movaps [rsp+168h+var_F8], xmm3
movaps [rsp+168h+var_B8], xmm0
movdqa xmm0, cs:xmmword_2140
movaps [rsp+168h+var_E8], xmm4
movaps [rsp+168h+var_A8], xmm0
movdqa xmm0, cs:xmmword_2150
movaps [rsp+168h+var_98], xmm0
movdqa xmm0, cs:xmmword_2160
movaps [rsp+168h+var_88], xmm0
movdqa xmm0, cs:xmmword_2170
movaps [rsp+168h+var_78], xmm0
movdqa xmm0, cs:xmmword_2180
movaps [rsp+168h+var_68], xmm0
movdqa xmm0, cs:xmmword_2190
movups [rsp+168h+var_68+9], xmm0
jmp short loc_17A3
loc_17A0:
mov eax, r13d
loc_17A3:
imul rdx, rax, 51EB851Fh
mov eax, r13d
shr rdx, 25h
imul esi, edx, 64h ; 'd'
sub eax, esi
mov esi, r13d
mov r13d, edx
mov edx, r14d
add eax, eax
lea edi, [rax+1]
movzx eax, byte ptr [rsp+rax+168h+var_118]
movzx edi, byte ptr [rsp+rdi+168h+var_118]
mov [r15+rdx], dil
lea edx, [r14-1]
sub r14d, 2
mov [r15+rdx], al
cmp esi, 270Fh
ja short loc_17A0
cmp esi, 3E7h
ja loc_19B0
loc_17F2:
lea ecx, [r13+30h]
loc_17F6:
mov [r15], cl
mov r8, [rsp+168h+var_138]
mov rdi, [rsp+168h+var_130]
add rdi, r8
cmp rdi, r8
jz loc_18B0
mov rsi, r8
jmp short loc_182E
loc_1818:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_1838
add rsi, 1
cmp rdi, rsi
jz loc_18B0
loc_182E:
movsx eax, byte ptr [rsi]
sub eax, 30h ; '0'
mov ecx, eax
jnz short loc_1818
loc_1838:
cmp r8, r12
jz short loc_184E
mov rax, [rsp+168h+var_128]
mov rdi, r8; void *
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_184E:
mov eax, [rsp+168h+var_14C]
add ebx, 1
mov [rsp+168h+var_13C], ebx
cmp ebx, eax
jle loc_1610
loc_1861:
mov rax, [rsp+168h+var_40]
sub rax, fs:28h
jnz loc_1A6B
add rsp, 138h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1890:
mov esi, 9
loc_1895:
lea r14d, [rsi-1]
loc_1899:
mov [rsp+168h+var_160], rax
add esi, edx
mov [rsp+168h+var_138], r12
jmp loc_16B8
loc_18B0:
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz loc_19EC
mov [rsi], ebx
add rsi, 4
mov [rbp+8], rsi
jmp loc_1838
loc_18CD:
mov rdi, [rsp+168h+var_158]
lea esi, [rdx+2]
mov edx, 2Dh ; '-'
mov [rsp+168h+var_138], r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movdqa xmm0, cs:xmmword_20D0
add r15, [rsp+168h+var_138]
movaps [rsp+168h+var_118], xmm0
movdqa xmm0, cs:xmmword_20E0
movaps [rsp+168h+var_108], xmm0
movdqa xmm0, cs:xmmword_20F0
movaps [rsp+168h+var_F8], xmm0
movdqa xmm0, cs:xmmword_2100
movaps [rsp+168h+var_E8], xmm0
movdqa xmm0, cs:xmmword_2110
movaps [rsp+168h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2120
movaps [rsp+168h+var_C8], xmm0
movdqa xmm0, cs:xmmword_2130
movaps [rsp+168h+var_B8], xmm0
movdqa xmm0, cs:xmmword_2140
movaps [rsp+168h+var_A8], xmm0
movdqa xmm0, cs:xmmword_2150
movaps [rsp+168h+var_98], xmm0
movdqa xmm0, cs:xmmword_2160
movaps [rsp+168h+var_88], xmm0
movdqa xmm0, cs:xmmword_2170
movaps [rsp+168h+var_78], xmm0
movdqa xmm0, cs:xmmword_2180
movaps [rsp+168h+var_68], xmm0
movdqa xmm0, cs:xmmword_2190
movups [rsp+168h+var_68+9], xmm0
loc_19B0:
lea ecx, [r13+r13+0]
lea eax, [rcx+1]
movzx ecx, byte ptr [rsp+rcx+168h+var_118]
movzx eax, byte ptr [rsp+rax+168h+var_118]
mov [r15+1], al
jmp loc_17F6
loc_19D0:
mov esi, 8
mov [rsp+168h+var_160], rax
mov r14d, 7
mov [rsp+168h+var_138], r12
add esi, edx
jmp loc_16B8
loc_19EC:
lea rdx, [rsp+168h+var_13C]
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&)
mov r8, [rsp+168h+var_138]
jmp loc_1838
loc_1A03:
mov rdi, [rsp+168h+var_158]
lea esi, [rdx+1]
mov edx, 2Dh ; '-'
mov [rsp+168h+var_138], r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [rsp+168h+var_138]
jmp loc_17F2
loc_1A24:
mov esi, 4
mov eax, ecx
mov [rsp+168h+var_138], r12
mov r14d, 3
mov [rsp+168h+var_160], rax
add esi, edx
jmp loc_16B8
loc_1A42:
mov esi, 3
mov eax, ecx
mov [rsp+168h+var_138], r12
mov r14d, 2
mov [rsp+168h+var_160], rax
add esi, edx
jmp loc_16B8
loc_1A60:
mov r14d, 5
jmp loc_16A9
loc_1A6B:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0ii_cold; func0(int,int) [clone] | long long func0(long long a1, int a2, int a3)
{
int v4; // ebx
unsigned int v5; // r15d
unsigned int v6; // ecx
unsigned int v7; // r13d
int v8; // esi
unsigned int v9; // r14d
long long v10; // rsi
long long v11; // rax
__int8 *v12; // r15
unsigned long long v13; // rdx
unsigned int v14; // eax
unsigned int v15; // esi
long long v16; // rax
long long v17; // rdi
long long v18; // rdx
__int8 v19; // cl
_QWORD *v20; // r8
_BYTE *v21; // rsi
int *v23; // rsi
long long v24; // [rsp+0h] [rbp-160h]
int v26; // [rsp+24h] [rbp-13Ch] BYREF
void *v27; // [rsp+28h] [rbp-138h] BYREF
long long v28; // [rsp+30h] [rbp-130h]
_QWORD v29[2]; // [rsp+38h] [rbp-128h] BYREF
__m128i si128; // [rsp+48h] [rbp-118h]
__m128i v31; // [rsp+58h] [rbp-108h]
__m128i v32; // [rsp+68h] [rbp-F8h]
__m128i v33; // [rsp+78h] [rbp-E8h]
__m128i v34; // [rsp+88h] [rbp-D8h]
__m128i v35; // [rsp+98h] [rbp-C8h]
__m128i v36; // [rsp+A8h] [rbp-B8h]
__m128i v37; // [rsp+B8h] [rbp-A8h]
__m128i v38; // [rsp+C8h] [rbp-98h]
__m128i v39; // [rsp+D8h] [rbp-88h]
__m128i v40; // [rsp+E8h] [rbp-78h]
__m128i v41[2]; // [rsp+F8h] [rbp-68h]
unsigned long long v42; // [rsp+120h] [rbp-40h]
v42 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
v26 = a2;
*(_OWORD *)a1 = 0LL;
if ( a2 <= a3 )
{
v4 = a2;
do
{
v5 = (unsigned int)v4 >> 31;
v6 = -v4;
if ( v4 > 0 )
v6 = v4;
v7 = v6;
if ( v6 <= 9 )
{
v27 = v29;
std::string::_M_construct(&v27, v5 + 1, 45LL);
v12 = (char *)v27 + (v4 < 0);
goto LABEL_20;
}
if ( v6 <= 0x63 )
{
v27 = v29;
std::string::_M_construct(&v27, v5 + 2, 45LL);
v12 = (char *)v27 + (v4 < 0);
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v31 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v32 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v33 = _mm_load_si128((const __m128i *)&xmmword_2100);
v34 = _mm_load_si128((const __m128i *)&xmmword_2110);
v35 = _mm_load_si128((const __m128i *)&xmmword_2120);
v36 = _mm_load_si128((const __m128i *)&xmmword_2130);
v37 = _mm_load_si128((const __m128i *)&xmmword_2140);
v38 = _mm_load_si128((const __m128i *)&xmmword_2150);
v39 = _mm_load_si128((const __m128i *)&xmmword_2160);
v40 = _mm_load_si128((const __m128i *)&xmmword_2170);
v41[0] = _mm_load_si128((const __m128i *)&xmmword_2180);
*(__m128i *)((char *)v41 + 9) = _mm_load_si128((const __m128i *)&xmmword_2190);
LABEL_36:
v19 = si128.m128i_i8[2 * v7];
v12[1] = si128.m128i_i8[2 * v7 + 1];
goto LABEL_21;
}
if ( v6 <= 0x3E7 )
{
v27 = v29;
v9 = 2;
v24 = v6;
v10 = v5 + 3;
goto LABEL_16;
}
if ( v6 <= 0x270F )
{
v27 = v29;
v9 = 3;
v24 = v6;
v10 = v5 + 4;
goto LABEL_16;
}
v8 = 5;
if ( v6 <= 0x1869F )
goto LABEL_31;
if ( v6 <= 0xF423F )
{
v9 = 5;
}
else
{
v9 = 6;
v8 = 7;
if ( v6 <= 0x98967F )
goto LABEL_32;
if ( v6 <= 0x5F5E0FF )
{
v24 = v6;
v9 = 7;
v27 = v29;
v10 = v5 + 8;
goto LABEL_16;
}
if ( v6 <= 0x3B9AC9FFuLL )
{
v8 = 9;
LABEL_31:
v9 = v8 - 1;
LABEL_32:
v24 = v6;
v10 = v5 + v8;
v27 = v29;
goto LABEL_16;
}
v9 = 9;
}
v24 = v6;
v10 = v9 + v5 + 1;
v27 = v29;
LABEL_16:
std::string::_M_construct(&v27, v10, 45LL);
v11 = v24;
v12 = (char *)v27 + (v4 < 0);
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v34 = _mm_load_si128((const __m128i *)&xmmword_2110);
v31 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v35 = _mm_load_si128((const __m128i *)&xmmword_2120);
v32 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v36 = _mm_load_si128((const __m128i *)&xmmword_2130);
v33 = _mm_load_si128((const __m128i *)&xmmword_2100);
v37 = _mm_load_si128((const __m128i *)&xmmword_2140);
v38 = _mm_load_si128((const __m128i *)&xmmword_2150);
v39 = _mm_load_si128((const __m128i *)&xmmword_2160);
v40 = _mm_load_si128((const __m128i *)&xmmword_2170);
v41[0] = _mm_load_si128((const __m128i *)&xmmword_2180);
*(__m128i *)((char *)v41 + 9) = _mm_load_si128((const __m128i *)&xmmword_2190);
while ( 1 )
{
v13 = (unsigned long long)(1374389535 * v11) >> 37;
v14 = v7 - 100 * ((unsigned int)v11 / 0x64);
v15 = v7;
v7 = v13;
v16 = 2 * v14;
v17 = (unsigned int)(v16 + 1);
LOBYTE(v16) = si128.m128i_i8[v16];
v12[v9] = si128.m128i_i8[v17];
v18 = v9 - 1;
v9 -= 2;
v12[v18] = v16;
if ( v15 <= 0x270F )
break;
v11 = v7;
}
if ( v15 > 0x3E7 )
goto LABEL_36;
LABEL_20:
v19 = v7 + 48;
LABEL_21:
*v12 = v19;
v20 = v27;
if ( (char *)v27 + v28 == v27 )
{
LABEL_33:
v23 = *(int **)(a1 + 8);
if ( v23 == *(int **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v23, &v26);
v20 = v27;
}
else
{
*v23 = v4;
*(_QWORD *)(a1 + 8) = v23 + 1;
}
}
else
{
v21 = v27;
while ( *v21 != 48 && !(v4 % ((char)*v21 - 48)) )
{
if ( (char *)v27 + v28 == ++v21 )
goto LABEL_33;
}
}
if ( v20 != v29 )
operator delete(v20, v29[0] + 1LL);
v26 = ++v4;
}
while ( v4 <= a3 );
}
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x138
MOV dword ptr [RSP + 0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x2c],ESI
MOV qword ptr [RSP + 0x10],RAX
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,EDX
JG 0x00101861
MOV EBX,ESI
LEA R12,[RSP + 0x40]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101610:
MOV R15D,EBX
MOV ECX,EBX
SHR R15D,0x1f
NEG ECX
CMOVS ECX,EBX
MOV EDX,R15D
MOVZX R15D,R15B
MOV R13D,ECX
CMP ECX,0x9
JBE 0x00101a03
CMP ECX,0x63
JBE 0x001018cd
CMP ECX,0x3e7
JBE 0x00101a42
CMP ECX,0x270f
JBE 0x00101a24
MOV EAX,ECX
MOV ESI,0x5
CMP ECX,0x1869f
JBE 0x00101895
CMP R13D,0xf423f
JBE 0x00101a60
MOV R14D,0x6
MOV ESI,0x7
CMP R13D,0x98967f
JBE 0x00101899
CMP R13D,0x5f5e0ff
JBE 0x001019d0
CMP RAX,0x3b9ac9ff
JBE 0x00101890
MOV R14D,0x9
LAB_001016a9:
MOV qword ptr [RSP + 0x8],RAX
LEA ESI,[R14 + RDX*0x1 + 0x1]
MOV qword ptr [RSP + 0x30],R12
LAB_001016b8:
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,0x2d
CALL 0x00101160
MOVDQA XMM0,xmmword ptr [0x00102110]
MOVDQA XMM1,xmmword ptr [0x001020d0]
MOVDQA XMM2,xmmword ptr [0x001020e0]
MOVDQA XMM3,xmmword ptr [0x001020f0]
MOV RAX,qword ptr [RSP + 0x8]
ADD R15,qword ptr [RSP + 0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x00102120]
MOVDQA XMM4,xmmword ptr [0x00102100]
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102130]
MOVAPS xmmword ptr [RSP + 0x70],XMM3
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102140]
MOVAPS xmmword ptr [RSP + 0x80],XMM4
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102150]
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102160]
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102170]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102180]
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVDQA XMM0,xmmword ptr [0x00102190]
MOVUPS xmmword ptr [RSP + 0x109],XMM0
JMP 0x001017a3
LAB_001017a0:
MOV EAX,R13D
LAB_001017a3:
IMUL RDX,RAX,0x51eb851f
MOV EAX,R13D
SHR RDX,0x25
IMUL ESI,EDX,0x64
SUB EAX,ESI
MOV ESI,R13D
MOV R13D,EDX
MOV EDX,R14D
ADD EAX,EAX
LEA EDI,[RAX + 0x1]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x50]
MOVZX EDI,byte ptr [RSP + RDI*0x1 + 0x50]
MOV byte ptr [R15 + RDX*0x1],DIL
LEA EDX,[R14 + -0x1]
SUB R14D,0x2
MOV byte ptr [R15 + RDX*0x1],AL
CMP ESI,0x270f
JA 0x001017a0
CMP ESI,0x3e7
JA 0x001019b0
LAB_001017f2:
LEA ECX,[R13 + 0x30]
LAB_001017f6:
MOV byte ptr [R15],CL
MOV R8,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,R8
CMP RDI,R8
JZ 0x001018b0
MOV RSI,R8
JMP 0x0010182e
LAB_00101818:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101838
ADD RSI,0x1
CMP RDI,RSI
JZ 0x001018b0
LAB_0010182e:
MOVSX EAX,byte ptr [RSI]
SUB EAX,0x30
MOV ECX,EAX
JNZ 0x00101818
LAB_00101838:
CMP R8,R12
JZ 0x0010184e
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,R8
LEA RSI,[RAX + 0x1]
CALL 0x00101140
LAB_0010184e:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EBX,0x1
MOV dword ptr [RSP + 0x2c],EBX
CMP EBX,EAX
JLE 0x00101610
LAB_00101861:
MOV RAX,qword ptr [RSP + 0x128]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101a6b
ADD RSP,0x138
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101890:
MOV ESI,0x9
LAB_00101895:
LEA R14D,[RSI + -0x1]
LAB_00101899:
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
MOV qword ptr [RSP + 0x30],R12
JMP 0x001016b8
LAB_001018b0:
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x001019ec
MOV dword ptr [RSI],EBX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
JMP 0x00101838
LAB_001018cd:
MOV RDI,qword ptr [RSP + 0x10]
LEA ESI,[RDX + 0x2]
MOV EDX,0x2d
MOV qword ptr [RSP + 0x30],R12
CALL 0x00101160
MOVDQA XMM0,xmmword ptr [0x001020d0]
ADD R15,qword ptr [RSP + 0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVDQA XMM0,xmmword ptr [0x001020e0]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVDQA XMM0,xmmword ptr [0x001020f0]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVDQA XMM0,xmmword ptr [0x00102100]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVDQA XMM0,xmmword ptr [0x00102110]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x00102120]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102130]
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102140]
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102150]
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102160]
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102170]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102180]
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVDQA XMM0,xmmword ptr [0x00102190]
MOVUPS xmmword ptr [RSP + 0x109],XMM0
LAB_001019b0:
LEA ECX,[R13 + R13*0x1]
LEA EAX,[RCX + 0x1]
MOVZX ECX,byte ptr [RSP + RCX*0x1 + 0x50]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x50]
MOV byte ptr [R15 + 0x1],AL
JMP 0x001017f6
LAB_001019d0:
MOV ESI,0x8
MOV qword ptr [RSP + 0x8],RAX
MOV R14D,0x7
MOV qword ptr [RSP + 0x30],R12
ADD ESI,EDX
JMP 0x001016b8
LAB_001019ec:
LEA RDX,[RSP + 0x2c]
MOV RDI,RBP
LAB_001019f4:
CALL 0x00101b90
MOV R8,qword ptr [RSP + 0x30]
JMP 0x00101838
LAB_00101a03:
MOV RDI,qword ptr [RSP + 0x10]
LEA ESI,[RDX + 0x1]
MOV EDX,0x2d
MOV qword ptr [RSP + 0x30],R12
CALL 0x00101160
ADD R15,qword ptr [RSP + 0x30]
JMP 0x001017f2
LAB_00101a24:
MOV ESI,0x4
MOV EAX,ECX
MOV qword ptr [RSP + 0x30],R12
MOV R14D,0x3
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
JMP 0x001016b8
LAB_00101a42:
MOV ESI,0x3
MOV EAX,ECX
MOV qword ptr [RSP + 0x30],R12
MOV R14D,0x2
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
JMP 0x001016b8
LAB_00101a60:
MOV R14D,0x5
JMP 0x001016a9
LAB_00101a6b:
CALL 0x00101150 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint uVar1;
uint *puVar2;
uint uVar3;
int in_EDX;
uint uVar4;
uint uVar5;
ulong uVar6;
char cVar7;
int iVar8;
long *plVar9;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
uint uVar10;
char *pcVar11;
long in_FS_OFFSET;
uint local_13c;
long *local_138;
long local_130;
long local_128 [2];
int8 local_118;
int8 uStack_110;
int8 local_108;
int8 uStack_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int uStack_60;
int7 uStack_5f;
char cStack_58;
char acStack_57 [23];
long local_40;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(this + 0x10) = 0;
*(int (*) [16])this = (int [16])0x0;
local_13c = param_2;
if (param_2 <= in_EDX) {
uVar6 = (ulong)(uint)param_2;
do {
uVar5 = (uint)uVar6;
uVar6 = uVar6 >> 0x1f;
uVar4 = -uVar5;
if (0 < (int)uVar5) {
uVar4 = uVar5;
}
cVar7 = (char)uVar6;
local_138 = local_128;
if (uVar4 < 10) {
std::string::_M_construct((ulong)&local_138,cVar7 + '\x01');
pcVar11 = (char *)((long)local_138 + uVar6);
LAB_001017f2:
cVar7 = (char)uVar4 + '0';
}
else {
if (uVar4 < 100) {
std::string::_M_construct((ulong)&local_138,cVar7 + '\x02');
pcVar11 = (char *)((long)local_138 + uVar6);
local_118 = _DAT_001020d0;
uStack_110 = _UNK_001020d8;
local_108 = _DAT_001020e0;
uStack_100 = _UNK_001020e8;
local_f8 = _DAT_001020f0;
uStack_f0 = _UNK_001020f8;
local_e8 = _DAT_00102100;
uStack_e0 = _UNK_00102108;
local_d8 = _DAT_00102110;
uStack_d0 = _UNK_00102118;
local_c8 = _DAT_00102120;
uStack_c0 = _UNK_00102128;
local_b8 = _DAT_00102130;
uStack_b0 = _UNK_00102138;
local_a8 = _DAT_00102140;
uStack_a0 = _UNK_00102148;
local_98 = _DAT_00102150;
uStack_90 = _UNK_00102158;
local_88 = _DAT_00102160;
uStack_80 = _UNK_00102168;
local_78 = _DAT_00102170;
uStack_70 = _UNK_00102178;
local_68 = _DAT_00102180;
uStack_60 = (int)_UNK_00102188;
uStack_5f = (int7)s_293949596979899_00102190._0_8_;
cStack_58 = SUB81(s_293949596979899_00102190._0_8_,7);
acStack_57[0] = s_293949596979899_00102190[8];
acStack_57[1] = s_293949596979899_00102190[9];
acStack_57[2] = s_293949596979899_00102190[10];
acStack_57[3] = s_293949596979899_00102190[0xb];
acStack_57[4] = s_293949596979899_00102190[0xc];
acStack_57[5] = s_293949596979899_00102190[0xd];
acStack_57[6] = s_293949596979899_00102190[0xe];
acStack_57[7] = s_293949596979899_00102190[0xf];
}
else {
if (uVar4 < 1000) {
uVar10 = 2;
cVar7 = cVar7 + '\x03';
}
else if (uVar4 < 10000) {
uVar10 = 3;
cVar7 = cVar7 + '\x04';
}
else {
iVar8 = 5;
if (uVar4 < 100000) {
LAB_00101895:
uVar10 = iVar8 - 1;
LAB_00101899:
cVar7 = (char)iVar8 + cVar7;
}
else {
if (uVar4 < 1000000) {
uVar10 = 5;
}
else {
uVar10 = 6;
iVar8 = 7;
if (uVar4 < 10000000) goto LAB_00101899;
if (uVar4 < 100000000) {
uVar10 = 7;
cVar7 = cVar7 + '\b';
goto LAB_001016b8;
}
if (uVar4 < 1000000000) {
iVar8 = 9;
goto LAB_00101895;
}
uVar10 = 9;
}
cVar7 = (char)uVar10 + '\x01' + cVar7;
}
}
LAB_001016b8:
std::string::_M_construct((ulong)&local_138,cVar7);
pcVar11 = (char *)((long)local_138 + uVar6);
local_118 = _DAT_001020d0;
uStack_110 = _UNK_001020d8;
local_d8 = _DAT_00102110;
uStack_d0 = _UNK_00102118;
local_108 = _DAT_001020e0;
uStack_100 = _UNK_001020e8;
local_c8 = _DAT_00102120;
uStack_c0 = _UNK_00102128;
local_f8 = _DAT_001020f0;
uStack_f0 = _UNK_001020f8;
local_b8 = _DAT_00102130;
uStack_b0 = _UNK_00102138;
local_e8 = _DAT_00102100;
uStack_e0 = _UNK_00102108;
local_a8 = _DAT_00102140;
uStack_a0 = _UNK_00102148;
local_98 = _DAT_00102150;
uStack_90 = _UNK_00102158;
local_88 = _DAT_00102160;
uStack_80 = _UNK_00102168;
local_78 = _DAT_00102170;
uStack_70 = _UNK_00102178;
local_68 = _DAT_00102180;
uStack_60 = (int)_UNK_00102188;
uStack_5f = (int7)s_293949596979899_00102190._0_8_;
cStack_58 = SUB81(s_293949596979899_00102190._0_8_,7);
acStack_57[0] = s_293949596979899_00102190[8];
acStack_57[1] = s_293949596979899_00102190[9];
acStack_57[2] = s_293949596979899_00102190[10];
acStack_57[3] = s_293949596979899_00102190[0xb];
acStack_57[4] = s_293949596979899_00102190[0xc];
acStack_57[5] = s_293949596979899_00102190[0xd];
acStack_57[6] = s_293949596979899_00102190[0xe];
acStack_57[7] = s_293949596979899_00102190[0xf];
do {
uVar3 = uVar4;
uVar4 = uVar3 / 100;
uVar1 = (uVar3 % 100) * 2;
cVar7 = *(char *)((long)&local_118 + (ulong)uVar1);
pcVar11[uVar10] = *(char *)((long)&local_118 + (ulong)(uVar1 + 1));
uVar1 = uVar10 - 1;
uVar10 = uVar10 - 2;
pcVar11[uVar1] = cVar7;
} while (9999 < uVar3);
if (uVar3 < 1000) goto LAB_001017f2;
}
cVar7 = *(char *)((long)&local_118 + (ulong)(uVar4 * 2));
pcVar11[1] = *(char *)((long)&local_118 + (ulong)(uVar4 * 2 + 1));
}
*pcVar11 = cVar7;
for (plVar9 = local_138; (long *)((long)local_138 + local_130) != plVar9;
plVar9 = (long *)((long)plVar9 + 1)) {
if ((*(char *)plVar9 + -0x30 == 0) || ((int)uVar5 % (*(char *)plVar9 + -0x30) != 0))
goto LAB_00101838;
}
puVar2 = *(uint **)(this + 8);
if (puVar2 == *(uint **)(this + 0x10)) {
/* try { // try from 001019f4 to 001019f8 has its CatchHandler @ 00101a70 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)puVar2,(int *)&local_13c);
}
else {
*puVar2 = uVar5;
*(uint **)(this + 8) = puVar2 + 1;
}
LAB_00101838:
if (local_138 != local_128) {
operator_delete(local_138,local_128[0] + 1);
}
local_13c = uVar5 + 1;
uVar6 = (ulong)local_13c;
} while ((int)local_13c <= in_EDX);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return this;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,979 | func0 |
#include <vector>
#include <string>
#include <assert.h>
| std::vector<int> func0(int startnum, int endnum) {
std::vector<int> result;
for (int n = startnum; n <= endnum; n++) {
bool divisible = true;
std::string s = std::to_string(n);
for (char c : s) {
int digit = c - '0';
if (digit == 0 || n % digit != 0) {
divisible = false;
break;
}
}
if (divisible) {
result.push_back(n);
}
}
return result;
}
| int main() {
std::vector<int> vec1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22};
std::vector<int> vec2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15};
std::vector<int> vec3 = {22, 24};
assert(func0(1, 22) == vec1);
assert(func0(1, 15) == vec2);
assert(func0(20, 25) == vec3);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x48,%rsp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
mov %esi,0xc(%rsp)
movups %xmm0,(%rdi)
cmp %edx,%esi
jg 17f3 <_Z5func0ii+0xd3>
mov %esi,%r8d
lea 0x10(%rsp),%r14
lea 0x20(%rsp),%rbp
mov %edx,%ebx
mov 0x2862(%rip),%r13
lea 0xc(%rsp),%r15
nopl 0x0(%rax,%rax,1)
lea 0x87d(%rip),%rcx
mov %r13,%rsi
mov %r14,%rdi
xor %eax,%eax
mov $0x10,%edx
callq 1560 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcEET_PFiPT0_mPKS8_P13__va_list_tagEmSB_z.constprop.0>
mov 0x10(%rsp),%r9
mov 0x18(%rsp),%r8
add %r9,%r8
cmp %r9,%r8
je 1818 <_Z5func0ii+0xf8>
mov 0xc(%rsp),%edi
mov %r9,%rsi
jmp 17ca <_Z5func0ii+0xaa>
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
jne 17d4 <_Z5func0ii+0xb4>
add $0x1,%rsi
cmp %rsi,%r8
je 1818 <_Z5func0ii+0xf8>
movsbl (%rsi),%eax
sub $0x30,%eax
mov %eax,%ecx
jne 17b8 <_Z5func0ii+0x98>
cmp %rbp,%r9
je 17e1 <_Z5func0ii+0xc1>
mov %r9,%rdi
callq 1130 <_ZdlPv@plt>
mov 0xc(%rsp),%eax
lea 0x1(%rax),%r8d
mov %r8d,0xc(%rsp)
cmp %ebx,%r8d
jle 1780 <_Z5func0ii+0x60>
mov 0x38(%rsp),%rax
xor %fs:0x28,%rax
jne 1848 <_Z5func0ii+0x128>
add $0x48,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl (%rax)
mov 0x8(%r12),%rsi
cmp 0x10(%r12),%rsi
je 1836 <_Z5func0ii+0x116>
mov 0xc(%rsp),%eax
add $0x4,%rsi
mov %eax,-0x4(%rsi)
mov %rsi,0x8(%r12)
jmp 17d4 <_Z5func0ii+0xb4>
mov %r15,%rdx
mov %r12,%rdi
callq 1960 <_ZNSt6vectorIiSaIiEE17_M_realloc_insertIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_>
mov 0x10(%rsp),%r9
jmp 17d4 <_Z5func0ii+0xb4>
callq 1150 <__stack_chk_fail@plt>
endbr64
mov %rax,%r13
jmpq 1180 <_Z5func0ii.cold>
nopl 0x0(%rax)
| _Z5func0ii:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
sub rsp, 138h
mov [rsp+168h+var_14C], edx
lea r12, [rsp+168h+var_128]
mov rax, fs:28h
mov [rsp+168h+var_40], rax
xor eax, eax
lea rax, [rsp+168h+var_138]
mov qword ptr [rdi+10h], 0
mov [rsp+168h+var_13C], esi
mov [rsp+168h+var_158], rax
movups xmmword ptr [rdi], xmm0
cmp esi, edx
jg loc_1863
nop dword ptr [rax+rax+00h]
loc_1610:
mov r15d, ebx
mov ecx, ebx
shr r15d, 1Fh
neg ecx
cmovs ecx, ebx
mov edx, r15d
movzx r15d, r15b
mov r13d, ecx
cmp ecx, 9
jbe loc_1A23
cmp ecx, 63h ; 'c'
jbe loc_18E9
cmp ecx, 3E7h
jbe loc_1A62
cmp ecx, 270Fh
jbe loc_1A44
mov eax, ecx
mov esi, 5
cmp ecx, 1869Fh
jbe loc_1895
cmp r13d, 0F423Fh
jbe loc_1A80
mov r14d, 6
mov esi, 7
cmp r13d, 98967Fh
jbe loc_1899
cmp r13d, 5F5E0FFh
jbe loc_19F0
cmp rax, 3B9AC9FFh
jbe loc_1890
mov r14d, 9
loc_16A9:
mov [rsp+168h+var_160], rax
lea esi, [r14+rdx+1]
mov [rsp+168h+var_138], r12
loc_16B8:
mov rdi, [rsp+168h+var_158]
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movdqa xmm0, cs:xmmword_2110
movdqa xmm1, cs:xmmword_20D0
movdqa xmm2, cs:xmmword_20E0
movdqa xmm3, cs:xmmword_20F0
mov rax, [rsp+168h+var_160]
add r15, [rsp+168h+var_138]
movaps [rsp+168h+var_118], xmm1
movaps [rsp+168h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2120
movdqa xmm4, cs:xmmword_2100
movaps [rsp+168h+var_108], xmm2
movaps [rsp+168h+var_C8], xmm0
movdqa xmm0, cs:xmmword_2130
movaps [rsp+168h+var_F8], xmm3
movaps [rsp+168h+var_B8], xmm0
movdqa xmm0, cs:xmmword_2140
movaps [rsp+168h+var_E8], xmm4
movaps [rsp+168h+var_A8], xmm0
movdqa xmm0, cs:xmmword_2150
movaps [rsp+168h+var_98], xmm0
movdqa xmm0, cs:xmmword_2160
movaps [rsp+168h+var_88], xmm0
movdqa xmm0, cs:xmmword_2170
movaps [rsp+168h+var_78], xmm0
movdqa xmm0, cs:xmmword_2180
movaps [rsp+168h+var_68], xmm0
movdqa xmm0, cs:xmmword_2190
movups [rsp+168h+var_68+9], xmm0
jmp short loc_17A3
loc_17A0:
mov eax, r13d
loc_17A3:
imul rdx, rax, 51EB851Fh
mov eax, r13d
shr rdx, 25h
imul esi, edx, 64h ; 'd'
sub eax, esi
mov esi, r13d
mov r13d, edx
mov edx, r14d
add eax, eax
lea edi, [rax+1]
movzx eax, byte ptr [rsp+rax+168h+var_118]
movzx edi, byte ptr [rsp+rdi+168h+var_118]
mov [r15+rdx], dil
lea edx, [r14-1]
sub r14d, 2
mov [r15+rdx], al
cmp esi, 270Fh
ja short loc_17A0
cmp esi, 3E7h
ja loc_19D0
loc_17F2:
lea ecx, [r13+30h]
loc_17F6:
mov [r15], cl
mov r8, [rsp+168h+var_138]
mov rdi, [rsp+168h+var_130]
add rdi, r8
cmp rdi, r8
jz loc_18B0
mov rsi, r8
jmp short loc_182E
loc_1818:
mov eax, ebx
cdq
idiv ecx
test edx, edx
jnz short loc_1838
add rsi, 1
cmp rdi, rsi
jz loc_18B0
loc_182E:
movsx eax, byte ptr [rsi]
sub eax, 30h ; '0'
mov ecx, eax
jnz short loc_1818
loc_1838:
cmp r8, r12
jz loc_18D1
loc_1841:
mov rax, [rsp+168h+var_128]
mov rdi, r8; void *
add ebx, 1
lea rsi, [rax+1]; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov [rsp+168h+var_13C], ebx
cmp [rsp+168h+var_14C], ebx
jge loc_1610
loc_1863:
mov rax, [rsp+168h+var_40]
sub rax, fs:28h
jnz loc_1A8B
add rsp, 138h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1890:
mov esi, 9
loc_1895:
lea r14d, [rsi-1]
loc_1899:
mov [rsp+168h+var_160], rax
add esi, edx
mov [rsp+168h+var_138], r12
jmp loc_16B8
loc_18B0:
mov rsi, [rbp+8]
cmp rsi, [rbp+10h]
jz loc_1A0C
mov [rsi], ebx
add rsi, 4
mov [rbp+8], rsi
cmp r8, r12
jnz loc_1841
loc_18D1:
mov eax, [rsp+168h+var_14C]
add ebx, 1
mov [rsp+168h+var_13C], ebx
cmp ebx, eax
jle loc_1610
jmp loc_1863
loc_18E9:
mov rdi, [rsp+168h+var_158]
lea esi, [rdx+2]
mov edx, 2Dh ; '-'
mov [rsp+168h+var_138], r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
movdqa xmm0, cs:xmmword_20D0
add r15, [rsp+168h+var_138]
movaps [rsp+168h+var_118], xmm0
movdqa xmm0, cs:xmmword_20E0
movaps [rsp+168h+var_108], xmm0
movdqa xmm0, cs:xmmword_20F0
movaps [rsp+168h+var_F8], xmm0
movdqa xmm0, cs:xmmword_2100
movaps [rsp+168h+var_E8], xmm0
movdqa xmm0, cs:xmmword_2110
movaps [rsp+168h+var_D8], xmm0
movdqa xmm0, cs:xmmword_2120
movaps [rsp+168h+var_C8], xmm0
movdqa xmm0, cs:xmmword_2130
movaps [rsp+168h+var_B8], xmm0
movdqa xmm0, cs:xmmword_2140
movaps [rsp+168h+var_A8], xmm0
movdqa xmm0, cs:xmmword_2150
movaps [rsp+168h+var_98], xmm0
movdqa xmm0, cs:xmmword_2160
movaps [rsp+168h+var_88], xmm0
movdqa xmm0, cs:xmmword_2170
movaps [rsp+168h+var_78], xmm0
movdqa xmm0, cs:xmmword_2180
movaps [rsp+168h+var_68], xmm0
movdqa xmm0, cs:xmmword_2190
movups [rsp+168h+var_68+9], xmm0
nop dword ptr [rax+00h]
loc_19D0:
lea ecx, [r13+r13+0]
lea eax, [rcx+1]
movzx ecx, byte ptr [rsp+rcx+168h+var_118]
movzx eax, byte ptr [rsp+rax+168h+var_118]
mov [r15+1], al
jmp loc_17F6
loc_19F0:
mov esi, 8
mov [rsp+168h+var_160], rax
mov r14d, 7
mov [rsp+168h+var_138], r12
add esi, edx
jmp loc_16B8
loc_1A0C:
lea rdx, [rsp+168h+var_13C]
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&)
mov r8, [rsp+168h+var_138]
jmp loc_1838
loc_1A23:
mov rdi, [rsp+168h+var_158]
lea esi, [rdx+1]
mov edx, 2Dh ; '-'
mov [rsp+168h+var_138], r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [rsp+168h+var_138]
jmp loc_17F2
loc_1A44:
mov esi, 4
mov eax, ecx
mov [rsp+168h+var_138], r12
mov r14d, 3
mov [rsp+168h+var_160], rax
add esi, edx
jmp loc_16B8
loc_1A62:
mov esi, 3
mov eax, ecx
mov [rsp+168h+var_138], r12
mov r14d, 2
mov [rsp+168h+var_160], rax
add esi, edx
jmp loc_16B8
loc_1A80:
mov r14d, 5
jmp loc_16A9
loc_1A8B:
call ___stack_chk_fail
endbr64
mov rbx, rax
jmp _Z5func0ii_cold; func0(int,int) [clone] | long long func0(long long a1, int a2, int a3)
{
int v4; // ebx
unsigned int v5; // r15d
unsigned int v6; // ecx
unsigned int v7; // r13d
int v8; // esi
unsigned int v9; // r14d
long long v10; // rsi
long long v11; // rax
__int8 *v12; // r15
unsigned long long v13; // rdx
unsigned int v14; // eax
unsigned int v15; // esi
long long v16; // rax
long long v17; // rdi
long long v18; // rdx
__int8 v19; // cl
_QWORD *v20; // r8
_BYTE *v21; // rsi
int *v23; // rsi
long long v24; // [rsp+0h] [rbp-160h]
int v26; // [rsp+24h] [rbp-13Ch] BYREF
void *v27; // [rsp+28h] [rbp-138h] BYREF
long long v28; // [rsp+30h] [rbp-130h]
_QWORD v29[2]; // [rsp+38h] [rbp-128h] BYREF
__m128i si128; // [rsp+48h] [rbp-118h]
__m128i v31; // [rsp+58h] [rbp-108h]
__m128i v32; // [rsp+68h] [rbp-F8h]
__m128i v33; // [rsp+78h] [rbp-E8h]
__m128i v34; // [rsp+88h] [rbp-D8h]
__m128i v35; // [rsp+98h] [rbp-C8h]
__m128i v36; // [rsp+A8h] [rbp-B8h]
__m128i v37; // [rsp+B8h] [rbp-A8h]
__m128i v38; // [rsp+C8h] [rbp-98h]
__m128i v39; // [rsp+D8h] [rbp-88h]
__m128i v40; // [rsp+E8h] [rbp-78h]
__m128i v41[2]; // [rsp+F8h] [rbp-68h]
unsigned long long v42; // [rsp+120h] [rbp-40h]
v4 = a2;
v42 = __readfsqword(0x28u);
*(_QWORD *)(a1 + 16) = 0LL;
v26 = a2;
*(_OWORD *)a1 = 0LL;
if ( a2 <= a3 )
{
while ( 1 )
{
v5 = (unsigned int)v4 >> 31;
v6 = -v4;
if ( v4 > 0 )
v6 = v4;
v7 = v6;
if ( v6 <= 9 )
{
v27 = v29;
std::string::_M_construct(&v27, v5 + 1, 45LL);
v12 = (char *)v27 + (v4 < 0);
goto LABEL_19;
}
if ( v6 <= 0x63 )
{
v27 = v29;
std::string::_M_construct(&v27, v5 + 2, 45LL);
v12 = (char *)v27 + (v4 < 0);
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v31 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v32 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v33 = _mm_load_si128((const __m128i *)&xmmword_2100);
v34 = _mm_load_si128((const __m128i *)&xmmword_2110);
v35 = _mm_load_si128((const __m128i *)&xmmword_2120);
v36 = _mm_load_si128((const __m128i *)&xmmword_2130);
v37 = _mm_load_si128((const __m128i *)&xmmword_2140);
v38 = _mm_load_si128((const __m128i *)&xmmword_2150);
v39 = _mm_load_si128((const __m128i *)&xmmword_2160);
v40 = _mm_load_si128((const __m128i *)&xmmword_2170);
v41[0] = _mm_load_si128((const __m128i *)&xmmword_2180);
*(__m128i *)((char *)v41 + 9) = _mm_load_si128((const __m128i *)&xmmword_2190);
LABEL_36:
v19 = si128.m128i_i8[2 * v7];
v12[1] = si128.m128i_i8[2 * v7 + 1];
goto LABEL_20;
}
if ( v6 <= 0x3E7 )
{
v27 = v29;
v9 = 2;
v24 = v6;
v10 = v5 + 3;
goto LABEL_15;
}
if ( v6 <= 0x270F )
{
v27 = v29;
v9 = 3;
v24 = v6;
v10 = v5 + 4;
goto LABEL_15;
}
v8 = 5;
if ( v6 <= 0x1869F )
goto LABEL_29;
if ( v6 <= 0xF423F )
{
v9 = 5;
}
else
{
v9 = 6;
v8 = 7;
if ( v6 <= 0x98967F )
goto LABEL_30;
if ( v6 <= 0x5F5E0FF )
{
v24 = v6;
v9 = 7;
v27 = v29;
v10 = v5 + 8;
goto LABEL_15;
}
if ( v6 <= 0x3B9AC9FFuLL )
{
v8 = 9;
LABEL_29:
v9 = v8 - 1;
LABEL_30:
v24 = v6;
v10 = v5 + v8;
v27 = v29;
goto LABEL_15;
}
v9 = 9;
}
v24 = v6;
v10 = v9 + v5 + 1;
v27 = v29;
LABEL_15:
std::string::_M_construct(&v27, v10, 45LL);
v11 = v24;
v12 = (char *)v27 + (v4 < 0);
si128 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v34 = _mm_load_si128((const __m128i *)&xmmword_2110);
v31 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v35 = _mm_load_si128((const __m128i *)&xmmword_2120);
v32 = _mm_load_si128((const __m128i *)&xmmword_20F0);
v36 = _mm_load_si128((const __m128i *)&xmmword_2130);
v33 = _mm_load_si128((const __m128i *)&xmmword_2100);
v37 = _mm_load_si128((const __m128i *)&xmmword_2140);
v38 = _mm_load_si128((const __m128i *)&xmmword_2150);
v39 = _mm_load_si128((const __m128i *)&xmmword_2160);
v40 = _mm_load_si128((const __m128i *)&xmmword_2170);
v41[0] = _mm_load_si128((const __m128i *)&xmmword_2180);
*(__m128i *)((char *)v41 + 9) = _mm_load_si128((const __m128i *)&xmmword_2190);
while ( 1 )
{
v13 = (unsigned long long)(1374389535 * v11) >> 37;
v14 = v7 - 100 * ((unsigned int)v11 / 0x64);
v15 = v7;
v7 = v13;
v16 = 2 * v14;
v17 = (unsigned int)(v16 + 1);
LOBYTE(v16) = si128.m128i_i8[v16];
v12[v9] = si128.m128i_i8[v17];
v18 = v9 - 1;
v9 -= 2;
v12[v18] = v16;
if ( v15 <= 0x270F )
break;
v11 = v7;
}
if ( v15 > 0x3E7 )
goto LABEL_36;
LABEL_19:
v19 = v7 + 48;
LABEL_20:
*v12 = v19;
v20 = v27;
if ( (char *)v27 + v28 == v27 )
{
LABEL_31:
v23 = *(int **)(a1 + 8);
if ( v23 == *(int **)(a1 + 16) )
{
std::vector<int>::_M_realloc_insert<int const&>(a1, v23, &v26);
v20 = v27;
goto LABEL_25;
}
*v23 = v4;
*(_QWORD *)(a1 + 8) = v23 + 1;
if ( v20 != v29 )
goto LABEL_26;
LABEL_33:
v26 = ++v4;
if ( v4 > a3 )
return a1;
}
else
{
v21 = v27;
while ( *v21 != 48 && !(v4 % ((char)*v21 - 48)) )
{
if ( (char *)v27 + v28 == ++v21 )
goto LABEL_31;
}
LABEL_25:
if ( v20 == v29 )
goto LABEL_33;
LABEL_26:
++v4;
operator delete(v20, v29[0] + 1LL);
v26 = v4;
if ( a3 < v4 )
return a1;
}
}
}
return a1;
} | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x138
MOV dword ptr [RSP + 0x1c],EDX
LEA R12,[RSP + 0x40]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x128],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
MOV qword ptr [RDI + 0x10],0x0
MOV dword ptr [RSP + 0x2c],ESI
MOV qword ptr [RSP + 0x10],RAX
MOVUPS xmmword ptr [RDI],XMM0
CMP ESI,EDX
JG 0x00101863
NOP dword ptr [RAX + RAX*0x1]
LAB_00101610:
MOV R15D,EBX
MOV ECX,EBX
SHR R15D,0x1f
NEG ECX
CMOVS ECX,EBX
MOV EDX,R15D
MOVZX R15D,R15B
MOV R13D,ECX
CMP ECX,0x9
JBE 0x00101a23
CMP ECX,0x63
JBE 0x001018e9
CMP ECX,0x3e7
JBE 0x00101a62
CMP ECX,0x270f
JBE 0x00101a44
MOV EAX,ECX
MOV ESI,0x5
CMP ECX,0x1869f
JBE 0x00101895
CMP R13D,0xf423f
JBE 0x00101a80
MOV R14D,0x6
MOV ESI,0x7
CMP R13D,0x98967f
JBE 0x00101899
CMP R13D,0x5f5e0ff
JBE 0x001019f0
CMP RAX,0x3b9ac9ff
JBE 0x00101890
MOV R14D,0x9
LAB_001016a9:
MOV qword ptr [RSP + 0x8],RAX
LEA ESI,[R14 + RDX*0x1 + 0x1]
MOV qword ptr [RSP + 0x30],R12
LAB_001016b8:
MOV RDI,qword ptr [RSP + 0x10]
MOV EDX,0x2d
CALL 0x00101160
MOVDQA XMM0,xmmword ptr [0x00102110]
MOVDQA XMM1,xmmword ptr [0x001020d0]
MOVDQA XMM2,xmmword ptr [0x001020e0]
MOVDQA XMM3,xmmword ptr [0x001020f0]
MOV RAX,qword ptr [RSP + 0x8]
ADD R15,qword ptr [RSP + 0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x00102120]
MOVDQA XMM4,xmmword ptr [0x00102100]
MOVAPS xmmword ptr [RSP + 0x60],XMM2
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102130]
MOVAPS xmmword ptr [RSP + 0x70],XMM3
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102140]
MOVAPS xmmword ptr [RSP + 0x80],XMM4
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102150]
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102160]
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102170]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102180]
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVDQA XMM0,xmmword ptr [0x00102190]
MOVUPS xmmword ptr [RSP + 0x109],XMM0
JMP 0x001017a3
LAB_001017a0:
MOV EAX,R13D
LAB_001017a3:
IMUL RDX,RAX,0x51eb851f
MOV EAX,R13D
SHR RDX,0x25
IMUL ESI,EDX,0x64
SUB EAX,ESI
MOV ESI,R13D
MOV R13D,EDX
MOV EDX,R14D
ADD EAX,EAX
LEA EDI,[RAX + 0x1]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x50]
MOVZX EDI,byte ptr [RSP + RDI*0x1 + 0x50]
MOV byte ptr [R15 + RDX*0x1],DIL
LEA EDX,[R14 + -0x1]
SUB R14D,0x2
MOV byte ptr [R15 + RDX*0x1],AL
CMP ESI,0x270f
JA 0x001017a0
CMP ESI,0x3e7
JA 0x001019d0
LAB_001017f2:
LEA ECX,[R13 + 0x30]
LAB_001017f6:
MOV byte ptr [R15],CL
MOV R8,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,R8
CMP RDI,R8
JZ 0x001018b0
MOV RSI,R8
JMP 0x0010182e
LAB_00101818:
MOV EAX,EBX
CDQ
IDIV ECX
TEST EDX,EDX
JNZ 0x00101838
ADD RSI,0x1
CMP RDI,RSI
JZ 0x001018b0
LAB_0010182e:
MOVSX EAX,byte ptr [RSI]
SUB EAX,0x30
MOV ECX,EAX
JNZ 0x00101818
LAB_00101838:
CMP R8,R12
JZ 0x001018d1
LAB_00101841:
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,R8
ADD EBX,0x1
LEA RSI,[RAX + 0x1]
CALL 0x00101140
MOV dword ptr [RSP + 0x2c],EBX
CMP dword ptr [RSP + 0x1c],EBX
JGE 0x00101610
LAB_00101863:
MOV RAX,qword ptr [RSP + 0x128]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101a8b
ADD RSP,0x138
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101890:
MOV ESI,0x9
LAB_00101895:
LEA R14D,[RSI + -0x1]
LAB_00101899:
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
MOV qword ptr [RSP + 0x30],R12
JMP 0x001016b8
LAB_001018b0:
MOV RSI,qword ptr [RBP + 0x8]
CMP RSI,qword ptr [RBP + 0x10]
JZ 0x00101a0c
MOV dword ptr [RSI],EBX
ADD RSI,0x4
MOV qword ptr [RBP + 0x8],RSI
CMP R8,R12
JNZ 0x00101841
LAB_001018d1:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EBX,0x1
MOV dword ptr [RSP + 0x2c],EBX
CMP EBX,EAX
JLE 0x00101610
JMP 0x00101863
LAB_001018e9:
MOV RDI,qword ptr [RSP + 0x10]
LEA ESI,[RDX + 0x2]
MOV EDX,0x2d
MOV qword ptr [RSP + 0x30],R12
CALL 0x00101160
MOVDQA XMM0,xmmword ptr [0x001020d0]
ADD R15,qword ptr [RSP + 0x30]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVDQA XMM0,xmmword ptr [0x001020e0]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVDQA XMM0,xmmword ptr [0x001020f0]
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVDQA XMM0,xmmword ptr [0x00102100]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVDQA XMM0,xmmword ptr [0x00102110]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVDQA XMM0,xmmword ptr [0x00102120]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102130]
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102140]
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102150]
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102160]
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102170]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVDQA XMM0,xmmword ptr [0x00102180]
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVDQA XMM0,xmmword ptr [0x00102190]
MOVUPS xmmword ptr [RSP + 0x109],XMM0
NOP dword ptr [RAX]
LAB_001019d0:
LEA ECX,[R13 + R13*0x1]
LEA EAX,[RCX + 0x1]
MOVZX ECX,byte ptr [RSP + RCX*0x1 + 0x50]
MOVZX EAX,byte ptr [RSP + RAX*0x1 + 0x50]
MOV byte ptr [R15 + 0x1],AL
JMP 0x001017f6
LAB_001019f0:
MOV ESI,0x8
MOV qword ptr [RSP + 0x8],RAX
MOV R14D,0x7
MOV qword ptr [RSP + 0x30],R12
ADD ESI,EDX
JMP 0x001016b8
LAB_00101a0c:
LEA RDX,[RSP + 0x2c]
MOV RDI,RBP
LAB_00101a14:
CALL 0x00101bb0
MOV R8,qword ptr [RSP + 0x30]
JMP 0x00101838
LAB_00101a23:
MOV RDI,qword ptr [RSP + 0x10]
LEA ESI,[RDX + 0x1]
MOV EDX,0x2d
MOV qword ptr [RSP + 0x30],R12
CALL 0x00101160
ADD R15,qword ptr [RSP + 0x30]
JMP 0x001017f2
LAB_00101a44:
MOV ESI,0x4
MOV EAX,ECX
MOV qword ptr [RSP + 0x30],R12
MOV R14D,0x3
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
JMP 0x001016b8
LAB_00101a62:
MOV ESI,0x3
MOV EAX,ECX
MOV qword ptr [RSP + 0x30],R12
MOV R14D,0x2
MOV qword ptr [RSP + 0x8],RAX
ADD ESI,EDX
JMP 0x001016b8
LAB_00101a80:
MOV R14D,0x5
JMP 0x001016a9
LAB_00101a8b:
CALL 0x00101150 | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint uVar1;
uint *puVar2;
uint uVar3;
int in_EDX;
uint uVar4;
uint uVar5;
char cVar7;
int iVar8;
long *plVar9;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
uint uVar10;
char *pcVar11;
long in_FS_OFFSET;
uint local_13c;
long *local_138;
long local_130;
long local_128 [2];
int8 local_118;
int8 uStack_110;
int8 local_108;
int8 uStack_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
int8 local_b8;
int8 uStack_b0;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
int uStack_60;
int7 uStack_5f;
char cStack_58;
char acStack_57 [23];
long local_40;
ulong uVar6;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_1);
uVar6 = (ulong)(uint)param_2;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
*(int8 *)(this + 0x10) = 0;
*(int (*) [16])this = (int [16])0x0;
local_13c = param_2;
if (param_2 <= in_EDX) {
LAB_00101610:
do {
uVar5 = (uint)uVar6;
uVar6 = uVar6 >> 0x1f;
uVar4 = -uVar5;
if (0 < (int)uVar5) {
uVar4 = uVar5;
}
cVar7 = (char)uVar6;
local_138 = local_128;
if (uVar4 < 10) {
std::string::_M_construct((ulong)&local_138,cVar7 + '\x01');
pcVar11 = (char *)((long)local_138 + uVar6);
LAB_001017f2:
cVar7 = (char)uVar4 + '0';
}
else {
if (uVar4 < 100) {
std::string::_M_construct((ulong)&local_138,cVar7 + '\x02');
pcVar11 = (char *)((long)local_138 + uVar6);
local_118 = _DAT_001020d0;
uStack_110 = _UNK_001020d8;
local_108 = _DAT_001020e0;
uStack_100 = _UNK_001020e8;
local_f8 = _DAT_001020f0;
uStack_f0 = _UNK_001020f8;
local_e8 = _DAT_00102100;
uStack_e0 = _UNK_00102108;
local_d8 = _DAT_00102110;
uStack_d0 = _UNK_00102118;
local_c8 = _DAT_00102120;
uStack_c0 = _UNK_00102128;
local_b8 = _DAT_00102130;
uStack_b0 = _UNK_00102138;
local_a8 = _DAT_00102140;
uStack_a0 = _UNK_00102148;
local_98 = _DAT_00102150;
uStack_90 = _UNK_00102158;
local_88 = _DAT_00102160;
uStack_80 = _UNK_00102168;
local_78 = _DAT_00102170;
uStack_70 = _UNK_00102178;
local_68 = _DAT_00102180;
uStack_60 = (int)_UNK_00102188;
uStack_5f = (int7)s_293949596979899_00102190._0_8_;
cStack_58 = SUB81(s_293949596979899_00102190._0_8_,7);
acStack_57[0] = s_293949596979899_00102190[8];
acStack_57[1] = s_293949596979899_00102190[9];
acStack_57[2] = s_293949596979899_00102190[10];
acStack_57[3] = s_293949596979899_00102190[0xb];
acStack_57[4] = s_293949596979899_00102190[0xc];
acStack_57[5] = s_293949596979899_00102190[0xd];
acStack_57[6] = s_293949596979899_00102190[0xe];
acStack_57[7] = s_293949596979899_00102190[0xf];
}
else {
if (uVar4 < 1000) {
uVar10 = 2;
cVar7 = cVar7 + '\x03';
}
else if (uVar4 < 10000) {
uVar10 = 3;
cVar7 = cVar7 + '\x04';
}
else {
iVar8 = 5;
if (uVar4 < 100000) {
LAB_00101895:
uVar10 = iVar8 - 1;
LAB_00101899:
cVar7 = (char)iVar8 + cVar7;
}
else {
if (uVar4 < 1000000) {
uVar10 = 5;
}
else {
uVar10 = 6;
iVar8 = 7;
if (uVar4 < 10000000) goto LAB_00101899;
if (uVar4 < 100000000) {
uVar10 = 7;
cVar7 = cVar7 + '\b';
goto LAB_001016b8;
}
if (uVar4 < 1000000000) {
iVar8 = 9;
goto LAB_00101895;
}
uVar10 = 9;
}
cVar7 = (char)uVar10 + '\x01' + cVar7;
}
}
LAB_001016b8:
std::string::_M_construct((ulong)&local_138,cVar7);
pcVar11 = (char *)((long)local_138 + uVar6);
local_118 = _DAT_001020d0;
uStack_110 = _UNK_001020d8;
local_d8 = _DAT_00102110;
uStack_d0 = _UNK_00102118;
local_108 = _DAT_001020e0;
uStack_100 = _UNK_001020e8;
local_c8 = _DAT_00102120;
uStack_c0 = _UNK_00102128;
local_f8 = _DAT_001020f0;
uStack_f0 = _UNK_001020f8;
local_b8 = _DAT_00102130;
uStack_b0 = _UNK_00102138;
local_e8 = _DAT_00102100;
uStack_e0 = _UNK_00102108;
local_a8 = _DAT_00102140;
uStack_a0 = _UNK_00102148;
local_98 = _DAT_00102150;
uStack_90 = _UNK_00102158;
local_88 = _DAT_00102160;
uStack_80 = _UNK_00102168;
local_78 = _DAT_00102170;
uStack_70 = _UNK_00102178;
local_68 = _DAT_00102180;
uStack_60 = (int)_UNK_00102188;
uStack_5f = (int7)s_293949596979899_00102190._0_8_;
cStack_58 = SUB81(s_293949596979899_00102190._0_8_,7);
acStack_57[0] = s_293949596979899_00102190[8];
acStack_57[1] = s_293949596979899_00102190[9];
acStack_57[2] = s_293949596979899_00102190[10];
acStack_57[3] = s_293949596979899_00102190[0xb];
acStack_57[4] = s_293949596979899_00102190[0xc];
acStack_57[5] = s_293949596979899_00102190[0xd];
acStack_57[6] = s_293949596979899_00102190[0xe];
acStack_57[7] = s_293949596979899_00102190[0xf];
do {
uVar3 = uVar4;
uVar4 = uVar3 / 100;
uVar1 = (uVar3 % 100) * 2;
cVar7 = *(char *)((long)&local_118 + (ulong)uVar1);
pcVar11[uVar10] = *(char *)((long)&local_118 + (ulong)(uVar1 + 1));
uVar1 = uVar10 - 1;
uVar10 = uVar10 - 2;
pcVar11[uVar1] = cVar7;
} while (9999 < uVar3);
if (uVar3 < 1000) goto LAB_001017f2;
}
cVar7 = *(char *)((long)&local_118 + (ulong)(uVar4 * 2));
pcVar11[1] = *(char *)((long)&local_118 + (ulong)(uVar4 * 2 + 1));
}
*pcVar11 = cVar7;
for (plVar9 = local_138; (long *)((long)local_138 + local_130) != plVar9;
plVar9 = (long *)((long)plVar9 + 1)) {
if ((*(char *)plVar9 + -0x30 == 0) || ((int)uVar5 % (*(char *)plVar9 + -0x30) != 0))
goto LAB_00101838;
}
puVar2 = *(uint **)(this + 8);
if (puVar2 == *(uint **)(this + 0x10)) {
/* try { // try from 00101a14 to 00101a18 has its CatchHandler @ 00101a90 */
std::vector<int,std::allocator<int>>::_M_realloc_insert<int_const&>
(this,(__normal_iterator)puVar2,(int *)&local_13c);
LAB_00101838:
if (local_138 == local_128) goto LAB_001018d1;
LAB_00101841:
uVar5 = uVar5 + 1;
uVar6 = (ulong)uVar5;
operator_delete(local_138,local_128[0] + 1);
local_13c = uVar5;
if (in_EDX < (int)uVar5) break;
goto LAB_00101610;
}
*puVar2 = uVar5;
*(uint **)(this + 8) = puVar2 + 1;
if (local_138 != local_128) goto LAB_00101841;
LAB_001018d1:
local_13c = uVar5 + 1;
uVar6 = (ulong)local_13c;
} while ((int)local_13c <= in_EDX);
}
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return this;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
} |
2,980 | func0 |
#include <assert.h>
#include <cmath>
| double func0(double r, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return std::nan("1");
}
double sectorarea = (pi * std::pow(r, 2)) * (a / 360);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(std::isnan(func0(9, 360)));
return 0;
}
| O0 | cpp | func0(double, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd 0xf41(%rip),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd -0x20(%rbp),%xmm0
comisd 0xf37(%rip),%xmm0
jb 11a5 <_Z5func0dd+0x3c>
movsd 0xf35(%rip),%xmm0
jmp 11e0 <_Z5func0dd+0x77>
mov -0x18(%rbp),%rax
mov $0x2,%edi
movq %rax,%xmm0
callq 12fa <_ZSt3powIdiEN9__gnu_cxx11__promote_2IT_T0_NS0_9__promoteIS2_XsrSt12__is_integerIS2_E7__valueEE6__typeENS4_IS3_XsrS5_IS3_E7__valueEE6__typeEE6__typeES2_S3_>
movapd %xmm0,%xmm1
mulsd -0x10(%rbp),%xmm1
movsd -0x20(%rbp),%xmm0
movsd 0xf02(%rip),%xmm2
divsd %xmm2,%xmm0
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
leaveq
retq
| _Z5func0dd:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm0, cs:qword_20A8
movsd [rbp+var_10], xmm0
movsd xmm0, [rbp+var_20]
comisd xmm0, cs:dbl_20B0
jb short loc_11A5
movsd xmm0, cs:qword_20B8
jmp short locret_11E6
loc_11A5:
mov rax, [rbp+var_18]
mov edi, 2
movq xmm0, rax
call _ZSt3powIdiEN9__gnu_cxx11__promote_2IDTplcvNS1_IT_XsrSt12__is_integerIS2_E7__valueEE6__typeELi0EcvNS1_IT0_XsrS3_IS7_E7__valueEE6__typeELi0EEXsrS3_ISB_E7__valueEE6__typeES2_S7_
movq rax, xmm0
movq xmm1, rax
mulsd xmm1, [rbp+var_10]
movsd xmm0, [rbp+var_20]
movsd xmm2, cs:dbl_20B0
divsd xmm0, xmm2
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
locret_11E6:
leave
retn | double func0(double a1, double a2)
{
if ( a2 < 360.0 )
return a2 / 360.0 * (std::pow<double,int>(2LL, a1) * 3.142857142857143);
else
return NAN;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM0,qword ptr [0x001020a8]
MOVSD qword ptr [RBP + -0x10],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
COMISD XMM0,qword ptr [0x001020b0]
JC 0x001011a5
MOVSD XMM0,qword ptr [0x001020b8]
JMP 0x001011e6
LAB_001011a5:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,0x2
MOVQ XMM0,RAX
CALL 0x00101343
MOVQ RAX,XMM0
MOVQ XMM1,RAX
MULSD XMM1,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RBP + -0x20]
MOVSD XMM2,qword ptr [0x001020b0]
DIVSD XMM0,XMM2
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM0,qword ptr [RBP + -0x8]
LAB_001011e6:
LEAVE
RET | /* func0(double, double) */
void func0(double param_1,double param_2)
{
if (param_2 < DAT_001020b0) {
std::pow<double,int>(param_1,2);
}
return;
} |
2,981 | func0 |
#include <assert.h>
#include <cmath>
| double func0(double r, double a) {
double pi = 22.0 / 7.0;
if (a >= 360) {
return std::nan("1");
}
double sectorarea = (pi * std::pow(r, 2)) * (a / 360);
return sectorarea;
}
| int main() {
assert(func0(4, 45) == 6.285714285714286);
assert(func0(9, 45) == 31.82142857142857);
assert(std::isnan(func0(9, 360)));
return 0;
}
| O1 | cpp | func0(double, double):
endbr64
comisd 0xedb(%rip),%xmm1
jb 1140 <_Z5func0dd+0x17>
movsd 0xec9(%rip),%xmm0
retq
mulsd %xmm0,%xmm0
mulsd 0xecc(%rip),%xmm0
divsd 0xebc(%rip),%xmm1
mulsd %xmm1,%xmm0
retq
| _Z5func0dd:
endbr64
comisd xmm1, cs:qword_2010
jb short loc_1140
movsd xmm0, cs:qword_2008
retn
loc_1140:
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2018
divsd xmm1, cs:qword_2010
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
if ( a2 < 360.0 )
return a1 * a1 * 3.142857142857143 * (a2 / 360.0);
else
return NAN;
} | func0:
ENDBR64
COMISD XMM1,qword ptr [0x00102010]
JC 0x00101140
MOVSD XMM0,qword ptr [0x00102008]
RET
LAB_00101140:
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102018]
DIVSD XMM1,qword ptr [0x00102010]
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double) */
double func0(double param_1,double param_2)
{
if (_DAT_00102010 <= param_2) {
return DAT_00102008;
}
return param_1 * param_1 * _DAT_00102018 * (param_2 / _DAT_00102010);
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.