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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
1,882 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int lens, int n) {
int mul = 1;
for (int i = 0; i < lens; i++) {
mul = (mul * (arr[i] % n)) % n;
}
return mul % n;
}
| int main() {
int arr1[] = {100, 10, 5, 25, 35, 14};
assert(func0(arr1, 6, 11) == 9);
int arr2[] = {1, 1, 1};
assert(func0(arr2, 3, 1) == 0);
int arr3[] = {1, 2, 1};
assert(func0(arr3, 3, 2) == 0);
return 0;
}
| O2 | cpp | func0(int*, int, int):
endbr64
mov %edx,%ecx
test %esi,%esi
jle 1320 <_Z5func0Piii+0x40>
lea -0x1(%rsi),%eax
mov $0x1,%r8d
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
add $0x4,%rdi
cltd
idiv %ecx
mov %edx,%eax
imul %r8d,%eax
cltd
idiv %ecx
mov %edx,%r8d
cmp %r... | _Z5func0Piii:
endbr64
mov ecx, edx
test esi, esi
jle short loc_1280
movsxd rsi, esi
lea r8, [rdi+rsi*4]
mov esi, 1
nop word ptr [rax+rax+00000000h]
loc_1260:
mov eax, [rdi]
add rdi, 4
cdq
idiv ecx
mov eax, edx
imul eax, esi
cdq
idiv ecx
mov esi, edx
cmp r8, rdi
jnz ... | long long func0(int *a1, int a2, int a3)
{
int *v3; // r8
unsigned int v4; // esi
int v5; // eax
if ( a2 <= 0 )
return (unsigned int)(1 % a3);
v3 = &a1[a2];
v4 = 1;
do
{
v5 = *a1++;
v4 = (int)(v4 * (v5 % a3)) % a3;
}
while ( v3 != a1 );
return v4;
} | func0:
ENDBR64
MOV ECX,EDX
TEST ESI,ESI
JLE 0x00101280
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101260:
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
CDQ
IDIV ECX
MOV EAX,EDX
IMUL EAX,ESI
CDQ
IDIV ECX
MOV ESI,EDX
CMP R8,RDI
JNZ 0x00101260
MOV EAX,ESI
RET
LAB_00101280:
XOR EDX,EDX
MO... | /* func0(int*, int, int) */
ulong func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
ulong uVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
uVar3 = (long)((iVar2 % param_3) * iVar4) %... |
1,883 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int arr[], int lens, int n) {
int mul = 1;
for (int i = 0; i < lens; i++) {
mul = (mul * (arr[i] % n)) % n;
}
return mul % n;
}
| int main() {
int arr1[] = {100, 10, 5, 25, 35, 14};
assert(func0(arr1, 6, 11) == 9);
int arr2[] = {1, 1, 1};
assert(func0(arr2, 3, 1) == 0);
int arr3[] = {1, 2, 1};
assert(func0(arr3, 3, 2) == 0);
return 0;
}
| O3 | cpp | func0(int*, int, int):
endbr64
mov %edx,%ecx
test %esi,%esi
jle 1360 <_Z5func0Piii+0x40>
lea -0x1(%rsi),%eax
mov $0x1,%r8d
lea 0x4(%rdi,%rax,4),%rsi
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
add $0x4,%rdi
cltd
idiv %ecx
mov %edx,%eax
imul %r8d,%eax
cltd
idiv %ecx
mov %edx,%r8d
cmp %r... | _Z5func0Piii:
endbr64
mov ecx, edx
test esi, esi
jle short loc_1180
movsxd rsi, esi
lea r8, [rdi+rsi*4]
mov esi, 1
nop word ptr [rax+rax+00000000h]
loc_1160:
mov eax, [rdi]
add rdi, 4
cdq
idiv ecx
mov eax, edx
imul eax, esi
cdq
idiv ecx
mov esi, edx
cmp r8, rdi
jnz ... | long long func0(int *a1, int a2, int a3)
{
int *v3; // r8
unsigned int v4; // esi
int v5; // eax
if ( a2 <= 0 )
return (unsigned int)(1 % a3);
v3 = &a1[a2];
v4 = 1;
do
{
v5 = *a1++;
v4 = (int)(v4 * (v5 % a3)) % a3;
}
while ( v3 != a1 );
return v4;
} | func0:
ENDBR64
MOV ECX,EDX
TEST ESI,ESI
JLE 0x00101180
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101160:
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
CDQ
IDIV ECX
MOV EAX,EDX
IMUL EAX,ESI
CDQ
IDIV ECX
MOV ESI,EDX
CMP R8,RDI
JNZ 0x00101160
MOV EAX,ESI
RET
LAB_00101180:
XOR EDX,EDX
MO... | /* func0(int*, int, int) */
ulong func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
ulong uVar3;
int iVar4;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
uVar3 = (long)((iVar2 % param_3) * iVar4) %... |
1,884 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| bool func0(std::vector<int> l) {
std::sort(l.begin(), l.end());
std::vector<int> range;
for (int i = std::min(l[0], l[l.size() - 1]); i <= std::max(l[0], l[l.size() - 1]); ++i) {
range.push_back(i);
}
return l == range;
}
| int main() {
assert(func0({1, 2, 3, 4, 5}) == true);
assert(func0({1, 2, 3, 5, 6}) == false);
assert(func0({1, 2, 1}) == false);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1802 <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x48(%rbp),%r... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // rax
long long v7; // rbx
long long v8; // rax
_DWORD *v9; // rax
unsigned int v10; // ebx
int i; // [rsp+1Ch] [rbp-34h] BYREF
_BYTE v13[24]; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x0010181a
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001017ce
MOV RSI,RBX
MOV RDI,RAX
LA... | /* func0(std::vector<int, std::allocator<int> >) */
ulong func0(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
long lVar4;
int *piVar5;
int *piVar6;
int7 extraout_var;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_... |
1,885 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| bool func0(std::vector<int> l) {
std::sort(l.begin(), l.end());
std::vector<int> range;
for (int i = std::min(l[0], l[l.size() - 1]); i <= std::max(l[0], l[l.size() - 1]); ++i) {
range.push_back(i);
}
return l == range;
}
| int main() {
assert(func0({1, 2, 3, 4, 5}) == true);
assert(func0({1, 2, 3, 5, 6}) == false);
assert(func0({1, 2, 1}) == false);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov 0x8(%rdi),%r12
mov (%rdi),%r13
cmp %r12,%r13
je 12fc <_Z5func0St6vectorIiSaIiEE+0xb3>
mov %r12,%rbp
s... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov r12, [rdi+8]
mov r13, [rdi]
cmp r13, r12
jz loc_1302
mov rbp, r12
sub rbp, r13
mov rdx, rbp
sar rdx... | long long func0(char **a1)
{
char *v2; // r12
char *v3; // r13
int v4; // eax
unsigned long long v5; // rax
char *v6; // rbp
int v7; // ecx
char *v8; // rax
int v9; // edx
char *v10; // rsi
char *v11; // rax
int v12; // edi
char *v13; // rax
int i; // ebp
char *v15; // rdi
char *v16; // r... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV R12,qword ptr [RDI + 0x8]
MOV R13,qword ptr [RDI]
CMP R13,R12
JZ 0x00101302
MOV RBP,R12
SUB RBP,R13
MOV RDX,RBP
SAR RDX,0x2
MOV EAX,0x40
JZ 0x00101295
BSR RAX,RDX
XOR EA... | /* func0(std::vector<int, std::allocator<int> >) */
bool func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,int4 param_11,int8 param_12,int8 param_13,int8 param_14,
int8 param_15)
{
int iVar1;
long lVar2... |
1,886 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| bool func0(std::vector<int> l) {
std::sort(l.begin(), l.end());
std::vector<int> range;
for (int i = std::min(l[0], l[l.size() - 1]); i <= std::max(l[0], l[l.size() - 1]); ++i) {
range.push_back(i);
}
return l == range;
}
| int main() {
assert(func0({1, 2, 3, 4, 5}) == true);
assert(func0({1, 2, 3, 5, 6}) == false);
assert(func0({1, 2, 1}) == false);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %r12,%rbp
mov %r12,%rdi
sub %r13,%rbp
cmp %r12,%r13
je 1538 ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 30h
mov r13, [rdi+8]
mov r12, [rdi]
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
mov rdi, r13
cmp r12, r13
jz loc_18B2
mov rbp, r13
mov rdx, 0FF... | long long func0(char **a1)
{
char *v2; // r13
char *v3; // r12
char *v4; // rdi
long long v5; // rdx
unsigned long long v6; // rax
char *v7; // rbp
int v8; // ecx
int v9; // edx
char *v10; // rax
char *v11; // rsi
char *v12; // rsi
int v13; // edx
int v14; // eax
int v15; // ebp
_BYTE *v1... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x30
MOV R13,qword ptr [RDI + 0x8]
MOV R12,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RDI,R13
CMP R12,R13
JZ 0x001018b2
MOV RBP,R13
MOV RDX,-0x2
SUB RBP,R12
MOV RAX,RBP
SAR RAX,0x2
JZ 0x001018... | /* func0(std::vector<int, std::allocator<int> >) */
bool func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,int4 param_11,int1 param_12 [16],int8 param_13,int8 param_14)
{
int8 uVar1;
int iVar2;
ulong uVar3;
i... |
1,887 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| bool func0(std::vector<int> l) {
std::sort(l.begin(), l.end());
std::vector<int> range;
for (int i = std::min(l[0], l[l.size() - 1]); i <= std::max(l[0], l[l.size() - 1]); ++i) {
range.push_back(i);
}
return l == range;
}
| int main() {
assert(func0({1, 2, 3, 4, 5}) == true);
assert(func0({1, 2, 3, 5, 6}) == false);
assert(func0({1, 2, 1}) == false);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x38,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%r13
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %r12,%r14
mov %r12,%rdi
sub %r13,%r14
cmp ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 38h
mov r12, [rdi+8]
mov rbx, [rdi]
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
mov r14, r12
sub r14, rbx
cmp rbx, r12
jz loc_18F0
mov ... | long long func0(char **a1)
{
char *v2; // r12
char *v3; // rbx
long long v4; // r14
char *v5; // r15
unsigned long long v6; // rdx
char *v7; // r13
int v8; // r14d
char *v9; // rsi
int v10; // edx
char *i; // rax
char *v12; // rdi
int v13; // ecx
int v14; // edx
char *v15; // rax
char *v1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x38
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV R14,R12
SUB R14,RBX
CMP RBX,R12
JZ 0x001018f0
MOV RAX,R14
LEA R15,[RBX + 0x4]
SAR RAX,0x2
JZ 0x00... | /* func0(std::vector<int, std::allocator<int> >) */
bool func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,int4 param_11,int1 param_12 [16],int8 param_13,int8 param_14)
{
long lVar1;
int8 uVar2;
int iVar3;
ul... |
1,888 | func0 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <assert.h>
| std::set<std::pair<int, int>> func0(std::vector<std::pair<int, int>> test_list1, std::vector<std::pair<int, int>> test_list2) {
std::set<std::pair<int, int>> set1;
std::set<std::pair<int, int>> set2;
for (auto &ele : test_list1) {
if (ele.first > ele.second)
std::swap(ele.first, e... | int main() {
assert((func0({{3, 4}, {5, 6}, {9, 10}, {4, 5}}, {{5, 4}, {3, 4}, {6, 5}, {9, 11}}) == std::set<std::pair<int, int>>{{4, 5}, {3, 4}, {5, 6}}));
assert((func0({{4, 1}, {7, 4}, {11, 13}, {17, 14}}, {{1, 4}, {7, 4}, {16, 12}, {10, 13}}) == std::set<std::pair<int, int>>{{4, 7}, {1, 4}}));
assert... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov ... | _Z5func0St6vectorISt4pairIiiESaIS1_EES3_:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_D8], rdi
mov [rbp+var_E0], rsi
mov [rbp+var_E8], rdx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
lea rax, [rbp+var_... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // r12
long long v5; // rdx
long long v6; // r13
long long v7; // r15
long long v8; // r14
long long v9; // rbx
long long v10; // rax
long long v13; // [rsp+20h] [rbp-D0h] BYREF
_QWORD v14[2]; // [rsp+28h... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xd8],RDI
MOV qword ptr [RBP + -0xe0],RSI
MOV qword ptr [RBP + -0xe8],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xa0]
MOV RDI,RAX
CALL 0x00102172
LEA RAX,... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
set<std::pair<int,int>,std::less<std::pair<int,int>>,std::allocator<std::pair<int,int>>> *
func0(vector param_1,vector param_2)
{
bool bVar1;
iterator iV... |
1,889 | func0 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <assert.h>
| std::set<std::pair<int, int>> func0(std::vector<std::pair<int, int>> test_list1, std::vector<std::pair<int, int>> test_list2) {
std::set<std::pair<int, int>> set1;
std::set<std::pair<int, int>> set2;
for (auto &ele : test_list1) {
if (ele.first > ele.second)
std::swap(ele.first, e... | int main() {
assert((func0({{3, 4}, {5, 6}, {9, 10}, {4, 5}}, {{5, 4}, {3, 4}, {6, 5}, {9, 11}}) == std::set<std::pair<int, int>>{{4, 5}, {3, 4}, {5, 6}}));
assert((func0({{4, 1}, {7, 4}, {11, 13}, {17, 14}}, {{1, 4}, {7, 4}, {16, 12}, {10, 13}}) == std::set<std::pair<int, int>>{{4, 7}, {1, 4}}));
assert... | O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,%r12
mov %rdx,%r14
mov %fs:0x28,%rax
mov %rax,0x... | _Z5func0St6vectorISt4pairIiiESaIS1_EES3_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov r12, rdi
mov r14, rdx
mov rax, fs:28h
mov [rsp+0A8h+var_30], rax
xor eax, eax
mov [rsp+0A8h+var_90], 0
mov [rsp+0A8h+var_88], 0
lea rax, [rsp+... | long long func0(long long a1, int **a2, int **a3)
{
int *v4; // rbx
int *v5; // rbp
int v6; // eax
int v7; // edx
int *v8; // rbx
int *v9; // rbp
int v10; // eax
int v11; // edx
long long v12; // r14
int *v13; // rbp
int *v14; // rbx
int v16; // edx
int v17; // eax
int v18; // edx
int v19... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
ADD RSP,-0x80
MOV R12,RDI
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV qw... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
long func0(vector param_1,vector param_2)
{
int iVar1;
int *piVar2;
_Rb_tree_iterator _Var3;
int4 extraout_var;
pair *ppVar4;
_Rb_tree_node_base ... |
1,890 | func0 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <assert.h>
| std::set<std::pair<int, int>> func0(std::vector<std::pair<int, int>> test_list1, std::vector<std::pair<int, int>> test_list2) {
std::set<std::pair<int, int>> set1;
std::set<std::pair<int, int>> set2;
for (auto &ele : test_list1) {
if (ele.first > ele.second)
std::swap(ele.first, e... | int main() {
assert((func0({{3, 4}, {5, 6}, {9, 10}, {4, 5}}, {{5, 4}, {3, 4}, {6, 5}, {9, 11}}) == std::set<std::pair<int, int>>{{4, 5}, {3, 4}, {5, 6}}));
assert((func0({{4, 1}, {7, 4}, {11, 13}, {17, 14}}, {{1, 4}, {7, 4}, {16, 12}, {10, 13}}) == std::set<std::pair<int, int>>{{4, 7}, {1, 4}}));
assert... | O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov (%rsi),%rbp
mov 0x8(%rsi),%r12
mov %rdx... | _Z5func0St6vectorISt4pairIiiESaIS1_EES3_:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 88h
mov rbx, [rsi]
mov r14, [rsi+8]
mov [rsp+0B8h+var_B0], rdx
lea rbp, [rsp+0B8h+var_A0]
lea r12, [rsp+0B8h+var_70]
mov rax, fs:28h
mov [rs... | long long func0(long long a1, __m128i **a2, __m128i **a3)
{
__m128i *v4; // rbx
__m128i *v5; // r14
__m128i v6; // xmm0
__m128i *v7; // rbx
__m128i *v8; // r14
__m128i v9; // xmm0
int *v10; // rbx
long long v11; // r15
int *v12; // r14
int v13; // eax
int v14; // eax
long long insert_hint_uniqu... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RDX
LEA RBP,[RSP + 0x18]
LEA R12,[RSP + 0x48]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],0x... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
_Rb_tree<std::pair<int,int>,std::pair<int,int>,std::_Identity<std::pair<int,int>>,std::less<std::pair<int,int>>,std::allocator<std::pair<int,int>>>
* func0(ve... |
1,891 | func0 |
#include <iostream>
#include <set>
#include <vector>
#include <algorithm>
#include <assert.h>
| std::set<std::pair<int, int>> func0(std::vector<std::pair<int, int>> test_list1, std::vector<std::pair<int, int>> test_list2) {
std::set<std::pair<int, int>> set1;
std::set<std::pair<int, int>> set2;
for (auto &ele : test_list1) {
if (ele.first > ele.second)
std::swap(ele.first, e... | int main() {
assert((func0({{3, 4}, {5, 6}, {9, 10}, {4, 5}}, {{5, 4}, {3, 4}, {6, 5}, {9, 11}}) == std::set<std::pair<int, int>>{{4, 5}, {3, 4}, {5, 6}}));
assert((func0({{4, 1}, {7, 4}, {11, 13}, {17, 14}}, {{1, 4}, {7, 4}, {16, 12}, {10, 13}}) == std::set<std::pair<int, int>>{{4, 7}, {1, 4}}));
assert... | O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov (%rsi),%rbx
mov %rdi,0x20(%rsp)
lea 0x38(%rsp),%r12
lea ... | _Z5func0St6vectorISt4pairIiiESaIS1_EES3_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov rbx, [rsi]
mov [rsp+0D8h+var_B8], rdi
lea r12, [rsp+0D8h+var_A0]
lea r13, [rsp+0D8h+var_70]
mov [rsp+0D8h+var_B0], rdx
lea rcx, [rsp+0D8h+var_A8]
mov ... | long long func0(long long a1, __m128i **a2, __m128i **a3)
{
__m128i *v3; // rbx
__m128i *v4; // rax
long long v5; // rax
__m128i v6; // xmm0
int v7; // r14d
int v8; // r15d
int v9; // eax
long long insert_unique_pos; // rax
int *v11; // rdx
int *v12; // rbp
__m128i *v13; // rbp
__m128i *j; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RBX,qword ptr [RSI]
MOV qword ptr [RSP + 0x20],RDI
LEA R12,[RSP + 0x38]
LEA R13,[RSP + 0x68]
MOV qword ptr [RSP + 0x28],RDX
LEA RCX,[RSP + 0x30]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
MOV RAX,qword ptr ... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
_Rb_tree<std::pair<int,int>,std::pair<int,int>,std::_Identity<std::pair<int,int>>,std::less<std::pair<int,int>>,std::allocator<std::pair<int,int>>>
* func0(ve... |
1,892 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string str1, char ch, char newch) {
for (size_t i = 0; i < str1.length(); ++i) {
if (str1[i] == ch) {
str1[i] = newch;
}
}
return str1;
}
| int main() {
assert(func0("polygon",'y','l') == "pollgon");
assert(func0("character",'c','a') == "aharaater");
assert(func0("python",'l','a') == "python");
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char, char):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %ecx,%eax
mov %dl,-0x34(%rbp)
mov %al,-0x38(%rbp)
movq $0x0,-0x18(%rbp)
mov -0x30(%rbp)... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov eax, ecx
mov [rbp+var_34], dl
mov [rbp+var_38], al
mov [rbp+var_18], 0
jmp short loc_242E
loc_23F0:
mov rdx, [... | long long func0(long long a1, long long a2, char a3, char a4)
{
unsigned long long i; // rax
unsigned long long v8; // [rsp+28h] [rbp-18h]
v8 = 0LL;
for ( i = std::string::length(a2); v8 < i; i = std::string::length(a2) )
{
if ( a3 == *(_BYTE *)std::string::operator[](a2, v8) )
*(_BYTE *)std::stri... | 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 EAX,ECX
MOV byte ptr [RBP + -0x34],DL
MOV byte ptr [RBP + -0x38],AL
MOV qword ptr [RBP + -0x18],0x0
JMP 0x0010242e
LAB_001023f0:
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
M... | /* func0(std::string, char, char) */
string * func0(string *param_1,string *param_2,char param_3,int param_4)
{
char *pcVar1;
int *puVar2;
ulong uVar3;
int8 local_20;
local_20 = 0;
while( true ) {
uVar3 = std::string::length();
if (uVar3 <= local_20) break;
pcVar1 = (char *)std::string::ope... |
1,893 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string str1, char ch, char newch) {
for (size_t i = 0; i < str1.length(); ++i) {
if (str1[i] == ch) {
str1[i] = newch;
}
}
return str1;
}
| int main() {
assert(func0("polygon",'y','l') == "pollgon");
assert(func0("character",'c','a') == "aharaater");
assert(func0("python",'l','a') == "python");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char, char):
endbr64
mov %rdi,%rax
cmpq $0x0,0x8(%rsi)
je 1279 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc+0x30>
mov $0x0,%r8d
jmp 1269 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc:
endbr64
mov r8, rdi
cmp qword ptr [rsi+8], 0
jz loc_1323
mov eax, 0
jmp short loc_124C
loc_1242:
add rax, 1
cmp rax, [rsi+8]
jnb short loc_125A
loc_124C:
mov rdi, rax
add rdi, [rsi]
cmp [rdi], dl
jnz short l... | char ** func0(char **a1, char **a2, char a3, char a4)
{
unsigned long long v5; // rax
char *v6; // rdi
_QWORD *v7; // rcx
char *v8; // rdx
char *v9; // rax
char *v11; // rdx
unsigned int v12; // edx
unsigned long long v13; // r9
char *v14; // rcx
char *v15; // r10
unsigned int v16; // edx
unsign... | func0:
ENDBR64
MOV R8,RDI
CMP qword ptr [RSI + 0x8],0x0
JZ 0x00101323
MOV EAX,0x0
JMP 0x0010124c
LAB_00101242:
ADD RAX,0x1
CMP RAX,qword ptr [RSI + 0x8]
JNC 0x0010125a
LAB_0010124c:
MOV RDI,RAX
ADD RDI,qword ptr [RSI]
CMP byte ptr [RDI],DL
JNZ 0x00101242
MOV byte ptr [RDI],CL
JMP 0x00101242
LAB_0010125a:
LEA RCX,[R8 + ... | /* func0(std::string, char, char) */
long * func0(long *param_1,long *param_2,char param_3,char param_4)
{
ulong uVar1;
uint uVar2;
long *plVar3;
long lVar4;
uint uVar5;
long *plVar6;
if (param_2[1] == 0) {
*param_1 = (long)(param_1 + 2);
plVar6 = (long *)*param_2;
if (plVar6 == param_2 +... |
1,894 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string str1, char ch, char newch) {
for (size_t i = 0; i < str1.length(); ++i) {
if (str1[i] == ch) {
str1[i] = newch;
}
}
return str1;
}
| int main() {
assert(func0("polygon",'y','l') == "pollgon");
assert(func0("character",'c','a') == "aharaater");
assert(func0("python",'l','a') == "python");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char, char):
endbr64
mov 0x8(%rsi),%r10
mov %rdi,%rax
test %r10,%r10
je 15e3 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc+0x33>
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov (%rsi),%r9
add %r8,%r9
... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc:
endbr64
mov r9, rdi
mov rdi, rsi
mov rsi, [rsi+8]
mov r8, rsi
test rsi, rsi
jz short loc_1440
xor eax, eax
nop dword ptr [rax+rax+00000000h]
loc_13E0:
mov r8, [rdi]
add r8, rax
cmp [r8], dl
jnz short loc_13F2... | char ** func0(char **a1, char **a2, char a3, char a4)
{
unsigned long long v6; // rsi
char *v7; // r8
unsigned long long i; // rax
char *v9; // r8
_QWORD *v10; // rcx
char *v11; // rax
unsigned int v12; // esi
char *v13; // rdx
char **result; // rax
unsigned long long v15; // r8
char *v16; // rcx
... | func0:
ENDBR64
MOV R9,RDI
MOV RDI,RSI
MOV RSI,qword ptr [RSI + 0x8]
MOV R8,RSI
TEST RSI,RSI
JZ 0x00101440
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001013e0:
MOV R8,qword ptr [RDI]
ADD R8,RAX
CMP byte ptr [R8],DL
JNZ 0x001013f2
MOV byte ptr [R8],CL
MOV RSI,qword ptr [RDI + 0x8]
LAB_001013f2:
ADD RAX,0x1
MOV R8,RSI
... | /* func0(std::string, char, char) */
long * func0(long *param_1,long *param_2,char param_3,char param_4)
{
ulong uVar1;
uint uVar2;
long *plVar3;
long lVar4;
uint uVar5;
long *plVar6;
ulong uVar7;
uVar7 = param_2[1];
if (uVar7 == 0) {
*param_1 = (long)(param_1 + 2);
plVar6 = (long *)*para... |
1,895 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(std::string str1, char ch, char newch) {
for (size_t i = 0; i < str1.length(); ++i) {
if (str1[i] == ch) {
str1[i] = newch;
}
}
return str1;
}
| int main() {
assert(func0("polygon",'y','l') == "pollgon");
assert(func0("character",'c','a') == "aharaater");
assert(func0("python",'l','a') == "python");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char, char):
endbr64
mov 0x8(%rsi),%r10
mov %rdi,%rax
test %r10,%r10
je 1638 <_Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc+0x28>
xor %r8d,%r8d
mov (%rsi),%r11
lea (%r11,%r8,1),%r9
cmp %dl,(%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEcc:
endbr64
mov r8, [rsi+8]
mov r10, rdi
mov rdi, rsi
test r8, r8
jz loc_1560
xor eax, eax
loc_14B9:
mov r9, [rdi]
loc_14BC:
lea rsi, [r9+rax]
cmp [rsi], dl
jz short loc_1508
add rax, 1
cmp rax, r8
jb short... | char ** func0(char **a1, char **a2, char a3, char a4)
{
unsigned long long v4; // r8
unsigned long long i; // rax
char *v8; // r9
_QWORD *v9; // rcx
char *v10; // rax
char *v11; // rdx
char **result; // rax
unsigned int v13; // r8d
unsigned long long v14; // r9
char *v15; // rcx
char *v16; // r11
... | func0:
ENDBR64
MOV R8,qword ptr [RSI + 0x8]
MOV R10,RDI
MOV RDI,RSI
TEST R8,R8
JZ 0x00101560
XOR EAX,EAX
LAB_001014b9:
MOV R9,qword ptr [RDI]
LAB_001014bc:
LEA RSI,[R9 + RAX*0x1]
CMP byte ptr [RSI],DL
JZ 0x00101508
ADD RAX,0x1
CMP RAX,R8
JC 0x001014bc
LAB_001014cd:
LEA RCX,[R10 + 0x10]
LEA RAX,[RDI + 0x10]
MOV qword pt... | /* func0(std::string, char, char) */
long * func0(long *param_1,long *param_2,char param_3,char param_4)
{
ulong uVar1;
uint uVar2;
long *plVar3;
long lVar4;
uint uVar5;
long *plVar6;
ulong uVar7;
uVar7 = param_2[1];
if (uVar7 == 0) {
*param_1 = (long)(param_1 + 2);
plVar6 = (long *)*para... |
1,896 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(map<string, int> dict1) {
vector<pair<string, int>> sort_counter;
for(auto &entry : dict1) {
sort_counter.push_back(entry);
}
sort(sort_counter.begin(), sort_counter.end(), [](const pair<string, int> &a, const pair<string, int> &b) {
return a.second ... | int main() {
assert((func0({{"Math", 81}, {"Physics", 83}, {"Chemistry", 87}}) == vector<pair<string, int>>{{"Chemistry", 87}, {"Physics", 83}, {"Math", 81}}));
assert((func0({{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}}) == vector<pair<string, int>>{{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}... | O0 | cpp | func0(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, 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, int> > >)::{la... | _ZZ5func0St3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiSt4lessIS5_ESaISt4pairIKS5_iEEEENKUlRKS8_IS5_iESF_E_clESF_SF_:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov edx, [rax+20h]
mov rax, [rbp+var_18]
mov ... | bool func0(std::map<std::string,int>)::{lambda(std::pair const&<std::string,int>,std::pair const&<std::string,int>)#1}::operator()(
long long a1,
long long a2,
long long a3)
{
return *(_DWORD *)(a2 + 32) > *(_DWORD *)(a3 + 32);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x00104854
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x50],RAX
MO... | /* func0(std::map<std::string, int, std::less<std::string >, std::allocator<std::pair<std::string
const, int> > >) */
vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>> * func0(map param_1)
{
char cVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
_lambda_std__pair<std::str... |
1,897 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(map<string, int> dict1) {
vector<pair<string, int>> sort_counter;
for(auto &entry : dict1) {
sort_counter.push_back(entry);
}
sort(sort_counter.begin(), sort_counter.end(), [](const pair<string, int> &a, const pair<string, int> &b) {
return a.second ... | int main() {
assert((func0({{"Math", 81}, {"Physics", 83}, {"Chemistry", 87}}) == vector<pair<string, int>>{{"Chemistry", 87}, {"Physics", 83}, {"Math", 81}}));
assert((func0({{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}}) == vector<pair<string, int>>{{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}... | O1 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_string<char, st... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEElS9_NS0_5__ops15_Iter_comp_iterIZ5func0St3mapIS8_iSt4lessIS8_ESaIS2_IKS8_iEEEEUlRKS9_SP_E_EEEvT_T0_ST_T1_T2_:
push r15
push r14
push r13
push r12
push rbp
push rbx
s... | unsigned long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,long,std::pair<std::string,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::map<std::string,int>)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(... | __adjust_heap<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,long,std::pair<std::string,int>,__ops::_Iter_comp_iter<func0(std::map<std::string,int,std::less<std::string>,std::allocator<std::pair<std::string_const,int>>>)::{lambda(std::pa... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >, long,
std::pair<std::string, int>, __ops::_Iter_comp_iter<func0(std::ma... |
1,898 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(map<string, int> dict1) {
vector<pair<string, int>> sort_counter;
for(auto &entry : dict1) {
sort_counter.push_back(entry);
}
sort(sort_counter.begin(), sort_counter.end(), [](const pair<string, int> &a, const pair<string, int> &b) {
return a.second ... | int main() {
assert((func0({{"Math", 81}, {"Physics", 83}, {"Chemistry", 87}}) == vector<pair<string, int>>{{"Chemistry", 87}, {"Physics", 83}, {"Math", 81}}));
assert((func0({{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}}) == vector<pair<string, int>>{{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}... | O2 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | _ZSt25__unguarded_linear_insertIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEENS0_5__ops14_Val_comp_iterIZ5func0St3mapIS8_iSt4lessIS8_ESaIS2_IKS8_iEEEEUlRKS9_SP_E_EEEvT_T0__isra_0:
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rd... | unsigned long long std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,__gnu_cxx::__ops::_Val_comp_iter<func0(std::map<std::string,int>)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(
long long *a... | __unguarded_linear_insert<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,__ops::_Val_comp_iter<func0(std::map<std::string,int,std::less<std::string>,std::allocator<std::pair<std::string_const,int>>>)::{lambda(std::pair<std::string,int>co... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__unguarded_linear_insert<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >,
__ops::_Val_comp_iter<func0(std::map<std::string, int, std:... |
1,899 | func0 | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <cassert>
using namespace std;
| vector<pair<string, int>> func0(map<string, int> dict1) {
vector<pair<string, int>> sort_counter;
for(auto &entry : dict1) {
sort_counter.push_back(entry);
}
sort(sort_counter.begin(), sort_counter.end(), [](const pair<string, int> &a, const pair<string, int> &b) {
return a.second ... | int main() {
assert((func0({{"Math", 81}, {"Physics", 83}, {"Chemistry", 87}}) == vector<pair<string, int>>{{"Chemistry", 87}, {"Physics", 83}, {"Math", 81}}));
assert((func0({{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}}) == vector<pair<string, int>>{{"Math", 400}, {"Physics", 300}, {"Chemistry", 250}... | O3 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int>, std::allocator<std::pair<std::__cxx11::basic_str... | _ZSt16__insertion_sortIN9__gnu_cxx17__normal_iteratorIPSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiESt6vectorIS9_SaIS9_EEEENS0_5__ops15_Iter_comp_iterIZ5func0St3mapIS8_iSt4lessIS8_ESaIS2_IKS8_iEEEEUlRKS9_SP_E_EEEvT_SS_T0__isra_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
s... | unsigned long long std::__insertion_sort<__gnu_cxx::__normal_iterator<std::pair<std::string,int> *,std::vector<std::pair<std::string,int>>>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::map<std::string,int>)::{lambda(std::pair<std::string,int> const&,std::pair<std::string,int> const&)#1}>>(
long long a1,
... | __insertion_sort<__normal_iterator<std::pair<std::string,int>*,std::vector<std::pair<std::string,int>,std::allocator<std::pair<std::string,int>>>>,__ops::_Iter_comp_iter<func0(std::map<std::string,int,std::less<std::string>,std::allocator<std::pair<std::string_const,int>>>)::{lambda(std::pair<std::string,int>const&,std... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__insertion_sort<__normal_iterator<std::pair<std::string, int>*,
std::vector<std::pair<std::string, int>, std::allocator<std::pair<std::string, int> > > >,
__ops::_Iter_comp_iter<func0(std::map<std::string, int, std::less<st... |
1,900 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| int func0(std::vector<int> nums) {
int sum = *max_element(nums.begin(), nums.end()) + *min_element(nums.begin(), nums.end());
return sum;
}
| int main() {
assert(func0({1,2,3}) == 4);
assert(func0({-1,2,3,4}) == 3);
assert(func0({2,3,6}) == 8);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x30,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 163c <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 30h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mo... | long long func0(long long a1)
{
long long v1; // rbx
long long v2; // rax
long long v3; // r12
long long v4; // rax
long long v6; // [rsp+18h] [rbp-28h] BYREF
_QWORD v7[4]; // [rsp+20h] [rbp-20h] BYREF
v7[1] = __readfsqword(0x28u);
v1 = std::vector<int>::end(a1);
v2 = std::vector<int>::begin(a1);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV qword ptr [RBP + -0x38],RDI
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 0x0010168c
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101640
MOV RSI,RBX
MOV R... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int4 extraout_var;
int *piVar4;
int4 extraout_var_00;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int8 local_30;
i... |
1,901 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| int func0(std::vector<int> nums) {
int sum = *max_element(nums.begin(), nums.end()) + *min_element(nums.begin(), nums.end());
return sum;
}
| int main() {
assert(func0({1,2,3}) == 4);
assert(func0({-1,2,3,4}) == 3);
assert(func0({2,3,6}) == 8);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%r8
mov (%rdi),%rcx
cmp %r8,%rcx
je 124f <_Z5func0St6vectorIiSaIiEE+0x46>
lea 0x4(%rcx),%rdx
cmp %rdx,%r8
je 1257 <_Z5func0St6vectorIiSaIiEE+0x4e>
mov %rdx,%rax
mov %rcx,%rsi
mov (%rax),%edi
cmp %edi,(%rsi)
cmovl %r... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r8, [rdi+8]
mov rcx, [rdi]
cmp rcx, r8
jz short loc_1258
lea rdx, [rcx+4]
cmp r8, rdx
jz short loc_1254
mov rax, rdx
mov rsi, rcx
loc_1228:
mov edi, [rax]
cmp [rsi], edi
cmovl rsi, rax
add rax, 4
cmp rax, r8
jnz short loc... | long long func0(int **a1)
{
int *v1; // r8
int *v2; // rcx
int *v3; // rdx
int *v4; // rax
int *v5; // rsi
int i; // eax
v1 = a1[1];
v2 = *a1;
if ( *a1 == v1 )
{
i = *v1;
v2 = a1[1];
}
else
{
v3 = v2 + 1;
if ( v1 == v2 + 1 )
{
i = *v2;
}
else
{
v4 ... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI]
CMP RCX,R8
JZ 0x00101258
LEA RDX,[RCX + 0x4]
CMP R8,RDX
JZ 0x00101254
MOV RAX,RDX
MOV RSI,RCX
LAB_00101228:
MOV EDI,dword ptr [RAX]
CMP dword ptr [RSI],EDI
CMOVL RSI,RAX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101228
MOV EAX,dword ptr [RSI]
CMP R8,RDX
JZ 0x0010... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int4 in_register_0000003c;
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
piVar4 = *(int **)CONCAT44(in_register_000000... |
1,902 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| int func0(std::vector<int> nums) {
int sum = *max_element(nums.begin(), nums.end()) + *min_element(nums.begin(), nums.end());
return sum;
}
| int main() {
assert(func0({1,2,3}) == 4);
assert(func0({-1,2,3,4}) == 3);
assert(func0({2,3,6}) == 8);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rdx
mov 0x8(%rdi),%r8
mov (%rdx),%eax
mov %eax,%esi
cmp %r8,%rdx
je 13e0 <_Z5func0St6vectorIiSaIiEE+0x40>
add $0x4,%rdx
cmp %rdx,%r8
je 13e0 <_Z5func0St6vectorIiSaIiEE+0x40>
mov %rdx,%rcx
mov (%rcx),%edi
cmp %edi,%e... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov r8, [rdi+8]
mov rdi, [rdi]
mov edx, [rdi]
mov eax, edx
cmp rdi, r8
jz short loc_1400
lea r9, [rdi+4]
cmp r8, r9
jz short loc_1400
mov r10, r8
mov rcx, r9
mov rsi, r9
sub r10, r9
and r10d, 4
jz short loc_13B0
mov ea... | long long func0(int **a1)
{
int *v1; // r8
int *v2; // rdi
int v3; // edx
int v4; // eax
int *v5; // r9
int *v6; // rcx
int *v7; // rsi
v1 = a1[1];
v2 = *a1;
v3 = *v2;
v4 = *v2;
if ( v2 != v1 )
{
v5 = v2 + 1;
if ( v1 != v2 + 1 )
{
v6 = v2 + 1;
v7 = v2 + 1;
if ( ... | func0:
ENDBR64
MOV R8,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RDI]
MOV EDX,dword ptr [RDI]
MOV EAX,EDX
CMP RDI,R8
JZ 0x00101400
LEA R9,[RDI + 0x4]
CMP R8,R9
JZ 0x00101400
MOV R10,R8
MOV RCX,R9
MOV RSI,R9
SUB R10,R9
AND R10D,0x4
JZ 0x001013b0
MOV EAX,dword ptr [R9]
LEA RSI,[RDI + 0x8]
CMP EDX,EAX
CMOVGE EAX,EDX
CMP RSI... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
int *piVar6;
int4 in_register_0000003c;
piVar1 = (int *)((int8 *)CONCAT44(in_register_0000003c,param_1))[1];
piVar2 = *(int **)CONCAT44(in_register_0000003c... |
1,903 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
| int func0(std::vector<int> nums) {
int sum = *max_element(nums.begin(), nums.end()) + *min_element(nums.begin(), nums.end());
return sum;
}
| int main() {
assert(func0({1,2,3}) == 4);
assert(func0({-1,2,3,4}) == 3);
assert(func0({2,3,6}) == 8);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov (%rdi),%rsi
mov 0x8(%rdi),%r11
mov (%rsi),%r10d
mov %r10d,%eax
cmp %r11,%rsi
je 1570 <_Z5func0St6vectorIiSaIiEE+0x1e0>
lea 0x4(%rsi),%r8
cmp %r8,%r11
je 1570 <_Z5func0St6vectorIiSaIiEE+0x1e0>
lea -0x8(%r11),%rax
push %rbx
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi]
mov r10, [rdi+8]
mov edi, [rcx]
mov eax, edi
cmp rcx, r10
jz loc_1550
lea r8, [rcx+4]
cmp r10, r8
jz loc_1550
lea r11, [r10-8]
push rbx
mov rax, rcx
sub r11, rcx
mov r9, r11
shr r9, 2
add r9, 1
cmp r11... | long long func0(unsigned int **a1)
{
unsigned int *v1; // rcx
unsigned int *v2; // r10
unsigned int v3; // edi
int *v4; // r8
unsigned int *v5; // rax
unsigned long long v6; // r11
unsigned long long v7; // r9
unsigned int *v8; // rdx
__m128i v9; // xmm0
__m128i v10; // xmm3
__m128i v11; // xmm1
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV R10,qword ptr [RDI + 0x8]
MOV EDI,dword ptr [RCX]
MOV EAX,EDI
CMP RCX,R10
JZ 0x00101550
LEA R8,[RCX + 0x4]
CMP R10,R8
JZ 0x00101550
LEA R11,[R10 + -0x8]
PUSH RBX
MOV RAX,RCX
SUB R11,RCX
MOV R9,R11
SHR R9,0x2
ADD R9,0x1
CMP R11,0x8
JBE 0x00101562
MOV RSI,R9
MOVD XMM5,EDI
MOV RD... | /* func0(std::vector<int, std::allocator<int> >) */
int func0(vector param_1)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint *puVar9;
uint *puVar10;
uint uVar11;
uint *puVar12;
int4 in_register_0000003c;
uint *puVar13;... |
1,904 | func0 |
#include <iostream>
#include <cassert>
#include <cctype>
#include <string>
| std::string func0(const std::string& string) {
std::string lowercased;
for (char ch : string) {
lowercased += std::tolower(ch);
}
return lowercased;
}
| int main() {
assert(func0("InValid") == "invalid");
assert(func0("TruE") == "true");
assert(func0("SenTenCE") == "sentence");
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
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq ... | _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
mov rax, [rbp+var_48]
mov rdi, rax
call __ZNSt7__cxx1112basic_st... | long long func0(long long a1, long long a2)
{
char v2; // al
char v4; // [rsp+1Fh] [rbp-31h]
long long v5; // [rsp+20h] [rbp-30h] BYREF
_QWORD v6[4]; // [rsp+28h] [rbp-28h] BYREF
v6[2] = __readfsqword(0x28u);
std::string::basic_string(a1);
v6[1] = a2;
v5 = std::string::begin(a2);
v6[0] = std::string... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001022c0
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x20],RAX
MO... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
int iVar2;
char *pcVar3;
long in_FS_OFFSET;
int8 local_38;
int8 local_30 [2];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::string(param_1);
local_38 = std::string::begin();
local_30[0] = st... |
1,905 | func0 |
#include <iostream>
#include <cassert>
#include <cctype>
#include <string>
| std::string func0(const std::string& string) {
std::string lowercased;
for (char ch : string) {
lowercased += std::tolower(ch);
}
return lowercased;
}
| int main() {
assert(func0("InValid") == "invalid");
assert(func0("TruE") == "true");
assert(func0("SenTenCE") == "sentence");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
lea 0x10(%rdi),%r15
mov %r15,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
mov (%rsi),%rbp
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbx, rdi
lea r15, [rdi+10h]
mov [rdi], r15
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rbp, [rsi]
mov rax, rbp
add ... | _QWORD * func0(_QWORD *a1, char **a2)
{
char *v2; // rbp
unsigned long long v4; // rax
char v5; // r13
long long v6; // r12
unsigned long long v7; // r14
char *v8; // [rsp+8h] [rbp-40h]
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v2 = *a2;
v8 = &(*a2)[(_QWORD)a2[1]];
if ( v8 != *a2 )
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA R15,[RDI + 0x10]
MOV qword ptr [RDI],R15
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RBP,qword ptr [RSI]
MOV RAX,RBP
ADD RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,RBP
JNZ 0x001012f... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong uVar1;
int iVar2;
char *pcVar3;
ulong uVar4;
char *pcVar5;
int8 *in_RSI;
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
pcVar5 = (char *)*in_RSI;
pcVar3 = pcVar5 + in_RSI[1]... |
1,906 | func0 |
#include <iostream>
#include <cassert>
#include <cctype>
#include <string>
| std::string func0(const std::string& string) {
std::string lowercased;
for (char ch : string) {
lowercased += std::tolower(ch);
}
return lowercased;
}
| int main() {
assert(func0("InValid") == "invalid");
assert(func0("TruE") == "true");
assert(func0("SenTenCE") == "sentence");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movb $0x0,0x10(%rdi)
mov %r15,(%rdi)
mov (%rsi),%rbx
movq $0x0,0x8(%rdi)
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea r15, [rdi+10h]
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov byte ptr [rdi+10h], 0
mov [rdi], r15
mov rbp, [rsi]
mov qword ptr [rdi+8], 0
mov rax, [rsi+8]
m... | long long * func0(long long *a1, char **a2)
{
long long *v2; // r15
char *v3; // rbp
long long v4; // r14
long long v5; // rax
unsigned long long v6; // r12
char v7; // r13
unsigned long long v8; // rax
char *v10; // [rsp+0h] [rbp-48h]
v2 = a1 + 2;
*((_BYTE *)a1 + 16) = 0;
*a1 = (long long)(a1 + ... | func0:
ENDBR64
PUSH R15
LEA R15,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],R15
MOV RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],R15
ADD RAX,RBP
MOV qword ptr [RSP],RAX
C... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
ulong uVar2;
int iVar3;
char *pcVar4;
ulong uVar5;
char *pcVar6;
int8 *in_RSI;
ulong uVar7;
string *psVar8;
psVar1 = param_1 + 0x10;
param_1[0x10] = (string)0x0;
*(string **)param_1 = psVar1;
pcVar6 = (char ... |
1,907 | func0 |
#include <iostream>
#include <cassert>
#include <cctype>
#include <string>
| std::string func0(const std::string& string) {
std::string lowercased;
for (char ch : string) {
lowercased += std::tolower(ch);
}
return lowercased;
}
| int main() {
assert(func0("InValid") == "invalid");
assert(func0("TruE") == "true");
assert(func0("SenTenCE") == "sentence");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
lea 0x10(%rdi),%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
movb $0x0,0x10(%rdi)
mov %r15,(%rdi)
mov (%rsi),%rbx
movq $0x0,0x8(%rdi)
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
lea r15, [rdi+10h]
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
mov byte ptr [rdi+10h], 0
mov [rdi], r15
mov rbp, [rsi]
mov qword ptr [rdi+8], 0
mov rax, [rsi+8]
m... | long long * func0(long long *a1, char **a2)
{
long long *v2; // r15
char *v3; // rbp
long long v4; // r14
long long v5; // rax
unsigned long long v6; // r12
char v7; // r13
unsigned long long v8; // rax
char *v10; // [rsp+0h] [rbp-48h]
v2 = a1 + 2;
*((_BYTE *)a1 + 16) = 0;
*a1 = (long long)(a1 + ... | func0:
ENDBR64
PUSH R15
LEA R15,[RDI + 0x10]
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
MOV byte ptr [RDI + 0x10],0x0
MOV qword ptr [RDI],R15
MOV RBP,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],0x0
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],R15
ADD RAX,RBP
MOV qword ptr [RSP],RAX
C... | /* func0(std::string const&) */
string * func0(string *param_1)
{
string *psVar1;
ulong uVar2;
int iVar3;
char *pcVar4;
ulong uVar5;
char *pcVar6;
int8 *in_RSI;
ulong uVar7;
string *psVar8;
psVar1 = param_1 + 0x10;
param_1[0x10] = (string)0x0;
*(string **)param_1 = psVar1;
pcVar6 = (char ... |
1,908 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(std::string str1) {
std::regex lower_case("[a-z]");
std::string result = std::regex_replace(str1, lower_case, "");
return result;
}
| int main() {
assert(func0("PYTHon") == "PYTH");
assert(func0("FInD") == "FID");
assert(func0("STRinG") == "STRG");
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 $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 0x2d3c... | _Z5func0NSt7__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, aAZ; "[a-z]"
mov ... | 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, "[a-z]", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits<c... | 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 ... | /* func0(std::string) */
int8 func0(int8 param_1,int8 param_2)
{
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex(local_48,"[a-z]",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchHandler @ 00104ba8 ... |
1,909 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(std::string str1) {
std::regex lower_case("[a-z]");
std::string result = std::regex_replace(str1, lower_case, "");
return result;
}
| int main() {
assert(func0("PYTHon") == "PYTH");
assert(func0("FInD") == "FID");
assert(func0("STRinG") == "STRG");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $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 <_ZNSt6local... | _Z5func0NSt7__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 __ZNS... | 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... | 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,[0x... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
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;
... |
1,910 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(std::string str1) {
std::regex lower_case("[a-z]");
std::string result = std::regex_replace(str1, lower_case, "");
return result;
}
| int main() {
assert(func0("PYTHon") == "PYTH");
assert(func0("FInD") == "FID");
assert(func0("STRinG") == "STRG");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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 ... | _Z5func0NSt7__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
x... | 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+10... | 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,[0x11a5e4]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int iVar3;
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_... |
1,911 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(std::string str1) {
std::regex lower_case("[a-z]");
std::string result = std::regex_replace(str1, lower_case, "");
return result;
}
| int main() {
assert(func0("PYTHon") == "PYTH");
assert(func0("FInD") == "FID");
assert(func0("STRinG") == "STRG");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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 ... | _Z5func0NSt7__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+va... | _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; //... | 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 0x... | /* func0(std::string) */
long * func0(long *param_1,long *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int uVar2;
int *puVar3;
long lVar4;
int8 uVar5;
bool bVar6;
char cVar7;
int iVar8;
int8 *puVar9;
long lVar10;
long *plVar11;
ulong uVar12;
ulong uVar13;
long lVar14;
int *puVar... |
1,912 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n /= 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
cmpl $0x9,-0x4(%rbp)
jle 11ba <_Z5func0i+0x31>
mov -0x4(%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,-0x4(%rbp)
jmp 1194 <_Z5f... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
jmp short loc_1174
loc_1156:
mov eax, [rbp+var_4]
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_4], eax
loc_1174:
cmp [rbp+var_4], 9
jg ... | long long func0(int a1)
{
while ( a1 > 9 )
a1 /= 10;
return (unsigned int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
JMP 0x00101174
LAB_00101156:
MOV EAX,dword ptr [RBP + -0x4]
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 + -0x4],EAX
LAB_00101174:
CMP dword ptr [RBP + -0x4],0x9
JG 0x00101156... | /* func0(int) */
int func0(int param_1)
{
int4 local_c;
for (local_c = param_1; 9 < local_c; local_c = local_c / 10) {
}
return local_c;
} |
1,913 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n /= 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O1 | cpp | func0(int):
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 1190 <_Z5func0i+0x27>
mov %eax,%ecx
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
sar $0x22,%rdx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
cmp $0x63,%ecx
jg 1174 <_Z5func0i+0xb>
retq
| _Z5func0i:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1152
loc_1134:
mov ecx, eax
movsxd rdx, eax
imul rdx, 66666667h
sar rdx, 22h
sar eax, 1Fh
mov esi, eax
mov eax, edx
sub eax, esi
cmp ecx, 63h ; 'c'
jg short loc_1134
locret_1152:
retn | long long func0(int a1)
{
long long result; // rax
int v2; // ecx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)((int)result / 10);
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101152
LAB_00101134:
MOV ECX,EAX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SAR RDX,0x22
SAR EAX,0x1f
MOV ESI,EAX
MOV EAX,EDX
SUB EAX,ESI
CMP ECX,0x63
JG 0x00101134
LAB_00101152:
RET | /* func0(int) */
void func0(int param_1)
{
bool bVar1;
if (9 < param_1) {
do {
bVar1 = 99 < param_1;
param_1 = param_1 / 10;
} while (bVar1);
}
return;
} |
1,914 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n /= 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 11e2 <_Z5func0i+0x22>
mov $0xcccccccd,%ecx
mov %eax,%eax
mov %rax,%rdx
imul %rcx,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 11d0 <_Z5func0i+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1162
mov ecx, 0CCCCCCCDh
loc_1150:
mov eax, eax
mov rdx, rax
imul rax, rcx
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_1150
locret_1162:
retn | unsigned long long func0(int a1)
{
unsigned long long result; // rax
int v2; // edx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)result / 0xAuLL;
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101162
MOV ECX,0xcccccccd
LAB_00101150:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RCX
SHR RAX,0x23
CMP EDX,0x63
JG 0x00101150
LAB_00101162:
RET | /* func0(int) */
void func0(int param_1)
{
ulong uVar1;
int iVar2;
uVar1 = (ulong)(uint)param_1;
if (9 < param_1) {
do {
iVar2 = (int)uVar1;
uVar1 = uVar1 / 10;
} while (99 < iVar2);
}
return;
} |
1,915 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
while (n >= 10) {
n /= 10;
}
return n;
}
| int main() {
assert(func0(123) == 1);
assert(func0(456) == 4);
assert(func0(12) == 1);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%eax
cmp $0x9,%edi
jle 11e2 <_Z5func0i+0x22>
mov $0xcccccccd,%ecx
mov %eax,%eax
mov %rax,%rdx
imul %rcx,%rax
shr $0x23,%rax
cmp $0x63,%edx
jg 11d0 <_Z5func0i+0x10>
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0i:
endbr64
mov eax, edi
cmp edi, 9
jle short locret_1162
mov ecx, 0CCCCCCCDh
loc_1150:
mov eax, eax
mov rdx, rax
imul rax, rcx
shr rax, 23h
cmp edx, 63h ; 'c'
jg short loc_1150
locret_1162:
retn | unsigned long long func0(int a1)
{
unsigned long long result; // rax
int v2; // edx
result = (unsigned int)a1;
if ( a1 > 9 )
{
do
{
v2 = result;
result = (unsigned int)result / 0xAuLL;
}
while ( v2 > 99 );
}
return result;
} | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,0x9
JLE 0x00101162
MOV ECX,0xcccccccd
LAB_00101150:
MOV EAX,EAX
MOV RDX,RAX
IMUL RAX,RCX
SHR RAX,0x23
CMP EDX,0x63
JG 0x00101150
LAB_00101162:
RET | /* func0(int) */
void func0(int param_1)
{
ulong uVar1;
int iVar2;
uVar1 = (ulong)(uint)param_1;
if (9 < param_1) {
do {
iVar2 = (int)uVar1;
uVar1 = uVar1 / 10;
} while (99 < iVar2);
}
return;
} |
1,916 | func0 |
#include <iostream>
#include <assert.h>
#include <string>
#include <vector>
| char func0(const std::string& str1) {
const int ASCII_SIZE = 256;
std::vector<int> ctr(ASCII_SIZE, 0);
int max = -1;
char ch = '\0';
for (char i : str1) {
ctr[static_cast<int>(i)]++;
}
for (char i : str1) {
if (max < ctr[static_cast<int>(i)]) {
... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
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 $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x100,-0x54(%rbp)
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_5C], 100h
lea rax, [rbp+var_58]
mov [rbp+var_38], rax
nop
nop
mov dword ... | long long func0(long long a1)
{
_DWORD *v1; // rax
unsigned __int8 v3; // [rsp+1Dh] [rbp-63h]
unsigned __int8 v4; // [rsp+1Eh] [rbp-62h]
char v5; // [rsp+1Fh] [rbp-61h]
int v6; // [rsp+20h] [rbp-60h]
long long v7; // [rsp+28h] [rbp-58h] BYREF
long long v8; // [rsp+30h] [rbp-50h] BYREF
long long v9; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x5c],0x100
LEA RAX,[RBP + -0x58]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x50],0x0
LEA RCX,[RBP + -0x58]
LEA RDX,... | /* func0(std::string const&) */
char func0(string *param_1)
{
char cVar1;
bool bVar2;
char *pcVar3;
int *piVar4;
long in_FS_OFFSET;
char local_6b;
int local_68;
int8 local_60;
ulong local_58;
string *local_50;
string *local_48;
int8 *local_40;
vector<int,std::allocator<int>> local_38 [24];
... |
1,917 | func0 |
#include <iostream>
#include <assert.h>
#include <string>
#include <vector>
| char func0(const std::string& str1) {
const int ASCII_SIZE = 256;
std::vector<int> ctr(ASCII_SIZE, 0);
int max = -1;
char ch = '\0';
for (char i : str1) {
ctr[static_cast<int>(i)]++;
}
for (char i : str1) {
if (max < ctr[static_cast<int>(i)]) {
... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbx
mov %rdi,%rbx
mov $0x400,%edi
callq 1130 <_Znwm@plt>
mov %rax,%rdi
lea 0x400(%rax),%rax
mov %rdi,%rdx
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %rdx,%rax
jne 1288 <_Z5func0RKNSt7__cxx11... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
mov rbx, rdi
mov edi, 400h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea rdx, [rax+400h]
loc_1285:
mov dword ptr [rax], 0
add rax, 4
cmp rax, rdx
jnz short loc_1285
mov ... | long long func0(char **a1)
{
_DWORD *v2; // rax
_DWORD *v3; // rdi
_DWORD *v4; // rdx
char *v5; // rax
char *v6; // r8
char *v7; // rdx
unsigned __int8 *v8; // rsi
unsigned int v9; // ebx
int v10; // r8d
v2 = (_DWORD *)operator new(0x400uLL);
v3 = v2;
v4 = v2 + 256;
do
*v2++ = 0;
while... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV EDI,0x400
CALL 0x00101120
MOV RDI,RAX
LEA RDX,[RAX + 0x400]
LAB_00101285:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x00101285
MOV RAX,qword ptr [RBX]
MOV R8,RAX
ADD R8,qword ptr [RBX + 0x8]
CMP RAX,R8
JZ 0x001012e9
MOV RDX,RAX
LAB_001012a6:
MOVSX RCX,byte ptr [RAX]
ADD... | /* func0(std::string const&) */
char func0(string *param_1)
{
long lVar1;
char *pcVar2;
int4 *puVar3;
int4 *puVar4;
char *pcVar5;
char *pcVar6;
char cVar7;
int iVar8;
bool bVar9;
puVar3 = (int4 *)operator_new(0x400);
puVar4 = puVar3;
do {
*puVar4 = 0;
puVar4 = puVar4 + 1;
} while ... |
1,918 | func0 |
#include <iostream>
#include <assert.h>
#include <string>
#include <vector>
| char func0(const std::string& str1) {
const int ASCII_SIZE = 256;
std::vector<int> ctr(ASCII_SIZE, 0);
int max = -1;
char ch = '\0';
for (char i : str1) {
ctr[static_cast<int>(i)]++;
}
for (char i : str1) {
if (max < ctr[static_cast<int>(i)]) {
... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r12
mov %rdi,%r12
mov $0x400,%edi
callq 1150 <_Znwm@plt>
mov %rax,%rdi
lea 0x400(%rax),%rax
mov %rdi,%rdx
movl $0x0,(%rdx)
add $0x4,%rdx
cmp %rdx,%rax
jne 1480 <_Z5func0RKNSt7__cxx11... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
mov rbx, rdi
mov edi, 400h; unsigned __int64
call __Znwm; operator new(ulong)
lea rdi, [rax+8]
mov rcx, rax
mov qword ptr [rax], 0
mov r8, rax
mov qword ptr [rax+3F8h], 0
and rdi, 0FFFFFFFFFFFFFFF8h
xo... | long long func0(char **a1)
{
_QWORD *v1; // rax
_DWORD *v2; // r8
char *v3; // rax
char *v4; // rsi
char *v5; // rdx
long long v6; // rcx
unsigned int v7; // ebx
int v8; // edi
long long v9; // rcx
v1 = (_QWORD *)operator new(0x400uLL);
*v1 = 0LL;
v2 = v1;
v1[127] = 0LL;
memset(
(void ... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV EDI,0x400
CALL 0x00101120
LEA RDI,[RAX + 0x8]
MOV RCX,RAX
MOV qword ptr [RAX],0x0
MOV R8,RAX
MOV qword ptr [RAX + 0x3f8],0x0
AND RDI,-0x8
XOR EAX,EAX
SUB RCX,RDI
ADD ECX,0x400
SHR ECX,0x3
STOSQ.REP RDI
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
ADD RSI,RAX
CMP RAX,RSI
... | /* func0(std::string const&) */
int func0(string *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
char *pcVar4;
int iVar5;
ulong uVar6;
char *pcVar7;
char *pcVar8;
char *pcVar9;
int iVar10;
int8 *puVar11;
byte bVar12;
bVar12 = 0;
puVar3 = (int8 *)operator_new(0x400);
*puVar3 = 0;
p... |
1,919 | func0 |
#include <iostream>
#include <assert.h>
#include <string>
#include <vector>
| char func0(const std::string& str1) {
const int ASCII_SIZE = 256;
std::vector<int> ctr(ASCII_SIZE, 0);
int max = -1;
char ch = '\0';
for (char i : str1) {
ctr[static_cast<int>(i)]++;
}
for (char i : str1) {
if (max < ctr[static_cast<int>(i)]) {
... | int main() {
assert(func0("data") == 'a');
assert(func0("create") == 'e');
assert(func0("brilliant girl") == 'i');
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r12
mov %rdi,%r12
mov $0x400,%edi
callq 1150 <_Znwm@plt>
lea 0x8(%rax),%rdi
mov %rax,%rcx
movq $0x0,(%rax)
mov %rax,%r8
movq $0x0,0x3f8(%rax)
and $0xfffffffffffffff8,%rdi
xor %eax,%ea... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbx
mov rbx, rdi
mov edi, 400h; unsigned __int64
call __Znwm; operator new(ulong)
lea rdi, [rax+8]
mov rcx, rax
mov qword ptr [rax], 0
mov r8, rax
mov qword ptr [rax+3F8h], 0
and rdi, 0FFFFFFFFFFFFFFF8h
xo... | long long func0(char **a1)
{
_QWORD *v1; // rax
_DWORD *v2; // r8
char *v3; // rax
char *v4; // rsi
char *v5; // rdx
long long v6; // rcx
unsigned int v7; // ebx
int v8; // edi
long long v9; // rcx
v1 = (_QWORD *)operator new(0x400uLL);
*v1 = 0LL;
v2 = v1;
v1[127] = 0LL;
memset(
(void ... | func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV EDI,0x400
CALL 0x00101120
LEA RDI,[RAX + 0x8]
MOV RCX,RAX
MOV qword ptr [RAX],0x0
MOV R8,RAX
MOV qword ptr [RAX + 0x3f8],0x0
AND RDI,-0x8
XOR EAX,EAX
SUB RCX,RDI
ADD ECX,0x400
SHR ECX,0x3
STOSQ.REP RDI
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RBX + 0x8]
ADD RSI,RAX
CMP RAX,RSI
... | /* func0(std::string const&) */
int func0(string *param_1)
{
int *piVar1;
int iVar2;
int8 *puVar3;
char *pcVar4;
int iVar5;
ulong uVar6;
char *pcVar7;
char *pcVar8;
char *pcVar9;
int iVar10;
int8 *puVar11;
byte bVar12;
bVar12 = 0;
puVar3 = (int8 *)operator_new(0x400);
*puVar3 = 0;
p... |
1,920 | func0 |
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& set, int n, int sum) {
if (sum == 0) {
return true;
}
if (n == 0) {
return false;
}
if (set[n - 1] > sum) {
return func0(set, n - 1, sum);
}
return func0(set, n-1, sum) || func0(set, n-1, sum-set[n-1]);
}
| int main() {
std::vector<int> set = {3, 34, 4, 12, 5, 2};
assert(func0(set, 6, 9) == true);
assert(func0(set, 6, 30) == false);
assert(func0(set, 6, 15) == true);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
mov %edx,-0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jne 124f <_Z5func0RKSt6vectorIiSaIiEEii+0x26>
mov $0x1,%eax
jmpq 12fb <_Z5func0RKSt6vectorIiSaIiEEi... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
cmp [rbp+var_10], 0
jnz short loc_126F
mov eax, 1
jmp locret_131B
loc_126F:
cmp [rbp+var_C], 0
jnz short loc_127F
mov eax, 0
jmp ... | long long func0(long long a1, int a2, unsigned int a3)
{
_DWORD *v4; // rax
if ( !a3 )
return 1LL;
if ( !a2 )
return 0LL;
if ( (signed int)a3 < *(_DWORD *)std::vector<int>::operator[](a1, a2 - 1) )
return func0(a1, (unsigned int)(a2 - 1), a3);
if ( (unsigned __int8)func0(a1, (unsigned int)(a2 - ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0010126f
MOV EAX,0x1
JMP 0x0010131b
LAB_0010126f:
CMP dword ptr [RBP + -0xc],0x0
JNZ 0x0010127f
MOV EAX,0x0
JMP 0x0010131b
LAB_0010127f:
MO... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int8 func0(vector *param_1,int param_2,int param_3)
{
char cVar1;
int8 uVar2;
int *piVar3;
if (param_3 == 0) {
uVar2 = 1;
}
else if (param_2 == 0) {
uVar2 = 0;
}
else {
piVar3 = (int *)std::vector<int,std::allocator<in... |
1,921 | func0 |
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& set, int n, int sum) {
if (sum == 0) {
return true;
}
if (n == 0) {
return false;
}
if (set[n - 1] > sum) {
return func0(set, n - 1, sum);
}
return func0(set, n-1, sum) || func0(set, n-1, sum-set[n-1]);
}
| int main() {
std::vector<int> set = {3, 34, 4, 12, 5, 2};
assert(func0(set, 6, 9) == true);
assert(func0(set, 6, 30) == false);
assert(func0(set, 6, 15) == true);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
mov $0x1,%eax
test %edx,%edx
je 1216 <_Z5func0RKSt6vectorIiSaIiEEii+0x6d>
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %edx,%r12d
mov $0x0,%eax
test %esi,%esi
je 11eb <_Z5func0RKSt6vecto... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
mov eax, 1
test edx, edx
jz short locret_1216
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r12d, edx
mov eax, 0
test esi, esi
jz short loc_11EB
lea ebx, [rsi-1]
movsxd rdx, ebx
mov rax, [rdi]
mov r13d,... | long long func0(_QWORD *a1, int a2, unsigned int a3)
{
long long result; // rax
unsigned int v5; // ebx
int v6; // r13d
result = 1LL;
if ( a3 )
{
result = 0LL;
if ( a2 )
{
v5 = a2 - 1;
v6 = *(_DWORD *)(*a1 + 4LL * (a2 - 1));
if ( v6 <= (int)a3 )
{
result = func0... | func0:
ENDBR64
MOV EAX,0x1
TEST EDX,EDX
JZ 0x00101216
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R12D,EDX
MOV EAX,0x0
TEST ESI,ESI
JZ 0x001011eb
LEA EBX,[RSI + -0x1]
MOVSXD RDX,EBX
MOV RAX,qword ptr [RDI]
MOV R13D,dword ptr [RAX + RDX*0x4]
CMP R13D,R12D
JLE 0x001011f6
MOV EDX,R12D
MOV ESI,EBX
CALL ... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int8 func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int8 uVar2;
int iVar3;
if (param_3 != 0) {
uVar2 = 0;
if (param_2 != 0) {
iVar3 = param_2 + -1;
iVar1 = *(int *)(*(long *)param_1 + (long)iVar3 * 4);
... |
1,922 | func0 |
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& set, int n, int sum) {
if (sum == 0) {
return true;
}
if (n == 0) {
return false;
}
if (set[n - 1] > sum) {
return func0(set, n - 1, sum);
}
return func0(set, n-1, sum) || func0(set, n-1, sum-set[n-1]);
}
| int main() {
std::vector<int> set = {3, 34, 4, 12, 5, 2};
assert(func0(set, 6, 9) == true);
assert(func0(set, 6, 30) == false);
assert(func0(set, 6, 15) == true);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r13
mov %rdi,%r13
push %r12
push %rbp
mov %edx,%ebp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
movslq %ebx,%rax
lea -0x4(,%rax,4),%rax
jmp 1330 <_Z5func0RKSt6vectorIiSaIiEEii+0x40>
nopw 0x0(%rax,%rax,1)
test %ebx,%ebx... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r13
mov r13, rdi
push r12
mov r12d, edx
push rbp
push rbx
mov ebx, esi
movsxd rax, ebx
lea rax, ds:0FFFFFFFFFFFFFFFCh[rax*4]
sub rsp, 8
test r12d, r12d
jnz short loc_1313
jmp short loc_134C
loc_1300:
mov rcx, [r13+0]
sub ebx... | long long func0(_QWORD *a1, unsigned int a2, unsigned int a3)
{
unsigned int v3; // r12d
unsigned int v4; // ebx
long long v5; // rax
int v6; // ebp
long long result; // rax
v3 = a3;
v4 = a2;
v5 = 4LL * (int)a2 - 4;
if ( !a3 )
return 1LL;
while ( v4 )
{
--v4;
v6 = *(_DWORD *)(*a1 + v... | func0:
ENDBR64
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12D,EDX
PUSH RBP
PUSH RBX
MOV EBX,ESI
MOVSXD RAX,EBX
LEA RAX,[-0x4 + RAX*0x4]
SUB RSP,0x8
TEST R12D,R12D
JNZ 0x00101313
JMP 0x0010134c
LAB_00101300:
MOV RCX,qword ptr [R13]
SUB EBX,0x1
MOV EBP,dword ptr [RCX + RAX*0x1]
SUB RAX,0x4
CMP EBP,R12D
JLE 0x00101328
LAB_0010131... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int8 func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
long lVar2;
int8 uVar3;
lVar2 = (long)param_2 * 4 + -4;
if (param_3 != 0) {
do {
do {
if (param_2 == 0) {
return 0;
}
param_2 =... |
1,923 | func0 |
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& set, int n, int sum) {
if (sum == 0) {
return true;
}
if (n == 0) {
return false;
}
if (set[n - 1] > sum) {
return func0(set, n - 1, sum);
}
return func0(set, n-1, sum) || func0(set, n-1, sum-set[n-1]);
}
| int main() {
std::vector<int> set = {3, 34, 4, 12, 5, 2};
assert(func0(set, 6, 9) == true);
assert(func0(set, 6, 30) == false);
assert(func0(set, 6, 15) == true);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int, int):
endbr64
push %r13
mov %rdi,%r13
push %r12
mov %edx,%r12d
push %rbp
push %rbx
mov %esi,%ebx
sub $0x8,%rsp
test %r12d,%r12d
je 134e <_Z5func0RKSt6vectorIiSaIiEEii+0x6e>
movslq %ebx,%rax
lea -0x4(,%rax,4),%rax
jmp 1323 <_Z5func... | _Z5func0RKSt6vectorIiSaIiEEii:
endbr64
push r15
push r14
push r13
push r12
mov r12d, edx
push rbp
push rbx
sub rsp, 28h
loc_12E5:
test r12d, r12d
jz loc_13EA
movsxd rax, esi
lea rax, ds:0FFFFFFFFFFFFFFFCh[rax*4]
jmp short loc_1316
loc_1300:
mov rbp, [rdi]
lea edx, [rsi... | long long func0(long long *a1, int a2, signed int a3)
{
long long v4; // rax
long long v5; // rbp
int v6; // r13d
long long result; // rax
long long v8; // rbx
long long v9; // r15
long long i; // rax
int v11; // ecx
unsigned int v12; // r12d
int v13; // r13d
unsigned int v14; // r14d
long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDX
PUSH RBP
PUSH RBX
SUB RSP,0x28
LAB_001012e5:
TEST R12D,R12D
JZ 0x001013ea
MOVSXD RAX,ESI
LEA RAX,[-0x4 + RAX*0x4]
JMP 0x00101316
LAB_00101300:
MOV RBP,qword ptr [RDI]
LEA EDX,[RSI + -0x1]
MOV R13D,dword ptr [RBP + RAX*0x1]
SUB RAX,0x4
CMP R12D,R13D
JGE 0x0... | /* func0(std::vector<int, std::allocator<int> > const&, int, int) */
int8 func0(vector *param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
long lVar3;
ulong uVar4;
int iVar5;
long lVar6;
ulong uVar7;
int8 uVar8;
uint uVar9;
long lVar10;
int iVar11;
ulong uVar12;
do {
if (param_3... |
1,924 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string &text) {
std::regex pattern("[A-Z]+[a-z]+$");
if (std::regex_search(text, pattern)) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
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 ... | _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, aAZAZ; "[A-Z]+[a-z]... | 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_trait... | 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 + -0x... | /* 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,"[A-Z]+[... |
1,925 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string &text) {
std::regex pattern("[A-Z]+[a-z]+$");
if (std::regex_search(text, pattern)) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
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 <_ZN... | _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 __Z... | 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,[0x... | /* 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> *lo... | |
1,926 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string &text) {
std::regex pattern("[A-Z]+[a-z]+$");
if (std::regex_search(text, pattern)) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
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... | _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... | long long func0(long long a1, long long *a2)
{
long long v3; // rdi
long long v4; // rsi
char v5; // r13
long long v6; // rsi
long long v7; // rdi
long long v8; // rdx
volatile signed __int32 *v9; // rcx
signed __int32 v10; // eax
long long v12; // rax
long long v13; // [rsp-8h] [rbp-78h]
_BYTE v... | 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,[0x11860c]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* 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;
lo... |
1,927 | func0 |
#include <iostream>
#include <regex>
#include <assert.h>
| std::string func0(const std::string &text) {
std::regex pattern("[A-Z]+[a-z]+$");
if (std::regex_search(text, pattern)) {
return "Yes";
} else {
return "No";
}
}
| int main() {
assert(func0("Geeks") == "Yes");
assert(func0("geeksforGeeks") == "Yes");
assert(func0("geeks") == "No");
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... | _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
c... | 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... | 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,[0x11a651]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* 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 _V... |
1,928 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; ++i) {
fact *= i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
movl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 11d3 <_Z5func0i+0x4a>
mov -0x4(%rbp),%eax
imul -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
idivl... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
mov [rbp+var_4], 1
mov [rbp+var_8], 1
jmp short loc_118B
loc_116B:
mov eax, [rbp+var_4]
imul eax, [rbp+var_8]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_14]
mov eax, edx
te... | long long func0(int a1)
{
int i; // [rsp+Ch] [rbp-8h]
int v3; // [rsp+10h] [rbp-4h]
v3 = 1;
for ( i = 1; i < a1; ++i )
{
v3 *= i;
if ( !(v3 % a1) )
return (unsigned int)i;
}
return (unsigned int)(i - 1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010118b
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
CDQ
I... | /* func0(int) */
int func0(int param_1)
{
int local_10;
int local_c;
local_c = 1;
local_10 = 1;
while( true ) {
if (param_1 <= local_10) {
return local_10 + -1;
}
local_c = local_c * local_10;
if (local_c % param_1 == 0) break;
local_10 = local_10 + 1;
}
return local_10;
} |
1,929 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; ++i) {
fact *= i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O1 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 11b7 <_Z5func0i+0x2e>
mov $0x1,%eax
cltd
idiv %edi
mov %edx,%esi
test %edx,%edx
je 11c2 <_Z5func0i+0x39>
mov %edx,%ecx
add $0x1,%esi
cmp %esi,%edi
je 11bc <_Z5func0i+0x33>
imul %esi,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
jne 11... | _Z5func0i:
endbr64
cmp edi, 1
jle short loc_117B
mov eax, 1
mov edx, 0
idiv edi
mov esi, edx
test edx, edx
jz short loc_1186
mov ecx, edx
loc_1166:
add esi, 1
cmp edi, esi
jz short loc_1180
imul ecx, esi
mov eax, ecx
cdq
idiv edi
test edx, edx
jnz short l... | long long func0(int a1)
{
unsigned int v1; // esi
int v2; // ecx
if ( a1 <= 1 )
{
a1 = 1;
}
else
{
v1 = 1 % a1;
if ( !(1 % a1) )
return 1;
v2 = 1 % a1;
while ( a1 != ++v1 )
{
v2 *= v1;
if ( !(v2 % a1) )
return v1;
}
}
return (unsigned int)(a1 - 1... | func0:
ENDBR64
CMP EDI,0x1
JLE 0x0010117b
MOV EAX,0x1
MOV EDX,0x0
IDIV EDI
MOV ESI,EDX
TEST EDX,EDX
JZ 0x00101186
MOV ECX,EDX
LAB_00101166:
ADD ESI,0x1
CMP EDI,ESI
JZ 0x00101180
IMUL ECX,ESI
MOV EAX,ECX
CDQ
IDIV EDI
TEST EDX,EDX
JNZ 0x00101166
JMP 0x00101183
LAB_0010117b:
MOV EDI,0x1
LAB_00101180:
LEA ESI,[RDI + -0x1]
... | /* func0(int) */
ulong func0(int param_1)
{
ulong uVar1;
uint uVar2;
ulong uVar3;
if (param_1 < 2) {
param_1 = 1;
LAB_00101180:
uVar3 = (ulong)(param_1 - 1);
}
else {
uVar1 = 1 % (long)param_1;
uVar3 = uVar1 & 0xffffffff;
if ((int)uVar1 == 0) {
uVar3 = 1;
}
else {
... |
1,930 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; ++i) {
fact *= i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 12d0 <_Z5func0i+0x40>
mov $0x1,%ecx
mov $0x1,%r8d
jmp 12bd <_Z5func0i+0x2d>
nopw %cs:0x0(%rax,%rax,1)
imul %r8d,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 12cc <_Z5func0i+0x3c>
mov %r8d,%eax
add $0x1,%r8d
cmp %r8d,%edi
jne 12b0 <_Z... | _Z5func0i:
endbr64
mov esi, 1
mov ecx, 1
xor eax, eax
cmp edi, 1
jg short loc_124C
jmp short loc_1255
loc_1240:
imul esi, ecx
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_1257
loc_124C:
mov eax, ecx
add ecx, 1
cmp edi, ecx
jnz short loc_1240
loc_1255:
m... | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // ecx
unsigned int v3; // eax
v1 = 1;
v2 = 1;
v3 = 0;
if ( a1 > 1 )
{
while ( 1 )
{
v3 = v2++;
if ( a1 == v2 )
break;
v1 *= v2;
if ( !(v1 % a1) )
return v2;
}
}
return v3;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
XOR EAX,EAX
CMP EDI,0x1
JG 0x0010124c
JMP 0x00101255
LAB_00101240:
IMUL ESI,ECX
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x00101257
LAB_0010124c:
MOV EAX,ECX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101240
LAB_00101255:
MOV ECX,EAX
LAB_00101257:
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar2 = 0;
iVar1 = 1;
if (1 < param_1) {
do {
iVar2 = iVar1 + 1;
if (param_1 == iVar2) {
return iVar1;
}
iVar3 = iVar3 * iVar2;
iVar1 = iVar2;
} while (iVar3 % param_1 !... |
1,931 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int x) {
int i = 1;
int fact = 1;
for (i = 1; i < x; ++i) {
fact *= i;
if (fact % x == 0) {
return i;
}
}
return i - 1;
}
| int main() {
assert(func0(10) == 5);
assert(func0(15) == 5);
assert(func0(5) == 4);
return 0;
}
| O3 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 1200 <_Z5func0i+0x40>
mov $0x1,%ecx
mov $0x1,%r8d
jmp 11ed <_Z5func0i+0x2d>
nopw %cs:0x0(%rax,%rax,1)
imul %r8d,%ecx
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 11fc <_Z5func0i+0x3c>
mov %r8d,%eax
add $0x1,%r8d
cmp %r8d,%edi
jne 11e0 <_Z... | _Z5func0i:
endbr64
mov esi, 1
mov ecx, 1
xor eax, eax
cmp edi, 1
jg short loc_116C
jmp short loc_1175
loc_1160:
imul esi, ecx
mov eax, esi
cdq
idiv edi
test edx, edx
jz short loc_1177
loc_116C:
mov eax, ecx
add ecx, 1
cmp edi, ecx
jnz short loc_1160
loc_1175:
m... | long long func0(int a1)
{
int v1; // esi
unsigned int v2; // ecx
unsigned int v3; // eax
v1 = 1;
v2 = 1;
v3 = 0;
if ( a1 > 1 )
{
while ( 1 )
{
v3 = v2++;
if ( a1 == v2 )
break;
v1 *= v2;
if ( !(v1 % a1) )
return v2;
}
}
return v3;
} | func0:
ENDBR64
MOV ESI,0x1
MOV ECX,0x1
XOR EAX,EAX
CMP EDI,0x1
JG 0x0010116c
JMP 0x00101175
LAB_00101160:
IMUL ESI,ECX
MOV EAX,ESI
CDQ
IDIV EDI
TEST EDX,EDX
JZ 0x00101177
LAB_0010116c:
MOV EAX,ECX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101160
LAB_00101175:
MOV ECX,EAX
LAB_00101177:
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = 1;
iVar2 = 0;
iVar1 = 1;
if (1 < param_1) {
do {
iVar2 = iVar1 + 1;
if (param_1 == iVar2) {
return iVar1;
}
iVar3 = iVar3 * iVar2;
iVar1 = iVar2;
} while (iVar3 % param_1 !... |
1,932 | func0 | #include <iostream>
#include <vector>
#include <cassert>
| std::vector<std::pair<std::string, std::string>> func0(
const std::vector<std::pair<std::string, std::string>>& test_list1,
const std::vector<std::pair<std::string, std::string>>& test_list2) {
std::vector<std::pair<std::string, std::string>> res;
for (const auto& sub : test_list1) {
... | int main() {
assert((func0({{"Hello", "dude"}, {"How", "are"}, {"you", "?"}}, {{"Hello", "dude"}, {"How", "are"}}) == std::vector<std::pair<std::string, std::string>>{{"you", "?"}}));
assert((func0({{"Part", "of"}, {"the", "journey"}, {"is ", "end"}}, {{"Journey", "the"}, {"is", "end"}}) == std::vector<std::p... | O0 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EESB_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_68], rdi
mov [rbp+var_70], rsi
mov [rbp+var_78], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rb... | long long func0(long long a1, long long a2, long long a3)
{
char v5; // [rsp+27h] [rbp-59h]
long long v6; // [rsp+28h] [rbp-58h] BYREF
long long v7; // [rsp+30h] [rbp-50h] BYREF
long long v8; // [rsp+38h] [rbp-48h] BYREF
_QWORD v9[2]; // [rsp+40h] [rbp-40h] BYREF
long long v10; // [rsp+50h] [rbp-30h]
lon... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV qword ptr [RBP + -0x78],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RDI,RAX
CALL 0x001038ae
MOV RAX,qword ptr [RBP + -0x70]
MO... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&, std::vector<std::pair<std::string, std::string >,
std::allocator<std::pair<std::string, std::string > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
bool bVar1;
bool b... |
1,933 | func0 | #include <iostream>
#include <vector>
#include <cassert>
| std::vector<std::pair<std::string, std::string>> func0(
const std::vector<std::pair<std::string, std::string>>& test_list1,
const std::vector<std::pair<std::string, std::string>>& test_list2) {
std::vector<std::pair<std::string, std::string>> res;
for (const auto& sub : test_list1) {
... | int main() {
assert((func0({{"Hello", "dude"}, {"How", "are"}, {"you", "?"}}, {{"Hello", "dude"}, {"How", "are"}}) == std::vector<std::pair<std::string, std::string>>{{"you", "?"}}));
assert((func0({{"Part", "of"}, {"the", "journey"}, {"is ", "end"}}, {{"Journey", "the"}, {"is", "end"}}) == std::vector<std::p... | O1 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EESB_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_40], rdi
mov [rsp+58h+var_48], rdx
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qw... | _QWORD * func0(_QWORD *a1, const void ***a2, long long *a3)
{
const void **v3; // r15
size_t v5; // rdx
long long v6; // rbx
_QWORD *v7; // rbx
long long v8; // r13
size_t v9; // r12
const void **v10; // [rsp+8h] [rbp-50h]
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v3 = *a2;
v10 = a2[1];
if ( v10 !... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV R15,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&, std::vector<std::pair<std::string, std::string >,
std::allocator<std::pair<std::string, std::string > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
pair *ppVar1;
size... |
1,934 | func0 | #include <iostream>
#include <vector>
#include <cassert>
| std::vector<std::pair<std::string, std::string>> func0(
const std::vector<std::pair<std::string, std::string>>& test_list1,
const std::vector<std::pair<std::string, std::string>>& test_list2) {
std::vector<std::pair<std::string, std::string>> res;
for (const auto& sub : test_list1) {
... | int main() {
assert((func0({{"Hello", "dude"}, {"How", "are"}, {"you", "?"}}, {{"Hello", "dude"}, {"How", "are"}}) == std::vector<std::pair<std::string, std::string>>{{"you", "?"}}));
assert((func0({{"Part", "of"}, {"the", "journey"}, {"is ", "end"}}, {{"Journey", "the"}, {"is", "end"}}) == std::vector<std::p... | O2 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EESB_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rdi
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qw... | long long func0(long long a1, long long *a2, long long *a3)
{
long long v3; // rbx
long long v5; // rbp
long long v6; // r13
size_t v7; // r15
_BYTE *v8; // r14
long long *v9; // rbp
size_t v10; // r14
_BYTE *v11; // rdi
_BYTE *v12; // r15
long long v13; // rdx
size_t v15; // rdx
long long v16;... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV qwo... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&, std::vector<std::pair<std::string, std::string >,
std::allocator<std::pair<std::string, std::string > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
pair *ppVar1;
int8... |
1,935 | func0 | #include <iostream>
#include <vector>
#include <cassert>
| std::vector<std::pair<std::string, std::string>> func0(
const std::vector<std::pair<std::string, std::string>>& test_list1,
const std::vector<std::pair<std::string, std::string>>& test_list2) {
std::vector<std::pair<std::string, std::string>> res;
for (const auto& sub : test_list1) {
... | int main() {
assert((func0({{"Hello", "dude"}, {"How", "are"}, {"you", "?"}}, {{"Hello", "dude"}, {"How", "are"}}) == std::vector<std::pair<std::string, std::string>>{{"you", "?"}}));
assert((func0({{"Part", "of"}, {"the", "journey"}, {"is ", "end"}}, {{"Journey", "the"}, {"is", "end"}}) == std::vector<std::p... | O3 | cpp | func0(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_st... | _Z5func0RKSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EESB_:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov rax, fs:28h
mov [rsp+58h+var_40], rax
xor eax, eax
mov qword ptr [rdi+... | long long func0(long long a1, long long *a2, long long *a3)
{
long long v4; // rbx
long long v6; // rbp
long long v7; // r14
size_t v8; // r15
size_t v9; // rdx
size_t v11; // rdx
long long *v12; // rbp
size_t v13; // r14
void *v14; // rdi
_BYTE *v15; // r15
size_t v16; // r14
void *v17; // rdi... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RAX,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOV qword ptr [RSP + 0x8]... | /* func0(std::vector<std::pair<std::string, std::string >, std::allocator<std::pair<std::string,
std::string > > > const&, std::vector<std::pair<std::string, std::string >,
std::allocator<std::pair<std::string, std::string > > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
pair *ppVar1;
int8... |
1,936 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
retu... | int func0(std::vector<int> A, int n) {
std::sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; --i) {
if (is_palindrome(A[i])) {
return A[i];
}
}
return -1;
}
| int main () {
assert(func0({1, 232, 54545, 999991}, 4) == 54545);
assert(func0({1, 2, 3, 4, 5, 50}, 6) == 5);
assert(func0({1, 3, 7, 9, 45}, 5) == 9);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 175c <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1710 <... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call ... | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
int *v4; // rax
int i; // [rsp+1Ch] [rbp-14h]
v2 = std::vector<int>::end(a1);
v3 = std::vector<int>::begin(a1);
std::sort<__gnu_cxx::__normal_iterator<int *,std::vector<int>>>(v3, v2);
for ( i = a2 - 1; i >= 0; --i )
{... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101782
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101736
MOV RSI,RBX
MOV RDI,RAX
CALL 0x001017d2
MOV EAX,dword ptr [RBP + -... | /* func0(std::vector<int, std::allocator<int> >, int) */
int4 func0(vector param_1,int param_2)
{
char cVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 *puVar5;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
int local_1c;
this = (vector<int,std::alloca... |
1,937 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
retu... | int func0(std::vector<int> A, int n) {
std::sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; --i) {
if (is_palindrome(A[i])) {
return A[i];
}
}
return -1;
}
| int main () {
assert(func0({1, 232, 54545, 999991}, 4) == 54545);
assert(func0({1, 2, 3, 4, 5, 50}, 6) == 5);
assert(func0({1, 3, 7, 9, 45}, 5) == 9);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %esi,%ebx
mov 0x8(%rdi),%r12
mov (%rdi),%r14
cmp %r14,%r12
je 138d <_Z5func0St6vectorIiSaIiEEi+0xa5>
mov %r12,%r13
sub %r14,%r13
mov %r13,%rax
sar $0x2... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r12, rdi
mov ebx, esi
mov r13, [rdi+8]
mov r14, [rdi]
cmp r13, r14
jz loc_1399
mov rbp, r13
sub rbp, r14
mov rdx, rbp
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_132C
bsr ... | long long func0(char **a1, int a2)
{
char *v3; // r13
char *v4; // r14
int v5; // eax
unsigned long long v6; // rax
char *v7; // rbp
int v8; // ecx
char *v9; // rax
int v10; // edx
char *v11; // rsi
long long v12; // rbx
char *v13; // r12
unsigned int v14; // ebp
v3 = a1[1];
v4 = *a1;
if... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV EBX,ESI
MOV R13,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
CMP R13,R14
JZ 0x00101399
MOV RBP,R13
SUB RBP,R14
MOV RDX,RBP
SAR RDX,0x2
MOV EAX,0x40
JZ 0x0010132c
BSR RAX,RDX
XOR EAX,0x3f
LAB_0010132c:
MOV EDX,0x3f
SUB EDX,EAX
MOVSXD RDX,EDX
AD... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int iVar2;
int *piVar3;
long lVar4;
int *piVar5;
int *piVar6;
int *piVar7;
char cVar8;
uint uVar9;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
ulong uVar10;
long lVar11;
in... |
1,938 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
retu... | int func0(std::vector<int> A, int n) {
std::sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; --i) {
if (is_palindrome(A[i])) {
return A[i];
}
}
return -1;
}
| int main () {
assert(func0({1, 232, 54545, 999991}, 4) == 54545);
assert(func0({1, 2, 3, 4, 5, 50}, 6) == 5);
assert(func0({1, 3, 7, 9, 45}, 5) == 9);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov 0x8(%rdi),%r13
mov (%rdi),%r14
cmp %r14,%r13
je 1564 <_Z5func0St6vectorIiSaIiEEi+0xa4>
mov %r13,%rbx
mov $0x3f,%edx
mov %r13,%rsi
mov %r1... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
mov r13, rdi
push r12
push rbp
mov ebp, esi
push rbx
mov r12, [rdi+8]
mov r14, [rdi]
cmp r12, r14
jz loc_18A4
mov rbx, r12
mov rdx, 0FFFFFFFFFFFFFFFEh
sub rbx, r14
mov rax, rbx
sar rax, 2
jz short loc_... | long long func0(char **a1, int a2)
{
char *v4; // r12
char *v5; // r14
long long v6; // rdx
unsigned long long v7; // rax
char *v8; // rbx
int v9; // ecx
int v10; // edx
char *v11; // rax
char *v12; // rsi
int v13; // ebp
long long v14; // r8
int v15; // edi
int v16; // esi
int v17; // ecx
... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV R12,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
CMP R12,R14
JZ 0x001018a4
MOV RBX,R12
MOV RDX,-0x2
SUB RBX,R14
MOV RAX,RBX
SAR RAX,0x2
JZ 0x00101841
BSR RAX,RAX
CDQE
LEA RDX,[RAX + RAX*0x1]
LAB_00101841:
MOV RSI,R12
MOV RDI,R14
CA... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int *piVar5;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
int iVar6;
int iVar7;
long lVar8;
int *piVar9;
__normal_iterator _Var10;
int4 ... |
1,939 | func0 | #include <vector>
#include <algorithm>
#include <cassert>
bool is_palindrome(int n) {
int divisor = 1;
while (n / divisor >= 10) {
divisor *= 10;
}
while (n != 0) {
int leading = n / divisor;
int trailing = n % 10;
if (leading != trailing) {
retu... | int func0(std::vector<int> A, int n) {
std::sort(A.begin(), A.end());
for (int i = n - 1; i >= 0; --i) {
if (is_palindrome(A[i])) {
return A[i];
}
}
return -1;
}
| int main () {
assert(func0({1, 232, 54545, 999991}, 4) == 54545);
assert(func0({1, 2, 3, 4, 5, 50}, 6) == 5);
assert(func0({1, 3, 7, 9, 45}, 5) == 9);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
mov %esi,0xc(%rsp)
cmp %rbp,%r12
je 1594 <_Z5func0St6vectorIiSaIiEEi+0x114>
mov %r12,%r14
mov $0... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r13, [rdi+8]
mov r15, [rdi]
mov [rsp+48h+var_3C], esi
cmp r13, r15
jz loc_1854
mov r14, r13
lea r12, [r15+4]
sub r14, r15
mov rax, r14
sa... | long long func0(char **a1, int a2)
{
char *v3; // r13
char *v4; // r15
char *v5; // r12
unsigned long long v6; // rdx
char *v7; // r14
int v8; // ebx
char *v9; // rsi
int v10; // edx
char *j; // rax
int v12; // ecx
int v13; // edx
char *v14; // rax
char *v15; // rsi
long long v16; // r8
i... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R13,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RDI]
MOV dword ptr [RSP + 0xc],ESI
CMP R13,R15
JZ 0x00101854
MOV R14,R13
LEA R12,[R15 + 0x4]
SUB R14,R15
MOV RAX,R14
SAR RAX,0x2
JZ 0x00101958
BSR RDX,RAX
MOV RSI,R13
MOV RDI,R1... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10,
int4 param_11)
{
int iVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int iVar5;
ulong uVar6;
_I... |
1,940 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) {
r = n - r;
}
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return (answer * pow(p, r0) * pow(1 - p, n - r0));
}
| int main() {
assert(func0(10, 5, 1.0/3) == 0.13656454808718185);
assert(func0(11, 6, 2.0/4) == 0.2255859375);
assert(func0(12, 7, 3.0/5) == 0.227030335488);
return 0;
}
| O0 | cpp | func0(int, int, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
movsd %xmm0,-0x20(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x18(%rbp)
jle 1... | _Z5func0iid:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
movsd [rbp+x], xmm0
mov eax, [rbp+var_18]
mov [rbp+var_C], eax
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_18], eax
jle sh... | double func0(int a1, int a2, double a3)
{
double v4; // [rsp+8h] [rbp-28h]
int v6; // [rsp+18h] [rbp-18h]
int i; // [rsp+20h] [rbp-10h]
double v8; // [rsp+28h] [rbp-8h]
v6 = a2;
if ( a2 > a1 / 2 )
v6 = a1 - a2;
v8 = 1.0;
for ( i = 1; i <= v6; ++i )
v8 = (double)(a1 - v6 + i) * v8 / (double)i;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOVSD qword ptr [RBP + -0x20],XMM0
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x18],... | /* func0(int, int, double) */
double func0(int param_1,int param_2,double param_3)
{
double dVar1;
double dVar2;
int4 local_20;
int4 local_18;
int8 local_10;
local_20 = param_2;
if (param_1 / 2 < param_2) {
local_20 = param_1 - param_2;
}
local_10 = DAT_001020c8;
for (local_18 = 1; local_18... |
1,941 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) {
r = n - r;
}
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return (answer * pow(p, r0) * pow(1 - p, n - r0));
}
| int main() {
assert(func0(10, 5, 1.0/3) == 0.13656454808718185);
assert(func0(11, 6, 2.0/4) == 0.2255859375);
assert(func0(12, 7, 3.0/5) == 0.227030335488);
return 0;
}
| O1 | cpp | func0(int, int, double):
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %edi,%ebx
mov %esi,%ebp
movsd %xmm0,0x10(%rsp)
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
mov %edi,%edx
sub %esi,%edx
cmp %esi,%eax
mov %edx,%eax
cmovge %esi,%eax
test %eax,%eax
jle 126e <_Z5func0... | _Z5func0iid:
endbr64
push rbp
push rbx
sub rsp, 28h
mov ebx, edi
mov ebp, esi
movsd [rsp+38h+x], xmm0
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
mov edx, edi
sub edx, esi
cmp eax, esi
cmovge edx, esi
test edx, edx
jle loc_122C
lea esi, [rdx+1]
mov e... | double func0(int a1, int a2, double a3)
{
int v3; // edx
int v4; // eax
double v6; // [rsp+8h] [rbp-30h]
double v8; // [rsp+18h] [rbp-20h]
v3 = a1 - a2;
if ( a1 / 2 >= a2 )
v3 = a2;
if ( v3 <= 0 )
{
v6 = 1.0;
}
else
{
v4 = 1;
v6 = 1.0;
do
{
v6 = (double)(a1 - v3 + v... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV EBX,EDI
MOV EBP,ESI
MOVSD qword ptr [RSP + 0x10],XMM0
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
MOV EDX,EDI
SUB EDX,ESI
CMP EAX,ESI
CMOVGE EDX,ESI
TEST EDX,EDX
JLE 0x0010122c
LEA ESI,[RDX + 0x1]
MOV EAX,0x1
MOVSD XMM5,qword ptr [0x001020b0]
MOVSD qword ptr [RSP +... | /* func0(int, int, double) */
double func0(int param_1,int param_2,double param_3)
{
int iVar1;
int iVar2;
double dVar3;
double dVar4;
int8 local_30;
iVar2 = param_1 - param_2;
if (param_2 <= param_1 / 2) {
iVar2 = param_2;
}
if (iVar2 < 1) {
local_30 = DAT_001020b0;
}
else {
iVar... |
1,942 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) {
r = n - r;
}
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return (answer * pow(p, r0) * pow(1 - p, n - r0));
}
| int main() {
assert(func0(10, 5, 1.0/3) == 0.13656454808718185);
assert(func0(11, 6, 2.0/4) == 0.2255859375);
assert(func0(12, 7, 3.0/5) == 0.227030335488);
return 0;
}
| O2 | cpp | func0(int, int, double):
endbr64
mov %edi,%eax
push %rbx
mov %edi,%ebx
mov %esi,%ecx
shr $0x1f,%eax
sub %esi,%ebx
movapd %xmm0,%xmm3
add %edi,%eax
sar %eax
sub $0x20,%rsp
cmp %esi,%eax
cmovl %ebx,%ecx
test %ecx,%ecx
jle 1390 <_Z5func0iid+0xc0>
movsd 0xdd7(%rip),%xmm4
sub %ecx,%edi... | _Z5func0iid:
endbr64
mov eax, edi
push rbx
mov ebx, edi
mov ecx, esi
shr eax, 1Fh
sub ebx, esi
movapd xmm3, xmm0
add eax, edi
sar eax, 1
sub rsp, 20h
cmp eax, esi
cmovl ecx, ebx
test ecx, ecx
jle loc_1320
movsd xmm4, cs:qword_20B0
sub edi, ecx
mov eax, 1
add ... | double func0(int a1, int a2, double a3)
{
int v3; // ecx
int v4; // ebx
int v5; // edi
int v6; // eax
int v7; // ecx
double v8; // xmm2_8
int v9; // edx
double v10; // xmm1_8
double v12; // [rsp+0h] [rbp-28h]
v3 = a2;
v4 = a1 - a2;
if ( a1 / 2 < a2 )
v3 = a1 - a2;
if ( v3 <= 0 )
{
... | func0:
ENDBR64
MOV EAX,EDI
PUSH RBX
MOV EBX,EDI
MOV ECX,ESI
SHR EAX,0x1f
SUB EBX,ESI
MOVAPD XMM3,XMM0
ADD EAX,EDI
SAR EAX,0x1
SUB RSP,0x20
CMP EAX,ESI
CMOVL ECX,EBX
TEST ECX,ECX
JLE 0x00101320
MOVSD XMM4,qword ptr [0x001020b0]
SUB EDI,ECX
MOV EAX,0x1
ADD ECX,0x1
MOVAPD XMM2,XMM4
NOP
LAB_00101290:
LEA EDX,[RAX + RDI*0x1... | /* func0(int, int, double) */
double func0(int param_1,int param_2,double param_3)
{
int iVar1;
int iVar2;
int iVar3;
double dVar4;
double dVar5;
double dVar6;
dVar4 = DAT_001020b0;
iVar3 = param_2;
if (param_1 / 2 < param_2) {
iVar3 = param_1 - param_2;
}
dVar6 = DAT_001020b0;
if (0 < ... |
1,943 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| double func0(int n, int r, double p) {
int r0 = r;
if (r > n / 2) {
r = n - r;
}
double answer = 1.0;
for (int i = 1; i <= r; i++) {
answer *= (n - r + i);
answer /= i;
}
return (answer * pow(p, r0) * pow(1 - p, n - r0));
}
| int main() {
assert(func0(10, 5, 1.0/3) == 0.13656454808718185);
assert(func0(11, 6, 2.0/4) == 0.2255859375);
assert(func0(12, 7, 3.0/5) == 0.227030335488);
return 0;
}
| O3 | cpp | func0(int, int, double):
endbr64
push %rbx
mov %edi,%eax
mov %edi,%ebx
shr $0x1f,%edi
add %eax,%edi
movapd %xmm0,%xmm3
sub %esi,%ebx
sar %edi
sub $0x20,%rsp
cmp %esi,%edi
jl 13a0 <_Z5func0iid+0xd0>
mov %esi,%ecx
mov %ebx,%edi
test %ecx,%ecx
jle 13ac <_Z5func0iid+0xdc>
movsd 0xd... | _Z5func0iid:
endbr64
mov eax, edi
push rbx
mov ebx, edi
movapd xmm3, xmm0
shr eax, 1Fh
sub ebx, esi
add eax, edi
sar eax, 1
sub rsp, 20h
cmp eax, esi
jl loc_1320
mov ecx, esi
mov edi, ebx
test ecx, ecx
jle loc_132C
loc_127E:
movsd xmm4, cs:qword_20B8
add ecx... | double func0(int a1, int a2, double a3)
{
int v3; // ebx
int v4; // ecx
int v5; // edi
int v6; // ecx
int v7; // eax
double v8; // xmm2_8
int v9; // edx
double v10; // xmm1_8
double v12; // [rsp+0h] [rbp-28h]
v3 = a1 - a2;
if ( a1 / 2 >= a2 )
{
v4 = a2;
v5 = a1 - a2;
if ( a2 > 0 )
... | func0:
ENDBR64
MOV EAX,EDI
PUSH RBX
MOV EBX,EDI
MOVAPD XMM3,XMM0
SHR EAX,0x1f
SUB EBX,ESI
ADD EAX,EDI
SAR EAX,0x1
SUB RSP,0x20
CMP EAX,ESI
JL 0x00101320
MOV ECX,ESI
MOV EDI,EBX
TEST ECX,ECX
JLE 0x0010132c
LAB_0010127e:
MOVSD XMM4,qword ptr [0x001020b8]
ADD ECX,0x1
MOV EAX,0x1
MOVAPD XMM2,XMM4
NOP word ptr [RAX + RAX*0x... | /* func0(int, int, double) */
double func0(int param_1,int param_2,double param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
double dVar6;
double dVar7;
double dVar8;
dVar6 = DAT_001020b8;
iVar4 = param_1 - param_2;
dVar8 = DAT_001020b8;
if (param_1 / 2 < param_2) {
iVar3... |
1,944 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
| std::vector<std::pair<int, int>> func0(std::vector<std::pair<int, int>>& tup) {
int lst = tup.size();
for (int i = 0; i < lst; ++i) {
for (int j = 0; j < lst - i - 1; ++j) {
if (tup[j].second > tup[j + 1].second) {
std::pair<int, int> temp = tup[j];
tup[... | int main() {
std::vector<std::pair<int, int>> vec1{{1, 3}, {3, 2}, {2, 1}};
std::vector<std::pair<int, int>> vec2{{2, 4}, {3, 3}, {1, 1}};
std::vector<std::pair<int, int>> vec3{{3, 9}, {6, 7}, {4, 3}};
assert((func0(vec1) == std::vector<std::pair<int, int>>{{2, 1}, {3, 2}, {1, 3}}));
assert((... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, 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 -0x40(%rbp),%rax
mov %rax,%rdi
callq 1a5a <_ZNKSt6v... | _Z5func0RSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZNKSt6vectorISt4pairIiiESaIS1_EE4sizeEv; std::v... | long long func0(long long a1, long long a2)
{
int v2; // ebx
long long v3; // rbx
long long v4; // rax
long long v5; // rax
int i; // [rsp+14h] [rbp-2Ch]
int j; // [rsp+18h] [rbp-28h]
int v9; // [rsp+1Ch] [rbp-24h]
_QWORD v10[3]; // [rsp+20h] [rbp-20h] BYREF
v10[1] = __readfsqword(0x28u);
v9 = std... | func0:
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 + -0x40]
MOV RDI,RAX
CALL 0x00101a6c
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x2c],0x0
JM... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&) */
vector * func0(vector *param_1)
{
int iVar1;
int iVar2;
long lVar3;
int8 *puVar4;
pair *ppVar5;
pair<int,int> *ppVar6;
vector<std::pair<int,int>,std::allocator<std::pair<int,int>>> *in_RSI;
long in_FS_OFFSET;
int l... |
1,945 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
| std::vector<std::pair<int, int>> func0(std::vector<std::pair<int, int>>& tup) {
int lst = tup.size();
for (int i = 0; i < lst; ++i) {
for (int j = 0; j < lst - i - 1; ++j) {
if (tup[j].second > tup[j + 1].second) {
std::pair<int, int> temp = tup[j];
tup[... | int main() {
std::vector<std::pair<int, int>> vec1{{1, 3}, {3, 2}, {2, 1}};
std::vector<std::pair<int, int>> vec2{{2, 4}, {3, 3}, {1, 1}};
std::vector<std::pair<int, int>> vec3{{3, 9}, {6, 7}, {4, 3}};
assert((func0(vec1) == std::vector<std::pair<int, int>>{{2, 1}, {3, 2}, {1, 3}}));
assert((... | O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
mov %rsi,%rbx
mov 0x8(%rsi),%r10
sub (%rsi),%r10
sar $0x3,%r10
test %r10d,%r10d
jle 127a <_Z5func0RSt6vectorISt4pairIiiESaIS1_EE+0x71>
sub $0x1,%r10d
jmpq 1... | _Z5func0RSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov rbx, rsi
mov r10, [rsi+8]
sub r10, [rsi]
sar r10, 3
test r10d, r10d
jg loc_12FE
jmp short loc_1273
loc_122D:
cmp rdx, rdi
jz loc_12FA
loc_1236:
mov rax, [rbx]
lea rcx, [r... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v4; // r10
int *v5; // rcx
int v6; // esi
long long v7; // rdx
int *v8; // rax
int v9; // r8d
_DWORD *v10; // rax
unsigned long long v11; // r12
long long v12; // rax
long long v13; // rsi
long long v14; // rdi
long long v15; // rsi
long lo... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV RBX,RSI
MOV R10,qword ptr [RSI + 0x8]
SUB R10,qword ptr [RSI]
SAR R10,0x3
TEST R10D,R10D
JG 0x001012fe
JMP 0x00101273
LAB_0010122d:
CMP RDX,RDI
JZ 0x001012fa
LAB_00101236:
MOV RAX,qword ptr [RBX]
LEA RCX,[RAX + RDX*0x1]
MOV ESI,dword ptr [RCX + 0x4]
ADD RDX,0x8
... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&) */
vector * func0(vector *param_1)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
int4 *puVar4;
void *pvVar5;
long lVar6;
long lVar7;
long *in_RSI;
long lVar8;
int iVar9;
ulong uVar10;
uVar10 = in_RSI[1] - *in_RSI >>... |
1,946 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
| std::vector<std::pair<int, int>> func0(std::vector<std::pair<int, int>>& tup) {
int lst = tup.size();
for (int i = 0; i < lst; ++i) {
for (int j = 0; j < lst - i - 1; ++j) {
if (tup[j].second > tup[j + 1].second) {
std::pair<int, int> temp = tup[j];
tup[... | int main() {
std::vector<std::pair<int, int>> vec1{{1, 3}, {3, 2}, {2, 1}};
std::vector<std::pair<int, int>> vec2{{2, 4}, {3, 3}, {1, 1}};
std::vector<std::pair<int, int>> vec3{{3, 9}, {6, 7}, {4, 3}};
assert((func0(vec1) == std::vector<std::pair<int, int>>{{2, 1}, {3, 2}, {1, 3}}));
assert((... | O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%r11
mov 0x8(%rsi),%rbp
sub %r11,%rbp
lea 0x8(%r11),%rsi
mov %rbp,%r13
sar $0x3,%r13
lea -0x1(%r13),... | _Z5func0RSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
mov r8, [rsi]
mov rbx, rdi
mov r10, [rsi+8]
sub r10, r8
mov rdi, r10
sar rdi, 3
test edi, edi
jle loc_1700
lea r9, [r8+8]
loc_163B:
cmp edi, 1
jle short loc_168B
loc_1640:
lea ... | long long func0(long long a1, unsigned int **a2)
{
unsigned int *v3; // r8
signed long long v5; // r10
long long v6; // rdi
unsigned int *v7; // rax
signed int v8; // ecx
signed int v9; // edx
signed long long v10; // r12
unsigned long long v11; // rax
unsigned int *v12; // rsi
unsigned int *v13; /... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV R8,qword ptr [RSI]
MOV RBX,RDI
MOV R10,qword ptr [RSI + 0x8]
SUB R10,R8
MOV RDI,R10
SAR RDI,0x3
TEST EDI,EDI
JLE 0x00101700
LEA R9,[R8 + 0x8]
LAB_0010163b:
CMP EDI,0x1
JLE 0x0010168b
LAB_00101640:
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R9 + RDX*0x8]
NOP word p... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&) */
vector * func0(vector *param_1)
{
int4 uVar1;
int8 *puVar2;
long lVar3;
long lVar4;
int8 *puVar5;
void *pvVar6;
long lVar7;
long *in_RSI;
uint uVar8;
ulong uVar9;
ulong uVar10;
puVar2 = (int8 *)*in_RSI;
... |
1,947 | func0 |
#include <vector>
#include <utility>
#include <assert.h>
| std::vector<std::pair<int, int>> func0(std::vector<std::pair<int, int>>& tup) {
int lst = tup.size();
for (int i = 0; i < lst; ++i) {
for (int j = 0; j < lst - i - 1; ++j) {
if (tup[j].second > tup[j + 1].second) {
std::pair<int, int> temp = tup[j];
tup[... | int main() {
std::vector<std::pair<int, int>> vec1{{1, 3}, {3, 2}, {2, 1}};
std::vector<std::pair<int, int>> vec2{{2, 4}, {3, 3}, {1, 1}};
std::vector<std::pair<int, int>> vec3{{3, 9}, {6, 7}, {4, 3}};
assert((func0(vec1) == std::vector<std::pair<int, int>>{{2, 1}, {3, 2}, {1, 3}}));
assert((... | O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov (%rsi),%r11
mov 0x8(%rsi),%rbp
sub %r11,%rbp
lea 0x8(%r11),%rsi
mov %rbp,%r13
sar $0x3,%r13
lea -0x1(%r13),... | _Z5func0RSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
push rbp
mov rbp, rsi
push rbx
mov r8, [rsi]
mov rbx, rdi
mov r10, [rsi+8]
sub r10, r8
mov rdi, r10
sar rdi, 3
test edi, edi
jle loc_1720
lea r9, [r8+8]
loc_165B:
cmp edi, 1
jle short loc_16AB
loc_1660:
lea ... | long long func0(long long a1, unsigned int **a2)
{
unsigned int *v3; // r8
signed long long v5; // r10
long long v6; // rdi
unsigned int *v7; // rax
signed int v8; // ecx
signed int v9; // edx
signed long long v10; // r12
unsigned long long v11; // rax
unsigned int *v12; // rsi
unsigned int *v13; /... | func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RSI
PUSH RBX
MOV R8,qword ptr [RSI]
MOV RBX,RDI
MOV R10,qword ptr [RSI + 0x8]
SUB R10,R8
MOV RDI,R10
SAR RDI,0x3
TEST EDI,EDI
JLE 0x00101720
LEA R9,[R8 + 0x8]
LAB_0010165b:
CMP EDI,0x1
JLE 0x001016ab
LAB_00101660:
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R9 + RDX*0x8]
NOP word p... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >&) */
vector * func0(vector *param_1)
{
int4 uVar1;
int8 *puVar2;
long lVar3;
int8 *puVar4;
void *pvVar5;
long lVar6;
long *in_RSI;
long lVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
puVar2 = (int8 *)*in_RSI;
... |
1,948 | func0 | #include <cmath>
#include <cassert>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O0 | cpp | func0(double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
movsd %xmm0,-0x18(%rbp)
movsd 0xf36(%rip),%xmm0
mov -0x18(%rbp),%rax
movapd %xmm0,%xmm1
movq %rax,%xmm0
callq 1060 <pow@plt>
movsd 0xf24(%rip),%xmm1
mulsd %xmm1,%xmm0
movsd 0xf20(%rip),%xmm1
divsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd... | _Z5func0d:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
movsd [rbp+x], xmm0
movsd xmm0, cs:y
mov rax, [rbp+x]
movapd xmm1, xmm0; y
movq xmm0, rax; x
call _pow
movsd xmm1, cs:qword_20A0
mulsd xmm0, xmm1
movsd xmm1, cs:qword_20A8
divsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rb... | double func0(double a1)
{
return pow(a1, 2.0) * 6.881909602355868 / 4.0;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD XMM0,qword ptr [0x00102098]
MOV RAX,qword ptr [RBP + -0x18]
MOVAPD XMM1,XMM0
MOVQ XMM0,RAX
CALL 0x00101060
MOVSD XMM1,qword ptr [0x001020a0]
MULSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x001020a8]
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + ... | /* func0(double) */
double func0(double param_1)
{
double dVar1;
dVar1 = pow(param_1,DAT_00102098);
return (dVar1 * DAT_001020a0) / DAT_001020a8;
} |
1,949 | func0 | #include <cmath>
#include <cassert>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O1 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xecf(%rip),%xmm0
mulsd 0xecf(%rip),%xmm0
retq
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
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 * _DAT_00102010;
} |
1,950 | func0 | #include <cmath>
#include <cassert>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O2 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopl 0x0(%rax)
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
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 * _DAT_00102010;
} |
1,951 | func0 | #include <cmath>
#include <cassert>
| double func0(double a) {
double area = (sqrt(5 * (5 + 2 * sqrt(5))) * pow(a, 2)) / 4.0;
return area;
}
| int main() {
assert(func0(5) == 43.01193501472417);
assert(func0(10) == 172.0477400588967);
assert(func0(15) == 387.10741513251753);
return 0;
}
| O3 | cpp | func0(double):
endbr64
mulsd %xmm0,%xmm0
mulsd 0xeb8(%rip),%xmm0
mulsd 0xeb8(%rip),%xmm0
retq
nopl 0x0(%rax)
| _Z5func0d:
endbr64
mulsd xmm0, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, cs:qword_2010
retn | double func0(double a1)
{
return a1 * a1 * 6.881909602355868 * 0.25;
} | func0:
ENDBR64
MULSD XMM0,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,qword ptr [0x00102010]
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 * _DAT_00102010;
} |
1,952 | func0 |
#include <cassert>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; ++i) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
assert(func0(5, arr1) == 2);
int arr2[] = {5, 6, 5};
assert(func0(3, arr2) == 1);
int arr3[] = {2, 7, 7, 7};
assert(func0(4, arr3) == 3);
return 0;
}
| O0 | cpp | func0(int, int*):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov -0x20(%rbp),%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jge 11f9 <_Z5func0iPi+0x90>
mov -0x4(%rbp),%eax
cltq... | _Z5func0iPi:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_C], eax
mov [rbp+var_8], 1
mov [rbp+var_4], 1
jmp short loc_11F1
loc_1191:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [... | long long func0(int a1, int *a2)
{
int v3; // [rsp+14h] [rbp-Ch]
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v3 = *a2;
v4 = 1;
for ( i = 1; i < a1; ++i )
{
if ( v3 >= a2[i] )
{
if ( v3 == a2[i] )
++v4;
}
else
{
v3 = a2[i];
v4 = 1;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001011f1
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RD... | /* func0(int, int*) */
int func0(int param_1,int *param_2)
{
int local_14;
int local_10;
int local_c;
local_14 = *param_2;
local_10 = 1;
for (local_c = 1; local_c < param_1; local_c = local_c + 1) {
if (local_14 < param_2[local_c]) {
local_14 = param_2[local_c];
local_10 = 1;
}
... |
1,953 | func0 |
#include <cassert>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; ++i) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
assert(func0(5, arr1) == 2);
int arr2[] = {5, 6, 5};
assert(func0(3, arr2) == 1);
int arr3[] = {2, 7, 7, 7};
assert(func0(4, arr3) == 3);
return 0;
}
| O1 | cpp | func0(int, int*):
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 11a7 <_Z5func0iPi+0x3e>
lea 0x4(%rsi),%rax
lea -0x2(%rdi),%edx
lea 0x8(%rsi,%rdx,4),%rdi
mov $0x1,%esi
jmp 1197 <_Z5func0iPi+0x2e>
mov %edx,%ecx
mov $0x1,%esi
add $0x4,%rax
cmp %rdi,%rax
je 11ac <_Z5func0iPi+0x43>
mov ... | _Z5func0iPi:
endbr64
mov ecx, [rsi]
cmp edi, 1
jle short loc_11A7
lea rax, [rsi+4]
lea edx, [rdi-2]
lea rdi, [rsi+rdx*4+8]
mov esi, 1
jmp short loc_1197
loc_1187:
mov ecx, edx
mov esi, 1
loc_118E:
add rax, 4
cmp rax, rdi
jz short loc_11AC
loc_1197:
mov edx, [rax]... | long long func0(int a1, int *a2)
{
int v2; // ecx
int *v3; // rax
int *v4; // rdi
unsigned int v5; // esi
v2 = *a2;
if ( a1 <= 1 )
{
return 1;
}
else
{
v3 = a2 + 1;
v4 = &a2[a1 - 2 + 2];
v5 = 1;
do
{
if ( *v3 > v2 )
{
v2 = *v3;
v5 = 1;
}
... | func0:
ENDBR64
MOV ECX,dword ptr [RSI]
CMP EDI,0x1
JLE 0x001011a7
LEA RAX,[RSI + 0x4]
LEA EDX,[RDI + -0x2]
LEA RDI,[RSI + RDX*0x4 + 0x8]
MOV ESI,0x1
JMP 0x00101197
LAB_00101187:
MOV ECX,EDX
MOV ESI,0x1
LAB_0010118e:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011ac
LAB_00101197:
MOV EDX,dword ptr [RAX]
CMP EDX,ECX
JG 0x00101187
SE... | /* func0(int, int*) */
int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
iVar3 = *param_2;
if (param_1 < 2) {
iVar4 = 1;
}
else {
piVar2 = param_2 + 1;
iVar4 = 1;
do {
iVar1 = *piVar2;
if (iVar1 == iVar3 || iVar1 < iVar3) {
iVar4... |
1,954 | func0 |
#include <cassert>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; ++i) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
assert(func0(5, arr1) == 2);
int arr2[] = {5, 6, 5};
assert(func0(3, arr2) == 1);
int arr3[] = {2, 7, 7, 7};
assert(func0(4, arr3) == 3);
return 0;
}
| O2 | cpp | func0(int, int*):
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 1280 <_Z5func0iPi+0x50>
lea -0x2(%rdi),%edx
lea 0x4(%rsi),%rax
mov $0x1,%r8d
lea 0x8(%rsi,%rdx,4),%rsi
jmp 1262 <_Z5func0iPi+0x32>
sete %dl
add $0x4,%rax
movzbl %dl,%edx
add %edx,%r8d
cmp %rsi,%rax
je 1279 <_Z5func0iPi+0x... | _Z5func0iPi:
endbr64
mov r8d, [rsi]
cmp edi, 1
jle short loc_12C0
lea edx, [rdi-2]
lea rax, [rsi+4]
mov ecx, 1
lea rsi, [rsi+rdx*4+8]
jmp short loc_12A1
loc_1290:
setz dl
add rax, 4
movzx edx, dl
add ecx, edx
cmp rsi, rax
jz short loc_12B9
loc_12A1:
mov edx, [ra... | long long func0(int a1, int *a2)
{
int v2; // r8d
int *v3; // rax
unsigned int v4; // ecx
int *v5; // rsi
int v6; // edx
bool v7; // zf
v2 = *a2;
if ( a1 <= 1 )
return 1LL;
v3 = a2 + 1;
v4 = 1;
v5 = &a2[a1 - 2 + 2];
do
{
while ( 1 )
{
v6 = *v3;
v7 = v2 == *v3;
i... | func0:
ENDBR64
MOV R8D,dword ptr [RSI]
CMP EDI,0x1
JLE 0x001012c0
LEA EDX,[RDI + -0x2]
LEA RAX,[RSI + 0x4]
MOV ECX,0x1
LEA RSI,[RSI + RDX*0x4 + 0x8]
JMP 0x001012a1
LAB_00101290:
SETZ DL
ADD RAX,0x4
MOVZX EDX,DL
ADD ECX,EDX
CMP RSI,RAX
JZ 0x001012b9
LAB_001012a1:
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
JGE 0x00101290
ADD RA... | /* func0(int, int*) */
int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_1 < 2) {
return 1;
}
piVar2 = param_2 + 1;
iVar3 = 1;
iVar4 = *param_2;
do {
while( true ) {
iVar1 = *piVar2;
if (iVar4 < iVar1) break;
piVar2 = piVar2 ... |
1,955 | func0 |
#include <cassert>
| int func0(int n, int arr[]) {
int mn = arr[0];
int freq = 1;
for (int i = 1; i < n; ++i) {
if (arr[i] > mn) {
mn = arr[i];
freq = 1;
} else if (arr[i] == mn) {
freq += 1;
}
}
return freq;
}
| int main() {
int arr1[] = {1, 2, 3, 4, 4};
assert(func0(5, arr1) == 2);
int arr2[] = {5, 6, 5};
assert(func0(3, arr2) == 1);
int arr3[] = {2, 7, 7, 7};
assert(func0(4, arr3) == 3);
return 0;
}
| O3 | cpp | func0(int, int*):
endbr64
mov (%rsi),%ecx
cmp $0x1,%edi
jle 1290 <_Z5func0iPi+0x50>
lea -0x2(%rdi),%edx
lea 0x4(%rsi),%rax
mov $0x1,%r8d
lea 0x8(%rsi,%rdx,4),%rsi
jmp 1272 <_Z5func0iPi+0x32>
sete %dl
add $0x4,%rax
movzbl %dl,%edx
add %edx,%r8d
cmp %rax,%rsi
je 1289 <_Z5func0iPi+0x... | _Z5func0iPi:
endbr64
mov r8d, [rsi]
cmp edi, 1
jle short loc_1190
lea edx, [rdi-2]
lea rax, [rsi+4]
mov ecx, 1
lea rsi, [rsi+rdx*4+8]
jmp short loc_1171
loc_1160:
setz dl
add rax, 4
movzx edx, dl
add ecx, edx
cmp rsi, rax
jz short loc_1189
loc_1171:
mov edx, [ra... | long long func0(int a1, int *a2)
{
int v2; // r8d
int *v3; // rax
unsigned int v4; // ecx
int *v5; // rsi
int v6; // edx
bool v7; // zf
v2 = *a2;
if ( a1 <= 1 )
return 1LL;
v3 = a2 + 1;
v4 = 1;
v5 = &a2[a1 - 2 + 2];
do
{
while ( 1 )
{
v6 = *v3;
v7 = v2 == *v3;
i... | func0:
ENDBR64
MOV R8D,dword ptr [RSI]
CMP EDI,0x1
JLE 0x00101190
LEA EDX,[RDI + -0x2]
LEA RAX,[RSI + 0x4]
MOV ECX,0x1
LEA RSI,[RSI + RDX*0x4 + 0x8]
JMP 0x00101171
LAB_00101160:
SETZ DL
ADD RAX,0x4
MOVZX EDX,DL
ADD ECX,EDX
CMP RSI,RAX
JZ 0x00101189
LAB_00101171:
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
JGE 0x00101160
ADD RA... | /* func0(int, int*) */
int func0(int param_1,int *param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_1 < 2) {
return 1;
}
piVar2 = param_2 + 1;
iVar3 = 1;
iVar4 = *param_2;
do {
while( true ) {
iVar1 = *piVar2;
if (iVar4 < iVar1) break;
piVar2 = piVar2 ... |
1,956 | func0 |
#include <iostream>
#include <set>
#include <utility>
#include <cassert>
| std::set<std::pair<int, int>> func0(const std::set<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> temp;
for (const auto& p : test_list) {
if (test_list.find({p.second, p.first}) != test_list.end()) {
temp.insert(p);
}
}
std::set<std::pair<int, int>>... | int main() {
std::set<std::pair<int, int>> test1 = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
std::set<std::pair<int, int>> result1 = {{8, 9}, {6, 7}};
assert(func0(test1) == result1);
std::set<std::pair<int, int>> test2 = {{7, 8}, {3, 4}, {8, 7}, {10, 9}, {11, 3}, {9, 10}};
std::set<... | O0 | cpp | func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mo... | _Z5func0RKSt3setISt4pairIiiESt4lessIS1_ESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+var_A8], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt3setISt4pairIiiESt4lessIS1_ESaIS... | long long func0(long long a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-98h] BYREF
long long v4; // [rsp+20h] [rbp-90h] BYREF
long long v5; // [rsp+28h] [rbp-88h] BYREF
_QWORD v6[2]; // [rsp+30h] [rbp-80h] BYREF
_BYTE *v7; // [rsp+40h] [rbp-70h]
_DWORD *v8; // [rsp+48h] [rbp-68h]
long long v9; // [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00101db4
MOV RAX,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qwor... | /* func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >,
std::allocator<std::pair<int, int> > > const&) */
set * func0(set *param_1)
{
char cVar1;
set<std::pair<int,int>,std::less<std::pair<int,int>>,std::allocator<std::pair<int,int>>> *in_RSI;
long in_FS_OFFSET;
int8 local_a0;
int8 local_... |
1,957 | func0 |
#include <iostream>
#include <set>
#include <utility>
#include <cassert>
| std::set<std::pair<int, int>> func0(const std::set<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> temp;
for (const auto& p : test_list) {
if (test_list.find({p.second, p.first}) != test_list.end()) {
temp.insert(p);
}
}
std::set<std::pair<int, int>>... | int main() {
std::set<std::pair<int, int>> test1 = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
std::set<std::pair<int, int>> result1 = {{8, 9}, {6, 7}};
assert(func0(test1) == result1);
std::set<std::pair<int, int>> test2 = {{7, 8}, {3, 4}, {8, 7}, {10, 9}, {11, 3}, {9, 10}};
std::set<... | O1 | cpp | func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x40,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movl $0x0,0x8(%rsp)
movq $0x0,0x10(... | _Z5func0RKSt3setISt4pairIiiESt4lessIS1_ESaIS1_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov r13, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
mov [rsp+68h+var_60], 0
mov [rsp+68h+var_58], 0
lea rax, [rsp+68h+var_60]
mov [r... | long long func0(long long a1, long long a2)
{
long long v4; // rbx
long long i; // rbp
int *j; // rbx
long long v7; // rax
int v8; // edx
long long v9; // rsi
int v10; // eax
int v11; // ecx
int v12; // edi
long long v14; // [rsp+0h] [rbp-68h] BYREF
int v15; // [rsp+8h] [rbp-60h] BYREF
long lon... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
LEA RAX,[RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP... | /* func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >,
std::allocator<std::pair<int, int> > > const&) */
set * func0(set *param_1)
{
int iVar1;
_Rb_tree_node_base *p_Var2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_node_base *p_Var5;
long in_RSI;
_Rb_tree_node_b... |
1,958 | func0 |
#include <iostream>
#include <set>
#include <utility>
#include <cassert>
| std::set<std::pair<int, int>> func0(const std::set<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> temp;
for (const auto& p : test_list) {
if (test_list.find({p.second, p.first}) != test_list.end()) {
temp.insert(p);
}
}
std::set<std::pair<int, int>>... | int main() {
std::set<std::pair<int, int>> test1 = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
std::set<std::pair<int, int>> result1 = {{8, 9}, {6, 7}};
assert(func0(test1) == result1);
std::set<std::pair<int, int>> test2 = {{7, 8}, {3, 4}, {8, 7}, {10, 9}, {11, 3}, {9, 10}};
std::set<... | O2 | cpp | func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
lea 0x8(%rsi),%rbx
sub $0x48,%rsp
mov 0x18(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)... | _Z5func0RKSt3setISt4pairIiiESt4lessIS1_ESaIS1_EE:
endbr64
push r14
push r13
mov r13, rdi
push r12
push rbp
lea rbp, [rsi+8]
push rbx
sub rsp, 40h
mov rbx, [rsi+18h]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r14, [rsp+68h+var_60]
mov [rsp+68h+var_60], 0... | long long func0(long long a1, long long a2)
{
long long v3; // rbp
long long v4; // rbx
long long v6; // rax
long long v7; // rdx
long long v8; // rsi
long long v9; // rcx
long long v10; // rdx
int *v11; // rbx
long long v12; // rdx
_QWORD *v13; // rbx
void *v14; // rdi
long long v16; // [rsp+0... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
LEA RBP,[RSI + 0x8]
PUSH RBX
SUB RSP,0x40
MOV RBX,qword ptr [RSI + 0x18]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x8]
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R14
M... | /* func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >,
std::allocator<std::pair<int, int> > > const&) */
set * func0(set *param_1)
{
_Rb_tree_node_base *p_Var1;
int iVar2;
void *pvVar3;
void *pvVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
... |
1,959 | func0 |
#include <iostream>
#include <set>
#include <utility>
#include <cassert>
| std::set<std::pair<int, int>> func0(const std::set<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> temp;
for (const auto& p : test_list) {
if (test_list.find({p.second, p.first}) != test_list.end()) {
temp.insert(p);
}
}
std::set<std::pair<int, int>>... | int main() {
std::set<std::pair<int, int>> test1 = {{6, 7}, {2, 3}, {7, 6}, {9, 8}, {10, 2}, {8, 9}};
std::set<std::pair<int, int>> result1 = {{8, 9}, {6, 7}};
assert(func0(test1) == result1);
std::set<std::pair<int, int>> test2 = {{7, 8}, {3, 4}, {8, 7}, {10, 9}, {11, 3}, {9, 10}};
std::set<... | O3 | cpp | func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r15
push %r14
mov %rdi,%r14
push %r13
push %r12
push %rbp
push %rbx
lea 0x8(%rsi),%rbx
sub $0x58,%rsp
mov 0x18(%rsi),%rbp
mov %rsi,(%rsp)
lea 0x18(%rsp),%r13
m... | _Z5func0RKSt3setISt4pairIiiESt4lessIS1_ESaIS1_EE:
endbr64
push r14
push r13
push r12
mov r12, rdi
push rbp
lea rbp, [rsi+8]
push rbx
sub rsp, 40h
mov rbx, [rsi+18h]
mov rax, fs:28h
mov [rsp+68h+var_30], rax
xor eax, eax
lea r14, [rsp+68h+var_60]
mov [rsp+68h+var_60], 0... | long long func0(long long a1, long long a2, long long a3)
{
long long v4; // rbp
long long v5; // rbx
long long v6; // r13
long long v7; // rax
long long v8; // rcx
int *v9; // rbx
_QWORD *v10; // rbx
void *v11; // rdi
long long v13; // [rsp+0h] [rbp-68h] BYREF
int v14; // [rsp+8h] [rbp-60h] BYREF
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
LEA RBP,[RSI + 0x8]
PUSH RBX
SUB RSP,0x40
MOV RBX,qword ptr [RSI + 0x18]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
LEA R14,[RSP + 0x8]
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],R14
M... | /* func0(std::set<std::pair<int, int>, std::less<std::pair<int, int> >,
std::allocator<std::pair<int, int> > > const&) */
set * func0(set *param_1)
{
_Rb_tree_node_base *p_Var1;
int iVar2;
void *pvVar3;
void *pvVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
... |
1,960 | func0 |
#include <cmath>
#include <cassert>
| double func0(double a, int n, double r) {
double total = (a * (1 - std::pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1, 5, 2) == 31);
assert(func0(1, 5, 4) == 341);
assert(func0(2, 6, 3) == 728);
return 0;
}
| O0 | cpp | func0(double, int, double):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
movsd %xmm0,-0x18(%rbp)
mov %edi,-0x1c(%rbp)
movsd %xmm1,-0x28(%rbp)
mov -0x1c(%rbp),%edx
mov -0x28(%rbp),%rax
mov %edx,%edi
movq %rax,%xmm0
callq 12d5 <_ZSt3powIdiEN9__gnu_cxx11__promote_2IT_T0_NS0_9__promoteIS2_XsrSt12... | _Z5func0did:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
movsd [rbp+var_18], xmm0
mov [rbp+var_1C], edi
movsd [rbp+var_28], xmm1
mov edx, [rbp+var_1C]
mov rax, [rbp+var_28]
mov edi, edx
movq xmm0, rax
call _ZSt3powIdiEN9__gnu_cxx11__promote_2IDTplcvNS1_IT_XsrSt12__is_integerIS2_E7__v... | double func0(double a1, unsigned int a2, double a3)
{
return (1.0 - std::pow<double,int>(a2, a3)) * a1 / (1.0 - a3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOVSD qword ptr [RBP + -0x18],XMM0
MOV dword ptr [RBP + -0x1c],EDI
MOVSD qword ptr [RBP + -0x28],XMM1
MOV EDX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x28]
MOV EDI,EDX
MOVQ XMM0,RAX
CALL 0x0010131d
MOVAPD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00102080]
SUBSD XMM0,X... | /* func0(double, int, double) */
double func0(double param_1,int param_2,double param_3)
{
double extraout_XMM0_Qa;
std::pow<double,int>(param_3,param_2);
return ((DAT_00102080 - extraout_XMM0_Qa) * param_1) / (DAT_00102080 - param_3);
} |
1,961 | func0 |
#include <cmath>
#include <cassert>
| double func0(double a, int n, double r) {
double total = (a * (1 - std::pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1, 5, 2) == 31);
assert(func0(1, 5, 4) == 341);
assert(func0(2, 6, 3) == 728);
return 0;
}
| O1 | cpp | func0(double, int, double):
endbr64
sub $0x18,%rsp
movsd %xmm0,(%rsp)
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
movsd %xmm3,0x8(%rsp)
movapd %xmm3,%xmm0
callq 1060 <pow@plt>
movsd 0xeff(%rip),%xmm1
movapd %xmm1,%xmm2
subsd %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd (%rsp),%xmm0
subsd 0x8(%rsp),%xmm1... | _Z5func0did:
endbr64
sub rsp, 18h
movsd [rsp+18h+var_18], xmm0
movapd xmm4, xmm1
pxor xmm1, xmm1
cvtsi2sd xmm1, edi; y
movsd [rsp+18h+var_10], xmm4
movapd xmm0, xmm4; x
call _pow
movsd xmm1, cs:dbl_2070
movapd xmm3, xmm1
subsd xmm3, xmm0
movapd xmm0, xmm3
mulsd xmm0, [rsp+18h+var_18]
subsd xmm... | double func0(double a1, int a2, double a3)
{
return (1.0 - pow(a3, (double)a2)) * a1 / (1.0 - a3);
} | func0:
ENDBR64
SUB RSP,0x18
MOVSD qword ptr [RSP],XMM0
MOVAPD XMM4,XMM1
PXOR XMM1,XMM1
CVTSI2SD XMM1,EDI
MOVSD qword ptr [RSP + 0x8],XMM4
MOVAPD XMM0,XMM4
CALL 0x00101060
MOVSD XMM1,qword ptr [0x00102070]
MOVAPD XMM3,XMM1
SUBSD XMM3,XMM0
MOVAPD XMM0,XMM3
MULSD XMM0,qword ptr [RSP]
SUBSD XMM1,qword ptr [RSP + 0x8]
DIVSD... | /* func0(double, int, double) */
double func0(double param_1,int param_2,double param_3)
{
double dVar1;
dVar1 = pow(param_3,(double)param_2);
return ((DAT_00102070 - dVar1) * param_1) / (DAT_00102070 - param_3);
} |
1,962 | func0 |
#include <cmath>
#include <cassert>
| double func0(double a, int n, double r) {
double total = (a * (1 - std::pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1, 5, 2) == 31);
assert(func0(1, 5, 4) == 341);
assert(func0(2, 6, 3) == 728);
return 0;
}
| O2 | cpp | func0(double, int, double):
endbr64
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
sub $0x18,%rsp
cvtsi2sd %edi,%xmm1
movsd %xmm0,(%rsp)
movapd %xmm3,%xmm0
movsd %xmm3,0x8(%rsp)
callq 1050 <pow@plt>
movsd 0xe78(%rip),%xmm2
movsd 0x8(%rsp),%xmm3
movapd %xmm2,%xmm4
subsd %xmm3,%xmm2
subsd %xmm0,%xmm4
movsd (%rsp),%xmm0... | _Z5func0did:
endbr64
movapd xmm3, xmm1
pxor xmm1, xmm1
sub rsp, 18h
cvtsi2sd xmm1, edi; y
movsd [rsp+18h+var_18], xmm0
movapd xmm0, xmm3; x
movsd [rsp+18h+var_10], xmm3
call _pow
movsd xmm2, cs:qword_2008
movsd xmm3, [rsp+18h+var_10]
movapd xmm4, xmm2
subsd xmm2, xmm3
subsd xmm4, xmm0
movsd x... | double func0(double a1, int a2, double a3)
{
return a1 * (1.0 - pow(a3, (double)a2)) / (1.0 - a3);
} | func0:
ENDBR64
MOVAPD XMM3,XMM1
PXOR XMM1,XMM1
SUB RSP,0x18
CVTSI2SD XMM1,EDI
MOVSD qword ptr [RSP],XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x8],XMM3
CALL 0x00101050
MOVSD XMM2,qword ptr [0x00102008]
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM4,XMM2
SUBSD XMM2,XMM3
SUBSD XMM4,XMM0
MOVSD XMM0,qword ptr [RSP]
ADD RS... | /* func0(double, int, double) */
double func0(double param_1,int param_2,double param_3)
{
double dVar1;
dVar1 = pow(param_3,(double)param_2);
return (param_1 * (DAT_00102008 - dVar1)) / (DAT_00102008 - param_3);
} |
1,963 | func0 |
#include <cmath>
#include <cassert>
| double func0(double a, int n, double r) {
double total = (a * (1 - std::pow(r, n))) / (1 - r);
return total;
}
| int main() {
assert(func0(1, 5, 2) == 31);
assert(func0(1, 5, 4) == 341);
assert(func0(2, 6, 3) == 728);
return 0;
}
| O3 | cpp | func0(double, int, double):
endbr64
movapd %xmm1,%xmm3
pxor %xmm1,%xmm1
sub $0x18,%rsp
cvtsi2sd %edi,%xmm1
movsd %xmm0,(%rsp)
movapd %xmm3,%xmm0
movsd %xmm3,0x8(%rsp)
callq 1050 <pow@plt>
movsd 0xe78(%rip),%xmm2
movsd 0x8(%rsp),%xmm3
movapd %xmm2,%xmm4
subsd %xmm3,%xmm2
subsd %xmm0,%xmm4
movsd (%rsp),%xmm0... | _Z5func0did:
endbr64
movapd xmm3, xmm1
pxor xmm1, xmm1
sub rsp, 18h
cvtsi2sd xmm1, edi; y
movsd [rsp+18h+var_18], xmm0
movapd xmm0, xmm3; x
movsd [rsp+18h+var_10], xmm3
call _pow
movsd xmm2, cs:qword_2008
movsd xmm3, [rsp+18h+var_10]
movapd xmm4, xmm2
subsd xmm2, xmm3
subsd xmm4, xmm0
movsd x... | double func0(double a1, int a2, double a3)
{
return a1 * (1.0 - pow(a3, (double)a2)) / (1.0 - a3);
} | func0:
ENDBR64
MOVAPD XMM3,XMM1
PXOR XMM1,XMM1
SUB RSP,0x18
CVTSI2SD XMM1,EDI
MOVSD qword ptr [RSP],XMM0
MOVAPD XMM0,XMM3
MOVSD qword ptr [RSP + 0x8],XMM3
CALL 0x00101050
MOVSD XMM2,qword ptr [0x00102008]
MOVSD XMM3,qword ptr [RSP + 0x8]
MOVAPD XMM4,XMM2
SUBSD XMM2,XMM3
SUBSD XMM4,XMM0
MOVSD XMM0,qword ptr [RSP]
ADD RS... | /* func0(double, int, double) */
double func0(double param_1,int param_2,double param_3)
{
double dVar1;
dVar1 = pow(param_3,(double)param_2);
return (param_1 * (DAT_00102008 - dVar1)) / (DAT_00102008 - param_3);
} |
1,964 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& item_list, int item) {
int first = 0;
int last = item_list.size() - 1;
bool found = false;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = true;
} else {
if (... | int main() {
assert(func0({1,2,3,5,8}, 6) == false);
assert(func0({7, 8, 9, 10, 13}, 10) == true);
assert(func0({11, 13, 14, 19, 22, 36}, 23) == false);
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,-0xc(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 15b0 <_ZNKSt6vectorIiSaIiEE4sizeEv>
sub $0x1,%eax
mov %eax,-0x8(%rbp)
movb $0x0... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
sub eax, 1
mov [rbp+var_8], eax
mov [rb... | long long func0(long long a1, int a2)
{
unsigned __int8 v3; // [rsp+13h] [rbp-Dh]
int v4; // [rsp+14h] [rbp-Ch]
int v5; // [rsp+18h] [rbp-8h]
int v6; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = std::vector<int>::size(a1) - 1;
v3 = 0;
while ( v4 <= v5 && v3 != 1 )
{
v6 = (v4 + v5) / 2;
if ( a2 == *(_D... | 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 + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x0010163e
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
MOV byte ptr [RBP + -0xd],0x0
JMP 0x001012eb
LAB_0010127b:
MOV EDX,dword ... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
char func0(vector *param_1,int param_2)
{
int iVar1;
int *piVar2;
int local_15;
int4 local_14;
int4 local_10;
local_14 = 0;
local_10 = std::vector<int,std::allocator<int>>::size((vector<int,std::allocator<int>> *)param_1);
local_10 = l... |
1,965 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& item_list, int item) {
int first = 0;
int last = item_list.size() - 1;
bool found = false;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = true;
} else {
if (... | int main() {
assert(func0({1,2,3,5,8}, 6) == false);
assert(func0({7, 8, 9, 10, 13}, 10) == true);
assert(func0({11, 13, 14, 19, 22, 36}, 23) == false);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbx
mov (%rdi),%r11
mov 0x8(%rdi),%rcx
sub %r11,%rcx
sar $0x2,%rcx
sub $0x1,%ecx
mov $0x0,%edi
mov $0x0,%ebx
mov $0x1,%r9d
lea (%rdi,%rcx,1),%eax
mov %eax,%r10d
shr $0x1f,%r10d
add %eax,%r10d
sar %r10d
movs... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbx
mov r10d, esi
mov r11, [rdi]
mov rcx, [rdi+8]
sub rcx, r11
sar rcx, 2
sub ecx, 1
mov esi, 0
mov ebx, 0
loc_122C:
lea eax, [rcx+rsi]
mov r9d, eax
shr r9d, 1Fh
add r9d, eax
sar r9d, 1
movsxd rax, r9d
lea r8, [r11+ra... | long long func0(long long *a1, int a2)
{
long long v3; // r11
int v4; // ecx
int v5; // esi
int v6; // r9d
unsigned int v7; // eax
unsigned int v8; // edi
int v9; // edx
v3 = *a1;
v4 = ((a1[1] - *a1) >> 2) - 1;
v5 = 0;
LABEL_2:
v6 = (v4 + v5) / 2;
v7 = 0;
while ( 1 )
{
v8 = v7;
v7 ... | func0:
ENDBR64
PUSH RBX
MOV R10D,ESI
MOV R11,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
SUB RCX,R11
SAR RCX,0x2
SUB ECX,0x1
MOV ESI,0x0
MOV EBX,0x0
LAB_0010122c:
LEA EAX,[RCX + RSI*0x1]
MOV R9D,EAX
SHR R9D,0x1f
ADD R9D,EAX
SAR R9D,0x1
MOVSXD RAX,R9D
LEA R8,[R11 + RAX*0x4]
MOV EAX,EBX
LAB_00101245:
MOV EDI,EAX
CMP EC... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
byte func0(vector *param_1,int param_2)
{
int iVar1;
byte bVar2;
byte bVar3;
int iVar4;
int iVar5;
int iVar6;
iVar4 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
iVar5 = 0;
do {
iVar6 = (iVar4 + iVar5) / 2;
bV... |
1,966 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& item_list, int item) {
int first = 0;
int last = item_list.size() - 1;
bool found = false;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = true;
} else {
if (... | int main() {
assert(func0({1,2,3,5,8}, 6) == false);
assert(func0({7, 8, 9, 10, 13}, 10) == true);
assert(func0({11, 13, 14, 19, 22, 36}, 23) == false);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r9
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
sub %r9,%rcx
sar $0x2,%rcx
sub $0x1,%ecx
lea (%rcx,%r8,1),%edi
sar %edi
movslq %edi,%rax
lea (%r9,%rax,4),%rdx
xor %eax,%eax
cmp %r8d,%ecx
jl 1415 <_Z5func0RKSt6vectorI... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rcx, [rdi+8]
xor edi, edi
sub rcx, r8
sar rcx, 2
sub ecx, 1
loc_13A7:
lea eax, [rcx+rdi]
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
movsxd rax, edx
lea rax, [r8+rax*4]
cmp ecx, edi
jl short loc_13E5
... | long long func0(long long *a1, int a2)
{
long long v2; // r8
long long v3; // rcx
int v4; // edi
int v5; // ecx
int v6; // edx
_DWORD *v7; // rax
v2 = *a1;
v3 = a1[1];
v4 = 0;
v5 = ((v3 - v2) >> 2) - 1;
while ( 1 )
{
v6 = (v5 + v4) / 2;
v7 = (_DWORD *)(v2 + 4LL * v6);
if ( v5 < v4 ... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
XOR EDI,EDI
SUB RCX,R8
SAR RCX,0x2
SUB ECX,0x1
LAB_001013a7:
LEA EAX,[RCX + RDI*0x1]
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
MOVSXD RAX,EDX
LEA RAX,[R8 + RAX*0x4]
CMP ECX,EDI
JL 0x001013e5
CMP dword ptr [RAX],ESI
JNZ 0x001013d0
MOV EAX,0x1
RET... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int8 func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 0;
iVar2 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
while( true ) {
iVar3 = (iVar2 + iVar4) / 2;
if (iVar2 < iVar4) ... |
1,967 | func0 |
#include <vector>
#include <assert.h>
| bool func0(const std::vector<int>& item_list, int item) {
int first = 0;
int last = item_list.size() - 1;
bool found = false;
while (first <= last && !found) {
int mid = (first + last) / 2;
if (item_list[mid] == item) {
found = true;
} else {
if (... | int main() {
assert(func0({1,2,3,5,8}, 6) == false);
assert(func0({7, 8, 9, 10, 13}, 10) == true);
assert(func0({11, 13, 14, 19, 22, 36}, 23) == false);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
mov (%rdi),%r9
mov 0x8(%rdi),%rcx
xor %r8d,%r8d
sub %r9,%rcx
sar $0x2,%rcx
sub $0x1,%ecx
lea (%rcx,%r8,1),%edi
sar %edi
movslq %edi,%rax
lea (%r9,%rax,4),%rdx
xor %eax,%eax
cmp %r8d,%ecx
jl 13e5 <_Z5func0RKSt6vectorI... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
mov r8, [rdi]
mov rcx, [rdi+8]
xor edi, edi
sub rcx, r8
sar rcx, 2
sub ecx, 1
loc_13A7:
lea eax, [rcx+rdi]
mov edx, eax
shr edx, 1Fh
add edx, eax
sar edx, 1
movsxd rax, edx
lea rax, [r8+rax*4]
cmp ecx, edi
jl short loc_13E5
... | long long func0(long long *a1, int a2)
{
long long v2; // r8
long long v3; // rcx
int v4; // edi
int v5; // ecx
int v6; // edx
_DWORD *v7; // rax
v2 = *a1;
v3 = a1[1];
v4 = 0;
v5 = ((v3 - v2) >> 2) - 1;
while ( 1 )
{
v6 = (v5 + v4) / 2;
v7 = (_DWORD *)(v2 + 4LL * v6);
if ( v5 < v4 ... | func0:
ENDBR64
MOV R8,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
XOR EDI,EDI
SUB RCX,R8
SAR RCX,0x2
SUB ECX,0x1
LAB_001013a7:
LEA EAX,[RCX + RDI*0x1]
MOV EDX,EAX
SHR EDX,0x1f
ADD EDX,EAX
SAR EDX,0x1
MOVSXD RAX,EDX
LEA RAX,[R8 + RAX*0x4]
CMP ECX,EDI
JL 0x001013e5
CMP dword ptr [RAX],ESI
JNZ 0x001013d0
MOV EAX,0x1
RET... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
int8 func0(vector *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 0;
iVar2 = (int)(*(long *)(param_1 + 8) - *(long *)param_1 >> 2) + -1;
while( true ) {
iVar3 = (iVar2 + iVar4) / 2;
if (iVar2 < iVar4) ... |
1,968 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
#include <tuple>
typedef std::tuple<double, double> Point;
typedef std::vector<Point> Polygon;
| std::vector<Polygon> func0(double startx, double starty, double endx, double endy, double radius) {
double pi = 3.14159265358979323846;
double radians30 = pi / 6;
double degrees30 = 30;
double sl = (2 * radius) * tan(radians30);
double p = sl * 0.5;
double b = sl * cos(pi / 6); // cos(30 ... | int main() {
assert(func0(1,1, 4, 4, 3)[0][0] == Point(-5.0, -4.196152422706632));
assert(func0(5,4,7,9,8)[0][0] == Point(-11.0, -9.856406460551018));
assert(func0(9,6,4,3,2)[0][0] == Point(5.0, 2.5358983848622456));
return 0;
}
| O0 | cpp | func0(double, double, double, double, double):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x1b8,%rsp
mov %rdi,-0x198(%rbp)
movsd %xmm0,-0x1a0(%rbp)
movsd %xmm1,-0x1a8(%rbp)
movsd %xmm2,-0x1b0(%rbp)
movsd %xmm3,-0x1b8(%rbp)
movsd %xmm4,-0x1c0(%rbp)
mov %fs:0x28,%rax
mov ... | _Z5func0ddddd:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 1C8h
mov [rbp+var_1A8], rdi
movsd [rbp+var_1B0], xmm0
movsd [rbp+var_1B8], xmm1
movsd [rbp+var_1C0], xmm2
movsd [rbp+var_1C8], xmm3
movsd [rbp+var_1D0], xmm4
mov rax, fs:28h
mov [rbp+var_28], rax
x... | long long func0(double a1, double a2, double a3, double a4, double a5, long long a6)
{
double v7; // [rsp+18h] [rbp-1C8h]
double v8; // [rsp+20h] [rbp-1C0h]
double v9; // [rsp+28h] [rbp-1B8h] BYREF
double v10; // [rsp+30h] [rbp-1B0h] BYREF
long long v11; // [rsp+38h] [rbp-1A8h]
char v12; // [rsp+4Fh] [rbp-... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x1c8
MOV qword ptr [RBP + -0x1a8],RDI
MOVSD qword ptr [RBP + -0x1b0],XMM0
MOVSD qword ptr [RBP + -0x1b8],XMM1
MOVSD qword ptr [RBP + -0x1c0],XMM2
MOVSD qword ptr [RBP + -0x1c8],XMM3
MOVSD qword ptr [RBP + -0x1d0],XMM4
MOV RAX,qword ptr FS:[0x28]
MO... | /* func0(double, double, double, double, double) */
vector<std::vector<std::tuple<double,double>,std::allocator<std::tuple<double,double>>>,std::allocator<std::vector<std::tuple<double,double>,std::allocator<std::tuple<double,double>>>>>
* func0(double param_1,double param_2,double param_3,double param_4,double param_... |
1,969 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
#include <tuple>
typedef std::tuple<double, double> Point;
typedef std::vector<Point> Polygon;
| std::vector<Polygon> func0(double startx, double starty, double endx, double endy, double radius) {
double pi = 3.14159265358979323846;
double radians30 = pi / 6;
double degrees30 = 30;
double sl = (2 * radius) * tan(radians30);
double p = sl * 0.5;
double b = sl * cos(pi / 6); // cos(30 ... | int main() {
assert(func0(1,1, 4, 4, 3)[0][0] == Point(-5.0, -4.196152422706632));
assert(func0(5,4,7,9,8)[0][0] == Point(-11.0, -9.856406460551018));
assert(func0(9,6,4,3,2)[0][0] == Point(5.0, 2.5358983848622456));
return 0;
}
| O1 | cpp | func0(double, double, double, double, double):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x108,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0xf8(%rsp)
xor %eax,%eax
addsd %xmm4,%xmm4
mulsd 0xe98(%rip),%xmm4
movapd %xmm4,%xmm5
mulsd 0xe94(%rip),%xmm5
movsd %... | _Z5func0ddddd:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov r13, rdi
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
addsd xmm4, xmm4
mulsd xmm4, cs:qword_2110
movapd xmm5, xmm4
mulsd xmm5, cs:qword_2118
movsd [rsp+138h+var_F0], x... | _QWORD * func0(double a1, double a2, double a3, double a4, double a5, _QWORD *a6)
{
double v6; // xmm4_8
__m128i *v8; // rbx
const __m128i *v9; // rax
__m128i *v10; // rdx
_QWORD *v11; // r12
long long v12; // rax
long long j; // rdx
double v14; // xmm0_8
double v15; // xmm1_8
double v16; // [rsp+0h... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV R13,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
ADDSD XMM4,XMM4
MULSD XMM4,qword ptr [0x00102110]
MOVAPD XMM5,XMM4
MULSD XMM5,qword ptr [0x00102118]
MOVSD qword ptr [RSP + 0x48],XMM5
MOVAPD XMM6,XMM4
MU... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double, double, double) */
void func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
int8 *puVar1;
double dVar2;
int8 uVar3;
bool bVar4;
double *pdVar5;
void *pvVar6... |
1,970 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
#include <tuple>
typedef std::tuple<double, double> Point;
typedef std::vector<Point> Polygon;
| std::vector<Polygon> func0(double startx, double starty, double endx, double endy, double radius) {
double pi = 3.14159265358979323846;
double radians30 = pi / 6;
double degrees30 = 30;
double sl = (2 * radius) * tan(radians30);
double p = sl * 0.5;
double b = sl * cos(pi / 6); // cos(30 ... | int main() {
assert(func0(1,1, 4, 4, 3)[0][0] == Point(-5.0, -4.196152422706632));
assert(func0(5,4,7,9,8)[0][0] == Point(-11.0, -9.856406460551018));
assert(func0(9,6,4,3,2)[0][0] == Point(5.0, 2.5358983848622456));
return 0;
}
| O2 | cpp | func0(double, double, double, double, double):
endbr64
push %r13
addsd %xmm4,%xmm4
mov $0x1,%r13d
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x118,%rsp
movsd 0xc92(%rip),%xmm7
movsd 0xc82(%rip),%xmm5
mulsd 0xc72(%rip),%xmm4
lea 0x100(%rsp),%rbx
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
... | _Z5func0ddddd:
endbr64
push r15
addsd xmm4, xmm4
push r14
mov r14d, 1
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 128h
movsd xmm6, cs:qword_2120
movsd xmm5, cs:qword_2118
mov rax, fs:28h
mov [rsp+158h+var_40], rax
xor eax, eax
mulsd xmm4, cs:qword_2110
mov... | long long func0(double a1, double a2, double a3, double a4, double a5, long long a6)
{
char v6; // r14
double v7; // xmm4_8
double v8; // r15
__m128d v9; // xmm1
__m128i *v10; // rax
long long v11; // rdx
__m128i v12; // xmm0
__m128i v13; // xmm6
__m128i v14; // xmm3
__m128i v15; // xmm7
__m128i ... | func0:
ENDBR64
PUSH R15
ADDSD XMM4,XMM4
PUSH R14
MOV R14D,0x1
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOVSD XMM6,qword ptr [0x00102120]
MOVSD XMM5,qword ptr [0x00102118]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
XOR EAX,EAX
MULSD XMM4,qword ptr [0x00102110]
MOV qword ptr [RDI + 0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double, double, double) */
void func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
long lVar1;
int (*pauVar2) [16];
double dVar3;
double dVar4;
double dVar5;
doubl... |
1,971 | func0 |
#include <vector>
#include <cmath>
#include <assert.h>
#include <tuple>
typedef std::tuple<double, double> Point;
typedef std::vector<Point> Polygon;
| std::vector<Polygon> func0(double startx, double starty, double endx, double endy, double radius) {
double pi = 3.14159265358979323846;
double radians30 = pi / 6;
double degrees30 = 30;
double sl = (2 * radius) * tan(radians30);
double p = sl * 0.5;
double b = sl * cos(pi / 6); // cos(30 ... | int main() {
assert(func0(1,1, 4, 4, 3)[0][0] == Point(-5.0, -4.196152422706632));
assert(func0(5,4,7,9,8)[0][0] == Point(-11.0, -9.856406460551018));
assert(func0(9,6,4,3,2)[0][0] == Point(5.0, 2.5358983848622456));
return 0;
}
| O3 | cpp | func0(double, double, double, double, double):
endbr64
push %r12
addsd %xmm4,%xmm4
mov %rdi,%r12
push %rbp
push %rbx
mov $0x1,%ebx
sub $0x110,%rsp
movsd 0xc95(%rip),%xmm6
movsd 0xc85(%rip),%xmm5
mov %fs:0x28,%rax
mov %rax,0x108(%rsp)
xor %eax,%eax
mulsd 0xc62(%rip),%xmm4
movq $0x0,0x10(%rd... | _Z5func0ddddd:
endbr64
push r15
addsd xmm4, xmm4
push r14
mov r14d, 1
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 128h
movsd xmm6, cs:qword_2128
movsd xmm5, cs:qword_2120
mov rax, fs:28h
mov [rsp+158h+var_40], rax
xor eax, eax
mulsd xmm4, cs:qword_2118
mov... | long long func0(double a1, double a2, double a3, double a4, double a5, long long a6)
{
char v6; // r14
double v7; // xmm4_8
double v8; // r15
__m128d v9; // xmm1
__m128i *v10; // rax
long long v11; // rdx
__m128i v12; // xmm0
__m128i v13; // xmm6
__m128i v14; // xmm3
__m128i v15; // xmm7
__m128i ... | func0:
ENDBR64
PUSH R15
ADDSD XMM4,XMM4
PUSH R14
MOV R14D,0x1
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x128
MOVSD XMM6,qword ptr [0x00102128]
MOVSD XMM5,qword ptr [0x00102120]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x118],RAX
XOR EAX,EAX
MULSD XMM4,qword ptr [0x00102118]
MOV qword ptr [RDI + 0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(double, double, double, double, double) */
void func0(double param_1,double param_2,double param_3,double param_4,double param_5)
{
long lVar1;
int (*pauVar2) [16];
double dVar3;
double dVar4;
double dVar5;
doubl... |
1,972 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& test_tup) {
std::string binary_str;
for (int ele : test_tup) {
binary_str += std::to_string(ele);
}
int res = std::stoi(binary_str, nullptr, 2);
return std::to_string(res);
}
| int main() {
assert(func0({1, 1, 0, 1, 0, 0, 1}) == "105");
assert(func0({0, 1, 1, 0, 0, 1, 0, 1}) == "101");
assert(func0({1, 1, 0, 1, 0, 1}) == "53");
return 0;
}
| O0 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 23e0 <_ZNSt7__cxx1112basic_str... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 88h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_60]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIc... | std::__cxx11 * func0[abi:cxx11](std::__cxx11 *a1, long long a2)
{
int v3; // [rsp+10h] [rbp-80h]
int v4; // [rsp+14h] [rbp-7Ch]
long long v5; // [rsp+18h] [rbp-78h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v7[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+50h] [rbp-40h] BYREF
unsign... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV RDI,RAX
CALL 0x001022f0
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x68],RAX
M... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
bool bVar1;
vector<int,std::allocator<int>> *in_RSI;
long in_FS_OFFSET;
int8 local_80;
int8 local_78;
vector<int,std::allocator<int>> *local_70;
string local_68 [32];
string local_48 [40]... |
1,973 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& test_tup) {
std::string binary_str;
for (int ele : test_tup) {
binary_str += std::to_string(ele);
}
int res = std::stoi(binary_str, nullptr, 2);
return std::to_string(res);
}
| int main() {
assert(func0({1, 1, 0, 1, 0, 0, 1}) == "105");
assert(func0({0, 1, 1, 0, 0, 1, 0, 1}) == "101");
assert(func0({1, 1, 0, 1, 0, 1}) == "53");
return 0;
}
| O1 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%r13
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rax
mov %rax,0x10(%rsp)
movq $0x0,0x18(%rsp)
movb $0x0,0x20(%rsp)
mov (%rs... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_A0], rdi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rsp+0B8h+var_78]
mov [rsp+0B8h+var_88], rax
mov [rsp+0B8h+var_80],... | _QWORD * func0[abi:cxx11](_QWORD *a1, unsigned int **a2)
{
unsigned int *v2; // r14
unsigned int v3; // ebx
unsigned int v4; // r13d
unsigned int v5; // ebp
unsigned int v6; // eax
void *v7; // r12
int *v8; // rbx
int v9; // ebp
long long v10; // rax
unsigned int v11; // r12d
unsigned int v12; // ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],0x0
MOV byte ptr [RSP + 0x40],0x0
MOV R14,qwor... | /* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
int iVar1;
uint *puVar2;
int *puVar3;
int *piVar4;
int8 uVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
int8 *in_RSI;
uint *puVar12;
long in... |
1,974 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& test_tup) {
std::string binary_str;
for (int ele : test_tup) {
binary_str += std::to_string(ele);
}
int res = std::stoi(binary_str, nullptr, 2);
return std::to_string(res);
}
| int main() {
assert(func0({1, 1, 0, 1, 0, 0, 1}) == "105");
assert(func0({0, 1, 1, 0, 0, 1, 0, 1}) == "101");
assert(func0({1, 1, 0, 1, 0, 1}) == "53");
return 0;
}
| O2 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rax
movb $0x0,0x3... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbp, [rsi]
mov [rsp+188h+var_178], rdi
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148]... | long long * func0[abi:cxx11](long long *a1, unsigned int **a2)
{
unsigned int *v2; // rbp
unsigned int *v3; // rax
unsigned int v4; // ebx
unsigned int v5; // ecx
unsigned int v6; // r15d
unsigned int v7; // r13d
int v8; // esi
unsigned int v9; // r14d
__int8 *v10; // rbx
unsigned int v11; // eax
... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBP,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RS... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
uint uVar1;
uint *puVar2;
long lVar3;
byte bVar4;
int *puVar5;
uint uVar6;
int *piVar7;
ulong uVar8;
... |
1,975 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <assert.h>
| std::string func0(const std::vector<int>& test_tup) {
std::string binary_str;
for (int ele : test_tup) {
binary_str += std::to_string(ele);
}
int res = std::stoi(binary_str, nullptr, 2);
return std::to_string(res);
}
| int main() {
assert(func0({1, 1, 0, 1, 0, 0, 1}) == "105");
assert(func0({0, 1, 1, 0, 0, 1, 0, 1}) == "101");
assert(func0({1, 1, 0, 1, 0, 1}) == "53");
return 0;
}
| O3 | cpp | func0[abi:cxx11](std::vector<int, std::allocator<int> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %rdi,0x10(%rsp)
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
lea 0x40(%rsp),%rax
movb $0... | _Z5func0B5cxx11RKSt6vectorIiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 158h
mov rbp, [rsi]
mov [rsp+188h+var_178], rdi
mov rax, fs:28h
mov [rsp+188h+var_40], rax
xor eax, eax
lea rax, [rsp+188h+var_148]
mov byte ptr [rsp+188h+var_148]... | long long * func0[abi:cxx11](long long *a1, unsigned int **a2)
{
unsigned int *v2; // rbp
unsigned int *v3; // rax
unsigned int v4; // ebx
unsigned int v5; // ecx
unsigned int v6; // r15d
unsigned int v7; // r13d
int v8; // esi
unsigned int v9; // r14d
__int8 *v10; // rbx
unsigned int v11; // eax
... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x158
MOV RBP,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x148],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x40]
MOV byte ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RS... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](std::vector<int, std::allocator<int> > const&) */
vector * func0_abi_cxx11_(vector *param_1)
{
uint uVar1;
uint *puVar2;
long lVar3;
byte bVar4;
int *puVar5;
uint uVar6;
int *piVar7;
ulong uVar8;
... |
1,976 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::regex lowercase_regex("[a-z]");
std::string result = std::regex_replace(str1, lowercase_regex, "");
return result;
}
| int main() {
assert(func0("KDeoALOklOOHserfLoAJSIskdsf") == "KDALOOOHLAJSI");
assert(func0("ProducTnamEstreAmIngMediAplAYer") == "PTEAIMAAY");
assert(func0("maNufacTuredbYSheZenTechNolOGIes") == "NTYSZTNOGI");
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 ... | _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, aAZ; "[a-z]"
mov ... | 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, "[a-z]", 16LL);
std::regex_replace<std::regex_traits<char>,char,std::char_traits<c... | 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 ... | /* 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,"[a-z]",0x10);
/* try { // try from 00104b84 to 00104b88 has its CatchHan... |
1,977 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::regex lowercase_regex("[a-z]");
std::string result = std::regex_replace(str1, lowercase_regex, "");
return result;
}
| int main() {
assert(func0("KDeoALOklOOHserfLoAJSIskdsf") == "KDALOOOHLAJSI");
assert(func0("ProducTnamEstreAmIngMediAplAYer") == "PTEAIMAAY");
assert(func0("maNufacTuredbYSheZenTechNolOGIes") == "NTYSZTNOGI");
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 <_ZNS... | _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 __Z... | 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... | 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,[0x... | /* 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... |
1,978 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::regex lowercase_regex("[a-z]");
std::string result = std::regex_replace(str1, lowercase_regex, "");
return result;
}
| int main() {
assert(func0("KDeoALOklOOHserfLoAJSIskdsf") == "KDALOOOHLAJSI");
assert(func0("ProducTnamEstreAmIngMediAplAYer") == "PTEAIMAAY");
assert(func0("maNufacTuredbYSheZenTechNolOGIes") == "NTYSZTNOGI");
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... | _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... | 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+10... | 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,[0x11a6d8]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* 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::... |
1,979 | func0 |
#include <iostream>
#include <string>
#include <regex>
#include <assert.h>
| std::string func0(const std::string& str1) {
std::regex lowercase_regex("[a-z]");
std::string result = std::regex_replace(str1, lowercase_regex, "");
return result;
}
| int main() {
assert(func0("KDeoALOklOOHserfLoAJSIskdsf") == "KDALOOOHLAJSI");
assert(func0("ProducTnamEstreAmIngMediAplAYer") == "PTEAIMAAY");
assert(func0("maNufacTuredbYSheZenTechNolOGIes") == "NTYSZTNOGI");
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... | _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+... | _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; //... | 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 0x... | /* 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;
lon... |
1,980 | func0 |
#include <vector>
#include <queue>
#include <cassert>
#include <functional>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::priority_queue<int, std::vector<int>, std::greater<int>> pq(nums.begin(), nums.end());
std::vector<int> smallest_nums;
for (int i = 0; i < n; i++) {
smallest_nums.push_back(pq.top());
pq.pop();
}
return smalles... | int main() {
assert((func0( {25, 35, 22, 85, 14, 65, 75, 25, 58}, 3) == std::vector<int>{14, 22, 25}));
assert((func0( {25, 35, 22, 85, 14, 65, 75, 25, 58}, 2) == std::vector<int>{14, 22}));
assert((func0( {25, 35, 22, 85, 14, 65, 75, 22, 58}, 5) == std::vector<int>{14, 22, 22, 25, 35}));
retu... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x88,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %edx,-0x84(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_60]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE3endEv; std... | long long func0(long long a1, long long a2, int a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // rax
char v8; // [rsp+2Bh] [rbp-45h] BYREF
int i; // [rsp+2Ch] [rbp-44h]
_BYTE v10[40]; // [rsp+30h] [rbp-40h] BYREF
unsigned long long v11; // [rsp+58h] [rbp-18h]
v11 = __readfsqword(0x28u)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
CALL 0x00101bae
MOV RBX,RAX
MOV RAX,qword ptr [RBP... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
__normal_iterator _Var1;
greater *pgVar2;
int *piVar3;
int in_EDX;
int4 in_register_00000034;
long in_FS_OFFSET;
int local_4c;
priority_queue<int,std::vector<int,std::allocator<int>>,std::grea... |
1,981 | func0 |
#include <vector>
#include <queue>
#include <cassert>
#include <functional>
| std::vector<int> func0(const std::vector<int>& nums, int n) {
std::priority_queue<int, std::vector<int>, std::greater<int>> pq(nums.begin(), nums.end());
std::vector<int> smallest_nums;
for (int i = 0; i < n; i++) {
smallest_nums.push_back(pq.top());
pq.pop();
}
return smalles... | int main() {
assert((func0( {25, 35, 22, 85, 14, 65, 75, 25, 58}, 3) == std::vector<int>{14, 22, 25}));
assert((func0( {25, 35, 22, 85, 14, 65, 75, 25, 58}, 2) == std::vector<int>{14, 22}));
assert((func0( {25, 35, 22, 85, 14, 65, 75, 22, 58}, 5) == std::vector<int>{14, 22, 22, 25, 35}));
retu... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %rdi,%rbx
mov %edx,%r12d
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov 0x8(%rsi),%rcx
mov (%rsi),%rdx
movq $0x0,(%rsp)
movq $0x0,0x8(%rs... | _Z5func0RKSt6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov r13, [rsi+8]
mov r15, [rsi]
mov [rsp+78h+var_68], 0
mov [rsp+78h+var_60], 0
mov [rsp+78h+var_58], 0
su... | _QWORD * func0(_QWORD *a1, long long a2, int a3)
{
_DWORD *v3; // r15
signed long long v4; // r13
char *v6; // rax
char *v7; // rbx
long long i; // r15
int v9; // r15d
_DWORD *v10; // rsi
long long v11; // rcx
char *v13; // [rsp+8h] [rbp-70h]
char *v14; // [rsp+18h] [rbp-60h]
v3 = *(_DWORD **)a2;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV R13,qword ptr [RSI + 0x8]
MOV R15,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
SUB R13,R15
MOV R14,... | /* func0(std::vector<int, std::allocator<int> > const&, int) */
vector * func0(vector *param_1,int param_2)
{
long lVar1;
int iVar2;
int *piVar3;
int *__dest;
int8 uVar4;
int in_EDX;
int4 in_register_00000034;
_Iter_comp_iter in_R8D;
ulong __n;
int iVar5;
long lVar6;
long in_FS_OFFSET;
int *... |
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.