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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
594 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string planet1,string planet2){
vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;m<planets.size();m++)
{
if (planets[m]==planet1) pos1=m;
if (planets[m]==planet2) pos2=m;
}
if (pos1==-1 o... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (is... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov $0x6e72,%ecx
push %r14
push %r13
push %r12
mov %rdx,%r12
mov $0x6574,%edx
push %rbp
push %rbx
sub $0x198,... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
lea rcx, aMercury; "Mercury"
push r14
movq xmm0, rcx
lea rcx, aEarth; "Earth"
push r13
push r12
push rbp
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_D8], rdi
mov edi, 100h; unsigned __int64
mov [r... | long long func0(long long a1, long long a2, long long a3)
{
char *v3; // rbx
char *v4; // rbp
const char *v5; // r13
const char *v6; // rdx
unsigned long long v7; // rcx
unsigned long long v8; // rbp
int v9; // r14d
char *v10; // r12
size_t v11; // rbx
long long v12; // r15
size_t v13; // r13
i... | func0:
ENDBR64
PUSH R15
LEA RCX,[0x103254]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x103262]
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x40],RDI
MOV EDI,0x100
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
LEA RAX,[0x10325c]
M... | /* func0(std::string, std::string) */
int (*) [16] func0(int (*param_1) [16],int8 *param_2,int8 *param_3)
{
char *__s;
size_t sVar1;
size_t __n;
int8 uVar2;
int iVar3;
int iVar4;
long *plVar5;
size_t sVar6;
ulong uVar7;
long *plVar8;
int iVar9;
char **ppcVar10;
ulong uVar11;
long *plVar12;... |
595 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| vector<string> func0(string planet1,string planet2){
vector<string> planets={"Mercury","Venus","Earth","Mars","Jupiter","Saturn","Uranus","Neptune"};
int pos1=-1,pos2=-1,m;
for (m=0;m<planets.size();m++)
{
if (planets[m]==planet1) pos1=m;
if (planets[m]==planet2) pos2=m;
}
if (pos1==-1 o... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0("Jupiter", "Neptune") , {"Saturn", "Uranus"}));
assert (is... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
mov $0x6e72,%ecx
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1a8,%rsp
mov %rdi,0... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
mov r15, rsi
push r14
mov r14, rdx
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_B0], rdi
mov edi, 100h; unsigned __int64
mov [rsp+0C8h+var_98], rdx
mov [rsp+0C8h+var_A8],... | long long func0(long long a1, long long a2, long long a3)
{
char *v4; // rbx
long long v5; // r13
size_t v6; // r12
char *v7; // r14
int v8; // ebp
size_t v9; // rbx
int v10; // r15d
int v11; // r12d
size_t v12; // r8
int v13; // eax
const void *v14; // rdi
const void *v15; // rsi
char *v16; ... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
MOV R14,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x18],RDI
MOV EDI,0x100
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LAB_00101c12:
CALL 0x001011a0
MOV ED... | /* func0(std::string, std::string) */
int (*) [16] func0(int (*param_1) [16],int8 *param_2,int8 *param_3)
{
int8 *puVar1;
size_t sVar2;
size_t __n;
size_t __n_00;
ulong __n_01;
int *__src;
int iVar3;
int iVar4;
int iVar5;
int8 *puVar6;
ulong *__dest;
int iVar7;
int8 *puVar8;
int8 *puVar9;
... |
596 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort(out.begin(),out.end());
for (int i=0;i<out.size();i++)
for (int j=1;j<out.size();j++)
if (out[j].length()<out[j-1].length())
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(func0({"sch... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_58]
pxor xmm0, xmm0
movups xmmwor... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // rax
unsigned long long v7; // rbx
long long v8; // rax
long long v9; // rax
long long v10; // rbx
long long v11; // rax
long long v12; // rax
int i;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOVQ qword ptr [RAX + 0x10],XMM0
MOV RAX,qword pt... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> * func0(vector param_1)
{
uint uVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
ulong uVar4;
ulong uVar5;
string *psVar6;
string *this;
vector<std::string,std::allocator<std::st... |
597 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort(out.begin(),out.end());
for (int i=0;i<out.size();i++)
for (int j=1;j<out.size();j++)
if (out[j].length()<out[j-1].length())
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(func0({"sch... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov ... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // rdx
unsigned long long v4; // rbx
_QWORD *v5; // rdx
_QWORD *v6; // rdi
long long v7; // r12
long long v8; // r13
int v9; // eax
unsigned long long v10; // rax
long long v11; // rbx
unsigned long long v12; // r13
long long v13; // rdx
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x0010148d
MOV R12,RSI... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> *
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int8 param_8,int param_9,int param_10,
int8 param_11)
{
long *plVar1;
uint uVar2;
int3 in... |
598 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort(out.begin(),out.end());
for (int i=0;i<out.size();i++)
for (int j=1;j<out.size();j++)
if (out[j].length()<out[j-1].length())
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(func0({"sch... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x48,%rsp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
xor r12d, r12d
push rbp
mov rbp, rsi
push rbx
xor ebx, ebx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor ... | char ** func0(char **a1, long long *a2)
{
char *v3; // r12
unsigned long long v4; // rbx
long long v5; // rcx
_QWORD *v6; // rdx
long long v7; // rax
char *v8; // rbp
long long v9; // rdx
unsigned long long v10; // rax
char *v11; // rdx
char *v12; // rcx
unsigned long long v13; // r15
unsigned l... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RSI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RCX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RS... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> *
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int1 param_8)
{
ulong uVar1;
long lVar2;
_Iter_less_iter extraout_EDX;
string *psVar3;
lon... |
599 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| vector<string> func0(vector<string> lst){
vector<string> out={};
for (int i=0;i<lst.size();i++)
if (lst[i].length()%2==0) out.push_back(lst[i]);
string mid;
sort(out.begin(),out.end());
for (int i=0;i<out.size();i++)
for (int j=1;j<out.size();j++)
if (out[j].length()<out[j-1].length())
... | #undef NDEBUG
#include<assert.h>
bool issame(vector<string> a,vector<string>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({"aa", "a", "aaa"}) , {"aa"}));
assert (issame(func0({"sch... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
mov %rsi,%r14
push %r13
mov %rdi,%r13
push %r12
push %rbp... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rsi
push r12
xor r12d, r12d
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor... | _QWORD * func0(_QWORD *a1, long long *a2)
{
_QWORD *v3; // r12
_QWORD *v4; // rbp
unsigned long long v5; // rbx
long long v6; // rsi
long long v7; // rcx
long long v8; // rdx
size_t v9; // r14
size_t v10; // rdi
_BYTE *v11; // rax
_BYTE *v12; // r15
_QWORD *v13; // rbx
long long v14; // rdx
un... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
XOR R12D,R12D
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RSI,qword ptr [RSI + 0x8]
MOV RCX,qword ptr [R13]
MOV qword ptr [RDI... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
vector<std::string,std::allocator<std::string>> *
func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int8 param_8,int8 param_9,int param_10,
int8 param_11,int1 param_12,int8 param_13,int8 param_14... |
600 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n,int x,int y){
bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(7, 34, 12) == 34);
assert (func0(15, 8, 5) == 5);
assert (func0(3, 33, 5212) == 33);
assert (func0(1259, 3, 52) == 3);
assert (func0(7919, -1, 12) == -1);
assert (func0(3609, 1245, 583) == 583);
assert (func0(91, 56, 129) == 129);
... | O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
movb $0x1,-0x5(%rbp)
cmpl $0x1,-0x14(%rbp)
jg 1168 <_Z5func0iii+0x1f>
movb $0x0,-0x5(%rbp)
movl $0x2,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x14(%rbp)
j... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_5], 1
cmp [rbp+var_14], 1
jg short loc_1168
mov [rbp+var_5], 0
loc_1168:
mov [rbp+var_4], 2
jmp short loc_1186
loc_1171:
mov eax, [rbp+var_14]
cdq
idi... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
bool v4; // [rsp+17h] [rbp-5h]
int i; // [rsp+18h] [rbp-4h]
v4 = a1 > 1;
for ( i = 2; a1 >= i * i; ++i )
{
if ( !(a1 % i) )
v4 = 0;
}
if ( v4 )
return a2;
else
return a3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV byte ptr [RBP + -0x5],0x1
CMP dword ptr [RBP + -0x14],0x1
JG 0x00101168
MOV byte ptr [RBP + -0x5],0x0
LAB_00101168:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00101186
LAB_00101171:
MOV EAX,... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int local_c;
bVar1 = 1 < param_1;
for (local_c = 2; local_c * local_c <= param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
bVar1 = false;
}
}
if (bVar1) {
param_3 = param_2;
}
ret... |
601 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n,int x,int y){
bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(7, 34, 12) == 34);
assert (func0(15, 8, 5) == 5);
assert (func0(3, 33, 5212) == 33);
assert (func0(1259, 3, 52) == 3);
assert (func0(7919, -1, 12) == -1);
assert (func0(3609, 1245, 583) == 583);
assert (func0(91, 56, 129) == 129);
... | O1 | cpp | func0(int, int, int):
endbr64
mov %edx,%r10d
cmp $0x1,%edi
setg %r8b
cmp $0x3,%edi
jle 117e <_Z5func0iii+0x35>
mov $0x2,%ecx
mov $0x0,%r9d
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
jle 1167 <_Z5func0iii+... | _Z5func0iii:
endbr64
mov r11d, edx
cmp edi, 1
setnle r8b
cmp edi, 3
jle short loc_1181
mov ecx, 2
mov r10d, 0
loc_1167:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp r9d, edi
jle short loc_1167
loc_1181:
test ... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
bool v3; // r8
int v4; // ecx
long long result; // rax
v3 = a1 > 1;
if ( a1 > 3 )
{
v4 = 2;
do
{
if ( !(a1 % v4) )
v3 = 0;
++v4;
}
while ( v4 * v4 <= a1 );
}
result = a3;
if ( v3 )
return a2;
re... | func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x1
SETG R8B
CMP EDI,0x3
JLE 0x00101181
MOV ECX,0x2
MOV R10D,0x0
LAB_00101167:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP R9D,EDI
JLE 0x00101167
LAB_00101181:
TEST R8B,R8B
MOV EAX,R11D
CMOVNZ EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
bVar1 = 1 < param_1;
if (3 < param_1) {
iVar2 = 2;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
}
if (bVar... |
602 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n,int x,int y){
bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(7, 34, 12) == 34);
assert (func0(15, 8, 5) == 5);
assert (func0(3, 33, 5212) == 33);
assert (func0(1259, 3, 52) == 3);
assert (func0(7919, -1, 12) == -1);
assert (func0(3609, 1245, 583) == 583);
assert (func0(91, 56, 129) == 129);
... | O2 | cpp | func0(int, int, int):
endbr64
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 1327 <_Z5func0iii+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %edi,%eax
j... | _Z5func0iii:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
char v4; // r8
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1... | func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8B,R8B
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
CMP EDI,... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
... |
603 | func0 | #include<stdio.h>
#include<math.h>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| int func0(int n,int x,int y){
bool isp=true;
if (n<2) isp=false;
for (int i=2;i*i<=n;i++)
if (n%i==0) isp=false;
if (isp) return x;
return y;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(7, 34, 12) == 34);
assert (func0(15, 8, 5) == 5);
assert (func0(3, 33, 5212) == 33);
assert (func0(1259, 3, 52) == 3);
assert (func0(7919, -1, 12) == -1);
assert (func0(3609, 1245, 583) == 583);
assert (func0(91, 56, 129) == 129);
... | O3 | cpp | func0(int, int, int):
endbr64
cmp $0x1,%edi
mov %edx,%r10d
setg %r8b
cmp $0x3,%edi
jle 12d7 <_Z5func0iii+0x37>
mov $0x2,%ecx
xor %r9d,%r9d
nopl 0x0(%rax,%rax,1)
mov %edi,%eax
cltd
idiv %ecx
test %edx,%edx
cmove %r9d,%r8d
add $0x1,%ecx
mov %ecx,%eax
imul %ecx,%eax
cmp %eax,%edi
j... | _Z5func0iii:
endbr64
mov r11d, edx
cmp edi, 3
jle short loc_1328
mov ecx, 2
mov r8d, 1
xor r10d, r10d
nop word ptr [rax+rax+00h]
loc_1300:
mov eax, edi
cdq
idiv ecx
test edx, edx
cmovz r8d, r10d
add ecx, 1
mov r9d, ecx
imul r9d, ecx
cmp edi, r9d
jge short loc_1... | long long func0(int a1, unsigned int a2, unsigned int a3)
{
int v3; // ecx
char v4; // r8
long long result; // rax
if ( a1 <= 3 )
{
result = a3;
if ( a1 > 1 )
return a2;
}
else
{
v3 = 2;
v4 = 1;
do
{
if ( !(a1 % v3) )
v4 = 0;
++v3;
}
while ( a1... | func0:
ENDBR64
MOV R11D,EDX
CMP EDI,0x3
JLE 0x00101328
MOV ECX,0x2
MOV R8D,0x1
XOR R10D,R10D
NOP word ptr [RAX + RAX*0x1]
LAB_00101300:
MOV EAX,EDI
CDQ
IDIV ECX
TEST EDX,EDX
CMOVZ R8D,R10D
ADD ECX,0x1
MOV R9D,ECX
IMUL R9D,ECX
CMP EDI,R9D
JGE 0x00101300
TEST R8B,R8B
MOV EAX,R11D
CMOVNZ EAX,ESI
RET
LAB_00101328:
CMP EDI,... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
bool bVar1;
int iVar2;
if (3 < param_1) {
iVar2 = 2;
bVar1 = true;
do {
if (param_1 % iVar2 == 0) {
bVar1 = false;
}
iVar2 = iVar2 + 1;
} while (iVar2 * iVar2 <= param_1);
if (bVar1) {
... |
604 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(vector<float> lst){
long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(lst[i]))*(int)(round(lst[i]));
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({5, 4}) == 25);
assert (func0({0.1, 0.2, 0.3}) == 0 );
assert (func0({-10, -20, -30}) == 0 );
assert (func0({-1, -2, 8}) == 0);
assert (func0({0.2, 3, 5}) == 34);
assert (func0({1, 3, 2, 0}) == 10);
asse... | O0 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movq $0x0,-0x18(%rbp)
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1e78 <_ZNKSt6vectorIfSaIfEE4sizeEv>
cmp ... | _Z5func0St6vectorIfSaIfEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_18], 0
mov [rbp+var_1C], 0
jmp loc_13B1
loc_128E:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+var_28]
mov rsi, rdx
mov rdi, rax
call _ZNSt6vectorIfS... | long long func0(long long a1)
{
float v1; // xmm0_4
float v2; // xmm0_4
float v4; // xmm0_4
int v5; // ebx
float v6; // xmm0_4
float v8; // [rsp+4h] [rbp-2Ch]
int i; // [rsp+14h] [rbp-1Ch]
long long v10; // [rsp+18h] [rbp-18h]
v10 = 0LL;
for ( i = 0; i < (unsigned long long)std::vector<float>::siz... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001013b1
LAB_0010128e:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101f9c
MOVSS XMM2,dword p... | /* func0(std::vector<float, std::allocator<float> >) */
long func0(vector param_1)
{
bool bVar1;
float *pfVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<float,std::allocator<float>> *this;
float fVar4;
float fVar5;
int4 local_24;
int8 local_20;
this = (vector<float,std::allocator<float>> ... |
605 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(vector<float> lst){
long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(lst[i]))*(int)(round(lst[i]));
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({5, 4}) == 25);
assert (func0({0.1, 0.2, 0.3}) == 0 );
assert (func0({-10, -20, -30}) == 0 );
assert (func0({-1, -2, 8}) == 0);
assert (func0({0.2, 3, 5}) == 34);
assert (func0({1, 3, 2, 0}) == 10);
asse... | O1 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rdi),%rax
mov 0x8(%rdi),%rbp
sub %rax,%rbp
mov %rbp,%rsi
shr $0x2,%rsi
je 12f9 <_Z5func0St6vectorIfSaIfEE+0x90>
mov %rax,%rbx
add %rax,%rbp
mov $0x0,%r12d
jmp 129f <_Z5fu... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rax, [rdi+8]
mov r12, [rdi]
mov r13, rax
sub r13, r12
sar r13, 2
cmp rax, r12
jz short loc_12F6
mov ebx, 0
mov r14d, 0
jmp short loc_12A1
loc_1298:
add rbx, 1
cmp rbx, r13
... | long long func0(long long *a1)
{
long long v1; // r12
unsigned long long v2; // r13
unsigned long long v3; // rbx
long long v4; // r14
float v5; // ebp
float v6; // xmm0_4
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
v4 = 0LL;
do
{
v5 = *(float *)(v1 +... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x8]
MOV R12,qword ptr [RDI]
MOV R13,RAX
SUB R13,R12
SAR R13,0x2
CMP RAX,R12
JZ 0x001012f6
MOV EBX,0x0
MOV R14D,0x0
JMP 0x001012a1
LAB_00101298:
ADD RBX,0x1
CMP RBX,R13
JNC 0x001012fc
LAB_001012a1:
MOV EBP,dword ptr [R12 + RBX*0x4]
MOV... | /* func0(std::vector<float, std::allocator<float> >) */
long func0(vector param_1)
{
float __x;
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int4 in_register_0000003c;
long lVar5;
float fVar6;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_registe... |
606 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(vector<float> lst){
long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(lst[i]))*(int)(round(lst[i]));
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({5, 4}) == 25);
assert (func0({0.1, 0.2, 0.3}) == 0 );
assert (func0({-10, -20, -30}) == 0 );
assert (func0({-1, -2, 8}) == 0);
assert (func0({0.2, 3, 5}) == 34);
assert (func0({1, 3, 2, 0}) == 10);
asse... | O2 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
sub %rbx,%rbp
mov %rbp,%rax
shr $0x2,%rax
je 19a8 <_Z5func0St6vectorIfSaIfEE+0x98>
add %rbx,%rbp
xor %r12d,%r12d
nopl (%rax)
movss (%rbx),%xmm2
... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, [rdi+8]
mov rbp, [rdi]
mov r12, rax
sub r12, rbp
sar r12, 2
cmp rax, rbp
jz loc_1880
xor ebx, ebx
xor r13d, r13d
nop dword ptr [rax]
loc_1800:
movss xmm2, dword ptr [rb... | long long func0(long long *a1)
{
long long v1; // rbp
unsigned long long v2; // r12
unsigned long long v3; // rbx
long long v4; // r13
float v5; // xmm0_4
float v7; // [rsp+Ch] [rbp-2Ch]
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
v4 = 0LL;
do
{
v7 = ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV R12,RAX
SUB R12,RBP
SAR R12,0x2
CMP RAX,RBP
JZ 0x00101880
XOR EBX,EBX
XOR R13D,R13D
NOP dword ptr [RAX]
LAB_00101800:
MOVSS XMM2,dword ptr [RBP + RBX*0x4]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc... | /* func0(std::vector<float, std::allocator<float> >) */
long func0(vector param_1)
{
float __x;
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int4 in_register_0000003c;
long lVar5;
float fVar6;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_registe... |
607 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| long long func0(vector<float> lst){
long long sum=0;
for (int i=0;i<lst.size();i++)
if (lst[i]-round(lst[i])<1e-4)
if (lst[i]>0 and (int)(round(lst[i]))%2==1) sum+=(int)(round(lst[i]))*(int)(round(lst[i]));
return sum;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({}) == 0);
assert (func0({5, 4}) == 25);
assert (func0({0.1, 0.2, 0.3}) == 0 );
assert (func0({-10, -20, -30}) == 0 );
assert (func0({-1, -2, 8}) == 0);
assert (func0({0.2, 3, 5}) == 34);
assert (func0({1, 3, 2, 0}) == 10);
asse... | O3 | cpp | func0(std::vector<float, std::allocator<float> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
sub %rbx,%rbp
mov %rbp,%rax
shr $0x2,%rax
je 1a28 <_Z5func0St6vectorIfSaIfEE+0x98>
add %rbx,%rbp
xor %r12d,%r12d
nopl (%rax)
movss (%rbx),%xmm2
... | _Z5func0St6vectorIfSaIfEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, [rdi+8]
mov rbp, [rdi]
mov r12, rax
sub r12, rbp
sar r12, 2
cmp rax, rbp
jz loc_1A10
xor ebx, ebx
xor r13d, r13d
nop dword ptr [rax]
loc_1990:
movss xmm2, dword ptr [rb... | long long func0(long long *a1)
{
long long v1; // rbp
unsigned long long v2; // r12
unsigned long long v3; // rbx
long long v4; // r13
float v5; // xmm0_4
float v7; // [rsp+Ch] [rbp-2Ch]
v1 = *a1;
v2 = (a1[1] - *a1) >> 2;
if ( a1[1] == *a1 )
return 0LL;
v3 = 0LL;
v4 = 0LL;
do
{
v7 = ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI]
MOV R12,RAX
SUB R12,RBP
SAR R12,0x2
CMP RAX,RBP
JZ 0x00101a10
XOR EBX,EBX
XOR R13D,R13D
NOP dword ptr [RAX]
LAB_00101990:
MOVSS XMM2,dword ptr [RBP + RBX*0x4]
MOVAPS XMM0,XMM2
MOVSS dword ptr [RSP + 0xc... | /* func0(std::vector<float, std::allocator<float> >) */
long func0(vector param_1)
{
float __x;
long lVar1;
long lVar2;
int iVar3;
ulong uVar4;
int4 in_register_0000003c;
long lVar5;
float fVar6;
lVar1 = *(long *)(CONCAT44(in_register_0000003c,param_1) + 8);
lVar2 = *(long *)CONCAT44(in_registe... |
608 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> game,vector<int> guess){
vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(fu... | O0 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %rdx,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x28(%rbp),%rax
mov %... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_38], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::v... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
int v4; // eax
unsigned long long v5; // rbx
int v8; // [rsp+20h] [rbp-20h] BYREF
int i; // [rsp+24h] [rbp-1Ch]
unsigned long long v10; // [rsp+28h] [rbp-18h]
v10 = __readfsqword(0x28u);
std::vector<int>::vector(a1);
for ( i ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x38],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010263e
MOV dword ptr [RBP + -0x1c],0x0
JM... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
int iVar1;
int *piVar2;
ulong uVar3;
vector<int,std::allocator<int>> *in_RDX;
ulong uVar4;
int4 in_register_00000034;
int4 in_register_0000... |
609 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> game,vector<int> guess){
vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(fu... | O1 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %rdx,%r13
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbp, rdi
mov r13, rdx
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rdx, [rsi... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
unsigned long long v6; // rbx
int v7; // eax
int v8; // edx
int *v9; // rsi
int v11; // [rsp+4h] [rbp-34h] BYREF
unsigned long long v12; // [rsp+8h] [rbp-30h]
v12 = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBP,RDI
MOV R13,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RDX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDX
JZ 0x00101354
... | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1,vector param_2)
{
int *piVar1;
long *in_RDX;
long lVar2;
ulong uVar3;
int4 in_register_00000034;
long *plVar4;
int4 in_register_0000003c;
vector<int,std::a... |
610 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> game,vector<int> guess){
vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(fu... | O2 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov ... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rcx... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
long long v7; // rbx
int *v8; // rdi
int *v9; // rsi
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QW... | func0:
MOV RDI,RBP
CALL 0x00101b50
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101160
MOV RDI,RBX
LAB_0010115b:
CALL 0x00101130
LAB_00101160:
CALL 0x00101110 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2,int param_3,int param_4,int param_5,
int param_6,long param_7)
{
vector<int,std::allocator<int>> *unaff_RBP;
long in_FS_OFFSET;
std::vector<int,std::... |
611 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(vector<int> game,vector<int> guess){
vector<int> out;
for (int i=0;i<game.size();i++)
out.push_back(abs(game[i]-guess[i]));
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0({1,2,3,4,5,1},{1,2,3,4,2,-2}),{0,0,0,0,3,3}));
assert (issame(fu... | O3 | cpp | func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi)
movups %xmm0,(%rdi)
mov (... | _Z5func0St6vectorIiSaIiEES1_:
endbr64
push r14
pxor xmm0, xmm0
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rcx, [rsi]
mov qword ptr [rdi+10h], 0
cmp [rsi+8], rcx... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rcx
long long v7; // rbx
int *v8; // rdi
int *v9; // rsi
int v10; // eax
int v12; // [rsp+0h] [rbp-34h] BYREF
unsigned long long v13; // [rsp+4h] [rbp-30h]
v13 = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QW... | func0:
MOV RDI,RBP
CALL 0x00101cc0
MOV RAX,qword ptr [RSP + 0x8]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010117c
MOV RDI,RBX
LAB_00101177:
CALL 0x00101130
LAB_0010117c:
CALL 0x00101110 | /* func0(std::vector<int, std::allocator<int> >, std::vector<int, std::allocator<int> >) [clone
.cold] */
void func0(vector param_1,vector param_2,int param_3,int param_4,int param_5,
int param_6,long param_7)
{
vector<int,std::allocator<int>> *unaff_RBP;
long in_FS_OFFSET;
std::vector<int,std::... |
612 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string class_name,vector<string> extensions){
string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
for (int j=0;j<extensions[i].length();j++)
{
char chr=extensions[i][j];
if (chr>=65 and chr<=90) strength... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Watashi", {"tEN", "niNE", "eIGHt8OKe"}) == "Watashi.eIGHt8OKe");
assert (func0("Boku123", {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"}) == "Boku123.YEs.WeCaNe");
assert (func0("__YESIMHERE", {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123Nooon... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
pu... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS4_SaIS4_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov [rbp+var_98], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_7A]
mov ... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
unsigned long long v4; // rbx
long long v5; // rax
long long v6; // rax
unsigned long long v7; // rbx
char v10; // [rsp+26h] [rbp-7Ah] BYREF
char v11; // [rsp+27h] [rbp-79h]
int v12; // [rsp+28h] [rbp-78h]
int i; // [rsp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV qword ptr [RBP + -0x98],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x7a]
MOV qword ptr [RBP + -0x68],RAX
NOP
NOP
LEA RDX,[RBP + -0x7a]
LEA RAX,[R... | /* func0(std::string, std::vector<std::string, std::allocator<std::string > >) */
int8
func0(int8 param_1,int8 param_2,vector<std::string,std::allocator<std::string>> *param_3
)
{
char *pcVar1;
string *psVar2;
ulong uVar3;
ulong uVar4;
long in_FS_OFFSET;
allocator local_82;
char local_81;
int loc... |
613 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string class_name,vector<string> extensions){
string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
for (int j=0;j<extensions[i].length();j++)
{
char chr=extensions[i][j];
if (chr>=65 and chr<=90) strength... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Watashi", {"tEN", "niNE", "eIGHt8OKe"}) == "Watashi.eIGHt8OKe");
assert (func0("Boku123", {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"}) == "Boku123.YEs.WeCaNe");
assert (func0("__YESIMHERE", {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123Nooon... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS4_SaIS4_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov r13, rdi
mov r14, rsi
mov r12, rdx
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor eax, eax
lea rdi, [rsp+98h+... | char ** func0(char **a1, long long *a2, long long *a3)
{
long long v6; // rdx
long long v7; // rcx
long long v8; // rsi
unsigned long long v9; // rbp
long long v10; // r8
unsigned long long v11; // rbx
long long v12; // rbp
int v13; // ebx
unsigned __int8 *v14; // rax
unsigned __int8 **v15; // rdi
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV R13,RDI
MOV R14,RSI
MOV R12,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RSP + 0x10],RAX
LEA RSI,[0x1033b1]
MOV RDX,RSI
LAB_001013ad:
CALL 0x001022... | /* func0(std::string, std::vector<std::string, std::allocator<std::string > >) */
long * func0(long *param_1,ulong *param_2,long *param_3)
{
long *plVar1;
int8 *puVar2;
ulong uVar3;
char *pcVar4;
long *plVar5;
int8 uVar6;
uint uVar7;
long lVar8;
uint uVar9;
int iVar10;
ulong uVar11;
char *pcVa... |
614 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string class_name,vector<string> extensions){
string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
for (int j=0;j<extensions[i].length();j++)
{
char chr=extensions[i][j];
if (chr>=65 and chr<=90) strength... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Watashi", {"tEN", "niNE", "eIGHt8OKe"}) == "Watashi.eIGHt8OKe");
assert (func0("Boku123", {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"}) == "Boku123.YEs.WeCaNe");
assert (func0("__YESIMHERE", {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123Nooon... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS4_SaIS4_EE:
endbr64
push r15
push r14
mov r14, rsi
lea rsi, function+0Ah; ""
push r13
mov r13, rdi
push r12
mov r12, rdx
mov rdx, rsi
push rbp
xor ebp, ebp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov ... | char ** func0(char **a1, long long *a2, long long *a3)
{
unsigned long long v6; // rbp
long long v7; // rdx
long long v8; // rcx
long long v9; // rdi
long long v10; // r8
int v11; // ebx
unsigned __int8 **v12; // r9
unsigned __int8 *v13; // rsi
unsigned __int8 *v14; // rax
unsigned __int8 *v15; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
LEA RSI,[0x10305c]
PUSH R13
MOV R13,RDI
PUSH R12
MOV R12,RDX
MOV RDX,RSI
PUSH RBP
XOR EBP,EBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R15,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV RDI,R15
MOV qword ptr [RSP + 0x8],RAX
MOV ... | /* func0(std::string, std::vector<std::string, std::allocator<std::string > >) */
long * func0(long *param_1,ulong *param_2,long *param_3)
{
long *plVar1;
long lVar2;
ulong uVar3;
char *pcVar4;
long *plVar5;
uint uVar6;
uint uVar7;
int iVar8;
ulong uVar9;
char *pcVar10;
long lVar11;
int iVar12... |
615 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<stdlib.h>
| string func0(string class_name,vector<string> extensions){
string strongest="";
int max=-1000;
for (int i=0;i<extensions.size();i++)
{
int strength=0;
for (int j=0;j<extensions[i].length();j++)
{
char chr=extensions[i][j];
if (chr>=65 and chr<=90) strength... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Watashi", {"tEN", "niNE", "eIGHt8OKe"}) == "Watashi.eIGHt8OKe");
assert (func0("Boku123", {"nani", "NazeDa", "YEs.WeCaNe", "32145tggg"}) == "Boku123.YEs.WeCaNe");
assert (func0("__YESIMHERE", {"t", "eMptY", "(nothing", "zeR00", "NuLl__", "123Nooon... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS4_SaIS4_EE:
endbr64
push r15
mov r15, rsi
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 78h
mov r9, [rdx+8]
mov r8, [rdx]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
... | char ** func0(char **a1, long long *a2, long long *a3)
{
long long v5; // r9
long long v6; // r8
unsigned long long v8; // rbp
int v9; // r10d
int v10; // ebx
long long v11; // rdi
long long v12; // rsi
_BYTE *v13; // rax
_BYTE *v14; // rsi
unsigned long long v15; // r12
long long v16; // r14
ch... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R9,qword ptr [RDX + 0x8]
MOV R8,qword ptr [RDX]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x30]
MOV byte ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ... | /* func0(std::string, std::vector<std::string, std::allocator<std::string > >) */
long * func0(long *param_1,ulong *param_2,long *param_3)
{
long *plVar1;
long lVar2;
ulong uVar3;
char *pcVar4;
long *plVar5;
uint uVar6;
uint uVar7;
int iVar8;
ulong uVar9;
char *pcVar10;
long lVar11;
int8 *puVa... |
616 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(string a,string b){
for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("xyzw","xyw") == false );
assert (func0("yello","ell") == true );
assert (func0("whattup","ptut") == false );
assert (func0("efef","fee") == true );
assert (func0("abab","aabb") == false );
assert (func0("winemtt","tinem") == true... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x90,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %fs:0x28,%rax
mov... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 90h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_84], 0
jmp loc_24ED
loc_2427:
mov eax... | long long func0(long long a1, long long a2)
{
unsigned int v2; // r12d
int v3; // ebx
int i; // [rsp+1Ch] [rbp-84h]
_BYTE v6[32]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+40h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+60h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+88h] [rbp-18h]
v9 = __read... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x90
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x84],0x0
JMP 0x001024ed
LAB_00102427:
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RDX,EAX
LEA RAX,[... | /* func0(std::string, std::string) */
int4 func0(string *param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
int4 unaff_R12D;
long in_FS_OFFSET;
int local_8c;
string local_88 [32];
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
for (local_8... |
617 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(string a,string b){
for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("xyzw","xyw") == false );
assert (func0("yello","ell") == true );
assert (func0("whattup","ptut") == false );
assert (func0("efef","fee") == true );
assert (func0("abab","aabb") == false );
assert (func0("winemtt","tinem") == true... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
cmpq $0x0,0x8(... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+98h+var_30], rax
xor eax, eax
mov rdx, [rsi+8]
test rdx, rdx
jz loc_16D8
mov r12, rdi
mov rbp, rsi
mov ebx, 0
mov r13... | long long func0(long long a1, _QWORD *a2)
{
unsigned long long v2; // rdx
unsigned long long v5; // rbx
unsigned long long v6; // rax
unsigned long long v7; // rsi
unsigned long long v8; // rsi
_QWORD *v9; // rax
_QWORD *v10; // rax
_QWORD *v11; // rdx
long long v12; // rsi
_DWORD *v13; // r9
_DW... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDX,qword ptr [RSI + 0x8]
TEST RDX,RDX
JZ 0x001016d8
MOV R12,RDI
MOV RBP,RSI
MOV EBX,0x0
MOV R13,0x3fffffffffffffff
JMP 0x001015c2
LAB_0010132e:
MOV RAX,qword ptr [RSP + 0x68]
SUB R... | /* func0(std::string, std::string) */
int8 func0(char *param_1,long *param_2)
{
long *plVar1;
long *plVar2;
long lVar3;
int8 uVar4;
uint uVar5;
long *plVar6;
ulong uVar7;
ulong uVar8;
long *plVar9;
long in_FS_OFFSET;
long *local_98;
long local_88 [2];
ulong *local_78;
long local_70;
ulon... |
618 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(string a,string b){
for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("xyzw","xyw") == false );
assert (func0("yello","ell") == true );
assert (func0("whattup","ptut") == false );
assert (func0("efef","fee") == true );
assert (func0("abab","aabb") == false );
assert (func0("winemtt","tinem") == true... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,0x8(%rsp)
mov %fs:0x28,%rax
mov %ra... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov rdx, [rsi+8]
mov [rsp+0B8h+var_B0], rdi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
test rdx, rdx
jz loc_1D40
mov ... | long long func0(long long a1, long long *a2)
{
unsigned long long v2; // rdx
unsigned long long v4; // rbx
_QWORD *v5; // rax
_QWORD *v6; // rsi
long long v7; // rdx
_QWORD *v8; // rcx
_QWORD *v9; // rdi
long long v10; // rsi
unsigned long long v11; // rdx
long long v12; // rsi
unsigned long long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
TEST RDX,RDX
JZ 0x00101d40
MOV RBP,RSI
LEA R15,[RSP + 0x50]
LEA R14,[RSP + 0x60]
XOR EBX,EBX
JMP 0x00101bd7... | /* func0(std::string, std::string) */
int8 func0(char *param_1,long *param_2)
{
long *plVar1;
int8 uVar2;
uint uVar3;
ulong uVar5;
long *plVar6;
ulong uVar7;
ulong uVar8;
long *plVar9;
long lVar10;
long *plVar11;
long in_FS_OFFSET;
long *local_a8;
long local_98 [2];
ulong *local_88;
long... |
619 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| bool func0(string a,string b){
for (int i=0;i<b.size();i++)
{
string rotate=b.substr(i)+b.substr(0,i);
if (a.find(rotate)!=string::npos) return true;
}
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("xyzw","xyw") == false );
assert (func0("yello","ell") == true );
assert (func0("whattup","ptut") == false );
assert (func0("efef","fee") == true );
assert (func0("abab","aabb") == false );
assert (func0("winemtt","tinem") == true... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,0x8(%rsp)
mov %fs:0x28,%rax
mov %ra... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
xor ebp, ebp
push rbx
sub rsp, 0A8h
mov rbx, [rsi+8]
mov [rsp+0D8h+var_C8], rdi
lea r14, [rsp+0D8h+var_58]
mov rax, fs:28h
mov [rsp+0D8h+va... | long long func0(long long a1, long long a2)
{
size_t v3; // rbp
size_t v4; // rbx
_BYTE *v5; // r13
_QWORD *v6; // rax
size_t v7; // rbx
_BYTE *v8; // r15
size_t v9; // rbx
_BYTE *v10; // r15
_QWORD *v11; // rax
unsigned long long v12; // rax
unsigned long long v13; // rdi
long long v14; // rax... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
XOR EBP,EBP
PUSH RBX
SUB RSP,0xa8
MOV RBX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x10],RDI
LEA R14,[RSP + 0x80]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x18],RAX
TEST RBX,... | /* func0(std::string, std::string) */
int8 func0(char *param_1,long *param_2)
{
int *__src;
long *plVar1;
long lVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
long *plVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
long *plVar10;
long *plVar11;
long in_FS_OFFSET;
ulong local_b0;
long *local_a8;... |
620 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int num){
string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(7) , {0, 1}));
assert (issame(func0(-78) , {1, 1}));
assert ... | O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x68,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov -0x7c(%rbp),%eax
cltd
mov %edx,%eax
xor -0x7c(%rbp),%eax
sub %edx,%eax
lea -0x50(%rbp),%... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov eax, [rbp+var_7C]
mov edx, eax
neg edx
cmovs edx, eax
lea rax, [rbp+var_50]
mov ... | long long func0(long long a1, int a2)
{
int v2; // edx
char v4; // [rsp+13h] [rbp-6Dh] BYREF
int v5; // [rsp+14h] [rbp-6Ch]
int v6; // [rsp+18h] [rbp-68h]
int i; // [rsp+1Ch] [rbp-64h]
char *v8; // [rsp+20h] [rbp-60h]
_DWORD v9[2]; // [rsp+28h] [rbp-58h] BYREF
_BYTE v10[40]; // [rsp+30h] [rbp-50h] BYRE... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x7c]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
LEA RAX,[RBP + -0x50]
MOV ESI,EDX
MOV RDI,... | /* func0(int) */
int8 func0(int param_1)
{
char *pcVar1;
ulong uVar2;
ulong uVar3;
int4 in_register_0000003c;
long in_FS_OFFSET;
__new_allocator<int> local_75;
int local_74;
int local_70;
int local_6c;
__new_allocator<int> *local_68;
int local_60;
int local_5c;
string local_58 [40];
long l... |
621 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int num){
string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(7) , {0, 1}));
assert (issame(func0(-78) , {1, 1}));
assert ... | O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%rbx
mov %esi,%r8d
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov %esi,%eax
sar $0x1f,%eax
xor %eax,%r8d
sub %eax,%r8d
lea 0xd4f(%rip),%rcx
mov $0x10,%edx
mov 0x2d17(%rip),%rsi
mov $0x... | _Z5func0i:
endbr64
push r12
push rbp
push rbx
sub rsp, 100h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+118h+var_20], rax
xor eax, eax
mov r12d, esi
neg r12d
cmovs r12d, esi
cmp r12d, 9
jbe loc_187E
cmp r12d, 63h ; 'c'
jbe short loc_1346
cmp r12d, 3E7h
jbe loc_15... | long long ** func0(long long **a1, int a2)
{
unsigned int v2; // r12d
unsigned int v3; // eax
unsigned int v4; // ebp
unsigned int v5; // edx
_BYTE *v6; // rcx
int v7; // r12d
char v8; // r12
char *v9; // rdx
unsigned int v10; // esi
long long v11; // r8
unsigned int v12; // eax
unsigned int v13... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x100
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
MOV R12D,ESI
NEG R12D
CMOVS R12D,ESI
CMP R12D,0x9
JBE 0x0010187e
CMP R12D,0x63
JBE 0x00101346
CMP R12D,0x3e7
JBE 0x00101563
CMP R12D,0x270f
JBE 0x00101793
MOV EAX,R12D
MOV EBP,0x1
M... | /* func0(int) */
int8 * func0(int param_1)
{
uint uVar1;
int8 *puVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
long *plVar6;
uint uVar7;
uint in_ESI;
int iVar8;
int4 in_register_0000003c;
int8 *puVar9;
int iVar10;
char cVar11;
ulong uVar12;
long in_FS_OFFSET;
long *local_118;
long local... |
622 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int num){
string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(7) , {0, 1}));
assert (issame(func0(-78) , {1, 1}));
assert ... | O2 | cpp | func0(int):
endbr64
push %r12
mov %esi,%r8d
mov %rdi,%r12
mov $0x10,%edx
push %rbp
lea 0x59b(%rip),%rcx
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %esi,%eax
mov 0x2551(%rip),%rsi
mov %rsp,%rdi
sar $0x1f,%eax
xor %eax,%r8d
sub %eax,%r8... | _Z5func0i:
endbr64
push r14
push r13
mov r13d, esi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 100h
mov rax, fs:28h
mov [rsp+128h+var_30], rax
xor eax, eax
neg r13d
cmovs r13d, esi
cmp r13d, 9
jle loc_1C2D
cmp r13d, 63h ; 'c'
jle loc_1AD2
cmp r13d, 3... | long long func0(long long a1, int a2)
{
int v3; // r13d
unsigned int v4; // r14d
long long v5; // rsi
_BYTE *v6; // rcx
unsigned int v7; // eax
unsigned int v8; // esi
long long v9; // rax
long long v10; // rdi
long long v11; // rdx
long long v12; // rdi
char *v13; // rdx
unsigned int v14; // e... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
NEG R13D
CMOVS R13D,ESI
CMP R13D,0x9
JLE 0x00101c2d
CMP R13D,0x63
JLE 0x00101ad2
CMP R13D,0x3e7
JLE 0x00101c61
CMP R13D,0x270f
JLE 0x00101c54
MOV EAX,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int (*) [16] func0(int param_1)
{
uint uVar1;
uint uVar2;
int8 *puVar3;
uint uVar4;
long *plVar5;
char cVar6;
uint in_ESI;
int iVar7;
int4 in_register_0000003c;
int (*pauVar8) [16];
int iVar9;
... |
623 | func0 | #include<stdio.h>
#include<math.h>
#include<string>
#include<vector>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| vector<int> func0(int num){
string w=to_string(abs(num));
int n1=0,n2=0;
for (int i=0;i<w.length();i++)
if (w[i]%2==1) n1+=1;
else n2+=1;
return {n2,n1};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(7) , {0, 1}));
assert (issame(func0(-78) , {1, 1}));
assert ... | O3 | cpp | func0(int):
endbr64
push %r12
mov %esi,%r8d
mov %rdi,%r12
mov $0x10,%edx
push %rbp
lea 0x143b(%rip),%rcx
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
mov %esi,%eax
mov 0x33f1(%rip),%rsi
mov %rsp,%rdi
sar $0x1f,%eax
xor %eax,%r8d
sub %eax,%r... | _Z5func0i:
endbr64
push r14
push r13
mov r13d, esi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 100h
mov rax, fs:28h
mov [rsp+128h+var_30], rax
xor eax, eax
neg r13d
cmovs r13d, esi
cmp r13d, 9
jle loc_217F
cmp r13d, 63h ; 'c'
jle loc_1F9D
cmp r13d, 3... | long long func0(long long a1, int a2)
{
int v3; // r13d
unsigned int v4; // r14d
long long v5; // rsi
_BYTE *v6; // rcx
unsigned int v7; // eax
unsigned int v8; // esi
long long v9; // rax
long long v10; // rdi
long long v11; // rdx
unsigned long long v12; // rsi
__m128i v13; // xmm9
const __m1... | func0:
ENDBR64
PUSH R14
PUSH R13
MOV R13D,ESI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x100
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
NEG R13D
CMOVS R13D,ESI
CMP R13D,0x9
JLE 0x0010217f
CMP R13D,0x63
JLE 0x00101f9d
CMP R13D,0x3e7
JLE 0x001021a6
CMP R13D,0x270f
JLE 0x001021b6
MOV EAX,... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int (*) [16] func0(int param_1)
{
uint uVar1;
bool bVar2;
bool bVar3;
bool bVar4;
bool bVar5;
bool bVar6;
bool bVar7;
bool bVar8;
bool bVar9;
bool bVar10;
bool bVar11;
bool bVar12;
bool bVar... |
624 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(int number){
string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,50,40,10,9,5,4,1};
int pos=0;
while(number>0)
{
while (number>=num[pos])
{
current=current+rep[pos];
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(19) == "xix");
assert (func0(152) == "clii");
assert (func0(251) == "ccli");
assert (func0(426) == "cdxxvi");
assert (func0(500) == "d");
assert (func0(1) == "i");
assert (func0(4) == "iv");
assert (func0(43) == "xliii");
as... | O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x248,%rsp
mov %rdi,-0x268(%rbp)
mov %esi,-0x26c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
lea -0x220(%rbp),%rax
mov %rax,%rdi
callq 23a0 <_ZNSaIcEC1Ev@p... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 0E8h
mov [rbp+var_F8], rdi
mov [rbp+var_FC], esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea rax, [rbp+var_B0]
mov [rbp+var_E8], rax
nop
nop
lea rdx, [rbp+var_B0]
mov ra... | long long func0[abi:cxx11](long long a1, int a2)
{
long long v2; // rax
char v5; // [rsp+13h] [rbp-EDh] BYREF
int v6; // [rsp+14h] [rbp-ECh]
_BYTE *v7; // [rsp+18h] [rbp-E8h]
_BYTE *v8; // [rsp+20h] [rbp-E0h]
char *v9; // [rsp+28h] [rbp-D8h]
_BYTE v10[32]; // [rsp+30h] [rbp-D0h] BYREF
_BYTE v11[32]; //... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RBP + -0xf8],RDI
MOV dword ptr [RBP + -0xfc],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0xb0]
MOV qword ptr [RBP + -0xe8],RAX
NOP
NOP
LEA RDX,[RBP + -0xb0]
MOV RAX,qword... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
int8 uVar1;
int *piVar2;
int in_ESI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
int local_104;
__new_allocator<int> local_f5;
int local_f4;
allocator *local_f0;
allocator *local_e8;
__new_allocator<int> *loca... |
625 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(int number){
string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,50,40,10,9,5,4,1};
int pos=0;
while(number>0)
{
while (number>=num[pos])
{
current=current+rep[pos];
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(19) == "xix");
assert (func0(152) == "clii");
assert (func0(251) == "ccli");
assert (func0(426) == "cdxxvi");
assert (func0(500) == "d");
assert (func0(1) == "i");
assert (func0(4) == "iv");
assert (func0(43) == "xliii");
as... | O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1d8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
lea 0x10(%rdi),%rax
mov %rax,(%rsp)
mov %rax,(%rdi)
lea 0xe09(%rip),%rdx
mov %rdx,%rsi
... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0B8h
mov rbx, rdi
mov r13d, esi
mov rax, fs:28h
mov [rsp+0E8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rsp+0E8h+var_D0], rax
mov [rdi], rax
lea rsi, aFunc090Xc+11h;... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2)
{
int v3; // r13d
__m128i *v4; // rcx
long long *v5; // r14
_BYTE *v6; // rax
long long v7; // rcx
unsigned long long v8; // r12
unsigned long long v9; // rbp
char *v10; // rdx
unsigned long long v11; // rdi
_BYTE *v12; // rax
__int8 *v13; // rsi
uns... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xb8
MOV RBX,RDI
MOV R13D,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xa8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RDI],RAX
LEA RSI,[0x102155]
MOV RDX,RSI
LAB_0010138d:
CALL 0x001... | /* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
int **ppuVar1;
int *puVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uint uVar6;
string *psVar7;
string *psVar8;
int *piVar9;
int8 uVar10;
long lVar11;
uint uVar12;
ulong uVar13;
string *psVar14;
int in_ESI;
int4 in_regi... |
626 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(int number){
string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,50,40,10,9,5,4,1};
int pos=0;
while(number>0)
{
while (number>=num[pos])
{
current=current+rep[pos];
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(19) == "xix");
assert (func0(152) == "clii");
assert (func0(251) == "ccli");
assert (func0(426) == "cdxxvi");
assert (func0(500) == "d");
assert (func0(1) == "i");
assert (func0(4) == "iv");
assert (func0(43) == "xliii");
as... | O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
mov $0x6d63,%edx
mov $0x64,%ecx
mov $0x6378,%r8d
push %r14
mov $0x6c,%r9d
mov $0x6c78,%r10d
mov $0x78,%r11d
push %r13
mov $0x76,%r14d
mov $0x7869,%r13d
mov $0x7669,%r15d
push %r12
mov %rdi,%r12
push %rbp
mov %esi,%ebp
mov $0x6463,%es... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
mov r14d, esi
lea rsi, aFunc090Xc+11h; ""
push r13
mov rdx, rsi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C8h
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov [rdi], rax
mov [r... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2)
{
int v2; // r14d
__m128i *v4; // rax
__m128i v5; // xmm1
int *v6; // r15
__m128i v7; // xmm2
long long v8; // rcx
__m128i *v9; // rax
size_t v10; // rbp
size_t v11; // r12
__m128i *p_src; // rdi
size_t v13; // rdx
void **v14; // rbp
__m128i *v16; ... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,ESI
LEA RSI,[0x102155]
PUSH R13
MOV RDX,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RSP + 0x20],RAX
LAB_00101924:
CALL 0x001... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
int *puVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
ulong uVar5;
string *psVar6;
string *psVar7;
int *piVar8;
string *psVar9;
int in_ESI;
int4 ... |
627 | func0 | #include<stdio.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(int number){
string current="";
vector<string> rep={"m","cm","d","cd","c","xc","l","xl","x","ix","v","iv","i"};
vector<int> num={1000,900,500,400,100,90,50,40,10,9,5,4,1};
int pos=0;
while(number>0)
{
while (number>=num[pos])
{
current=current+rep[pos];
... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(19) == "xix");
assert (func0(152) == "clii");
assert (func0(251) == "ccli");
assert (func0(426) == "cdxxvi");
assert (func0(500) == "d");
assert (func0(1) == "i");
assert (func0(4) == "iv");
assert (func0(43) == "xliii");
as... | O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
mov $0x6d63,%edx
mov $0x64,%ecx
mov $0x6378,%r8d
push %r14
mov $0x6c,%r9d
mov $0x6c78,%r10d
mov $0x78,%r11d
push %r13
mov %rdi,%r13
mov $0x76,%r14d
mov $0x7669,%r15d
push %r12
mov $0x7869,%r12d
push %rbp
mov %esi,%ebp
mov $0x6463,%es... | _Z5func0B5cxx11i:
endbr64
push r15
lea rcx, aCm+1; "m"
push r14
movq xmm0, rcx
lea rcx, aCd+1; "d"
mov r14d, esi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 0C8h
mov rax, fs:28h
mov [rsp+0F8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov qwor... | long long * func0[abi:cxx11](long long *a1, int a2)
{
int v2; // r14d
__m128i *v4; // rax
__m128i v5; // xmm1
int *v6; // r15
__m128i v7; // xmm2
size_t v8; // rbp
size_t v9; // r12
__m128i *p_src; // rdi
size_t v11; // rdx
long long v12; // rcx
long long *j; // rbp
_QWORD *v14; // rdi
long lo... | func0[abi:cxx11]:
ENDBR64
PUSH R15
LEA RCX,[0x102062]
PUSH R14
MOVQ XMM0,RCX
LEA RCX,[0x102065]
MOV R14D,ESI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0xc8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI],RAX
MOV ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
ulong * func0_abi_cxx11_(int param_1)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int *puVar5;
string *psVar6;
string *psVar7;
int *piVar8;
string *psVar9;
int in_ESI;
int4 ... |
628 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 4, 5) == true);
assert (func0(1, 2, 3) == false);
assert (func0(10, 6, 8) == true);
assert (func0(2, 2, 2) == false);
assert (func0(7, 24, 25) == true);
assert (func0(10, 5, 7) == false);
assert (func0(5, 12, 13) == true);
as... | O0 | cpp | func0(float, float, float):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
movss %xmm0,-0x4(%rbp)
movss %xmm1,-0x8(%rbp)
movss %xmm2,-0xc(%rbp)
movss -0x4(%rbp),%xmm0
movaps %xmm0,%xmm1
mulss %xmm0,%xmm1
movss -0x8(%rbp),%xmm0
mulss %xmm0,%xmm0
addss %xmm0,%xmm1
movss -0xc(%rbp),%xmm0
mulss %xmm0,%xmm... | _Z5func0fff:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
movss [rbp+var_4], xmm0
movss [rbp+var_8], xmm1
movss [rbp+var_C], xmm2
movss xmm0, [rbp+var_4]
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm0, [rbp+var_8]
mulss xmm0, xmm0
addss xmm1, xmm0
movss xmm0, [rbp+var_C]
mulss xmm0, xmm0
su... | _BOOL8 func0(float a1, float a2, float a3)
{
__m128i v3; // xmm1
float v4; // xmm0_4
__m128i v5; // xmm1
float v6; // xmm0_4
__m128i v7; // xmm1
float v8; // xmm0_4
char v9; // al
v3 = (__m128i)LODWORD(a1);
*(float *)v3.m128i_i32 = (float)((float)(*(float *)v3.m128i_i32 * *(float *)v3.m128i_i32) + (... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS dword ptr [RBP + -0x8],XMM1
MOVSS dword ptr [RBP + -0xc],XMM2
MOVSS XMM0,dword ptr [RBP + -0x4]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0x8]
MULSS XMM0,XMM0
ADDSS XMM1,XMM0
MOVSS XMM0,dword ptr [RBP + -0xc]
MU... | /* func0(float, float, float) */
int func0(float param_1,float param_2,float param_3)
{
int uVar1;
float fVar2;
fVar2 = (float)std::abs((param_1 * param_1 + param_2 * param_2) - param_3 * param_3);
if ((((double)fVar2 < DAT_00102160) ||
(fVar2 = (float)std::abs((param_1 * param_1 + param_3 * param_3)... |
629 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 4, 5) == true);
assert (func0(1, 2, 3) == false);
assert (func0(10, 6, 8) == true);
assert (func0(2, 2, 2) == false);
assert (func0(7, 24, 25) == true);
assert (func0(10, 5, 7) == false);
assert (func0(5, 12, 13) == true);
as... | O1 | cpp | func0(float, float, float):
endbr64
mulss %xmm0,%xmm0
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps 0xec5(%rip),%xmm3
cvtss2sd %xmm3,%xmm3
mov $0x1,%eax
movsd 0xec4(%rip),%xmm4
comisd %xmm3,%xmm4
ja 1198 <_Z5func0fff+0x6f>
movaps %xmm0,%xmm3
addss %xmm2,... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, cs:xmmword_2010
cvtss2sd xmm0, xmm0
mov eax, 1
movsd xmm4, cs:qword_2020
comisd xmm4, xmm0
ja short locret_119B
movaps xmm0, xmm3
addss x... | bool func0(float a1, float a2, float a3)
{
float v3; // xmm3_4
float v4; // xmm1_4
float v5; // xmm2_4
bool result; // al
v3 = a1 * a1;
v4 = a2 * a2;
v5 = a3 * a3;
result = 1;
if ( fabs((float)((float)(a1 * a1) + v4) - v5) >= 0.0001 && fabs((float)(v3 + v5) - v4) >= 0.0001 )
return fabs((float)(... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,xmmword ptr [0x00102010]
CVTSS2SD XMM0,XMM0
MOV EAX,0x1
MOVSD XMM4,qword ptr [0x00102020]
COMISD XMM4,XMM0
JA 0x0010119b
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,XMM1
ANDPS XMM0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
float fVar3;
float fVar4;
fVar4 = param_1 * param_1;
fVar2 = param_2 * param_2;
fVar3 = param_3 * para... |
630 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 4, 5) == true);
assert (func0(1, 2, 3) == false);
assert (func0(10, 6, 8) == true);
assert (func0(2, 2, 2) == false);
assert (func0(7, 24, 25) == true);
assert (func0(10, 5, 7) == false);
assert (func0(5, 12, 13) == true);
as... | O2 | cpp | func0(float, float, float):
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ab <_Z5func0fff+0x6b>
movaps %xmm0,... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11AE
movaps xmm... | bool func0(float a1, float a2, float a3)
{
bool result; // al
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((float)(... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011ae
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,X... | /* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
float fVar3;
float fVar4;
bVar1 = true;
fVar4 = param_1 * param_1;
fVar2 = param_2 * param_2;
fVar3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((fVar4 + fVar2) - ... |
631 | func0 | #include<stdio.h>
#include<math.h>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| bool func0(float a,float b,float c){
if (abs(a*a+b*b-c*c)<1e-4 or abs(a*a+c*c-b*b)<1e-4 or abs(b*b+c*c-a*a)<1e-4) return true;
return false;
}
| #undef NDEBUG
#include<assert.h>
int main(){
assert (func0(3, 4, 5) == true);
assert (func0(1, 2, 3) == false);
assert (func0(10, 6, 8) == true);
assert (func0(2, 2, 2) == false);
assert (func0(7, 24, 25) == true);
assert (func0(10, 5, 7) == false);
assert (func0(5, 12, 13) == true);
as... | O3 | cpp | func0(float, float, float):
endbr64
mulss %xmm0,%xmm0
movsd 0xed0(%rip),%xmm4
movss 0xeb8(%rip),%xmm5
mov $0x1,%eax
mulss %xmm1,%xmm1
mulss %xmm2,%xmm2
movaps %xmm0,%xmm3
addss %xmm1,%xmm3
subss %xmm2,%xmm3
andps %xmm5,%xmm3
cvtss2sd %xmm3,%xmm3
comisd %xmm3,%xmm4
ja 11ab <_Z5func0fff+0x6b>
movaps %xmm0,... | _Z5func0fff:
endbr64
movaps xmm3, xmm0
movsd xmm4, cs:qword_2020
movss xmm5, cs:dword_2010
mov eax, 1
mulss xmm3, xmm0
mulss xmm1, xmm1
mulss xmm2, xmm2
movaps xmm0, xmm3
addss xmm0, xmm1
subss xmm0, xmm2
andps xmm0, xmm5
cvtss2sd xmm0, xmm0
comisd xmm4, xmm0
ja short locret_11AE
movaps xmm... | bool func0(float a1, float a2, float a3)
{
bool result; // al
float v4; // xmm3_4
float v5; // xmm1_4
float v6; // xmm2_4
result = 1;
v4 = a1 * a1;
v5 = a2 * a2;
v6 = a3 * a3;
if ( fabs((float)((float)(a1 * a1) + v5) - v6) >= 0.0001 && fabs((float)(v4 + v6) - v5) >= 0.0001 )
return fabs((float)(... | func0:
ENDBR64
MOVAPS XMM3,XMM0
MOVSD XMM4,qword ptr [0x00102020]
MOVSS XMM5,dword ptr [0x00102010]
MOV EAX,0x1
MULSS XMM3,XMM0
MULSS XMM1,XMM1
MULSS XMM2,XMM2
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM1
SUBSS XMM0,XMM2
ANDPS XMM0,XMM5
CVTSS2SD XMM0,XMM0
COMISD XMM4,XMM0
JA 0x001011ae
MOVAPS XMM0,XMM3
ADDSS XMM0,XMM2
SUBSS XMM0,X... | /* func0(float, float, float) */
bool func0(float param_1,float param_2,float param_3)
{
bool bVar1;
float fVar2;
float fVar3;
float fVar4;
bVar1 = true;
fVar4 = param_1 * param_1;
fVar2 = param_2 * param_2;
fVar3 = param_3 * param_3;
if ((DAT_00102020 <= (double)(float)((uint)((fVar4 + fVar2) - ... |
632 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> words){
string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
if (find(unique.begin(),unique.end(),words[i][j])==unique.end())
unique=unique+words[i][j];
if (un... | #undef NDEBUG
#include<assert.h>
int main(){
assert ((func0({"name", "of", "string"}) == "string"));
assert ((func0({"name", "enam", "game"}) == "enam"));
assert ((func0({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
assert ((func0({"abc", "cba"}) == "abc"));
assert ((func0({"play", "this", "game", "of",... | O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
add $0xffffffffffffff80,%rsp
mov %rdi,-0x88(%rbp)
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 90h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_78]
mov [rbp+var_70],... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // r12
long long v4; // rbx
long long v5; // rax
long long v6; // rax
char *v7; // rax
long long v8; // rax
long long v9; // rax
long long v11; // rax
int v13; // [rsp+14h] [rbp-8Ch]
int i; // [rsp+18h] [rbp-88h]
i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x90
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x78]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x78]
MOV RAX,qword ptr [RBP + -0x98]
L... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
bool bVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
char *pcVar4;
int4 extraout_var;
long lVar5;
string *psVar6;
ulong uVar7;
vector<std::string,std::allocator<std::string>> *in_RSI;
int... |
633 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> words){
string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
if (find(unique.begin(),unique.end(),words[i][j])==unique.end())
unique=unique+words[i][j];
if (un... | #undef NDEBUG
#include<assert.h>
int main(){
assert ((func0({"name", "of", "string"}) == "string"));
assert ((func0({"name", "enam", "game"}) == "enam"));
assert ((func0({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
assert ((func0({"abc", "cba"}) == "abc"));
assert ((func0({"play", "this", "game", "of",... | O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,0x10(%rsp)... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 88h
mov [rsp+0B8h+var_A0], rdi
mov r14, rsi
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov ... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // r13
size_t v4; // rbx
long long v5; // rbp
char *v6; // rax
void *v7; // rbx
unsigned long long v8; // r12
char *v9; // rdi
char *v10; // rsi
unsigned long long v11; // rdx
char *v12; // rcx
long long v13; // rax
char *v14; // rax
l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x88
MOV qword ptr [RSP + 0x18],RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RSI,[0x10309d]
MOV RDX,RSI
LAB_001013a7:
CALL 0x0010211a
MOV RAX,qword ptr ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
ulong *puVar1;
char cVar2;
ulong *puVar3;
uint uVar4;
int iVar5;
ulong *puVar6;
long lVar7;
int8 uVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
ulong uVar12;
long *in_RSI;
char *pcVar13;
... |
634 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> words){
string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
if (find(unique.begin(),unique.end(),words[i][j])==unique.end())
unique=unique+words[i][j];
if (un... | #undef NDEBUG
#include<assert.h>
int main(){
assert ((func0({"name", "of", "string"}) == "string"));
assert ((func0({"name", "enam", "game"}) == "enam"));
assert ((func0({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
assert ((func0({"abc", "cba"}) == "abc"));
assert ((func0({"play", "this", "game", "of",... | O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,0x20(%rsp)... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
lea rdx, aFunc0BB+15h; ""
mov r15, rsi
push r14
mov rsi, rdx
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], rdi
mov rax, fs:28h
mov [rsp+0C8h+var_40], r... | const void ** func0(const void **a1, long long *a2)
{
long long v3; // rdi
signed long long v4; // r12
long long v5; // r13
const void **v6; // r14
size_t v7; // rbx
size_t v8; // rbp
void *v9; // rbx
char *v10; // rcx
long long v11; // rdx
char *v12; // rsi
char *v13; // rax
double *v15; // rdi... | func0:
ENDBR64
PUSH R15
LEA RDX,[0x10309d]
MOV R15,RSI
PUSH R14
MOV RSI,RDX
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LAB_00101ba1:
CALL 0x00101ab0
MOV RAX,qword ptr ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
char cVar1;
ulong *puVar2;
uint uVar3;
int iVar4;
ulong *puVar5;
ulong uVar6;
ulong uVar7;
long *in_RSI;
int4 in_register_0000003c;
string *psVar8;
long lVar9;
ulong uVar10;
long *plVar11;
... |
635 | func0 | #include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
#include<math.h>
#include<stdlib.h>
| string func0(vector<string> words){
string max="";
int maxu=0;
for (int i=0;i<words.size();i++)
{
string unique="";
for (int j=0;j<words[i].length();j++)
if (find(unique.begin(),unique.end(),words[i][j])==unique.end())
unique=unique+words[i][j];
if (un... | #undef NDEBUG
#include<assert.h>
int main(){
assert ((func0({"name", "of", "string"}) == "string"));
assert ((func0({"name", "enam", "game"}) == "enam"));
assert ((func0({"aaaaaaa", "bb", "cc"}) == "aaaaaaa"));
assert ((func0({"abc", "cba"}) == "abc"));
assert ((func0({"play", "this", "game", "of",... | O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
mov %rdi,%rax
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_A0], rdi
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
lea rax, [rdi+10h]
mov ... | long long func0(long long a1, long long *a2, unsigned long long a3, char *a4)
{
long long v5; // r13
__int8 *v6; // rbx
const void **v7; // r13
size_t v8; // r14
size_t v9; // rbp
signed long long v10; // r12
char *v11; // rsi
char *v12; // rax
double *v13; // rdi
size_t v14; // xmm0_8
__m128 v15... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV byte ptr [RDI + 0x10],0x0
MOV R13,qword ptr [RSI]
MOV qword ptr [RDI],RAX
LEA RAX,[RSP + 0x50]
MOV ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
string * func0(vector param_1)
{
char cVar1;
ulong *puVar2;
uint uVar3;
int iVar4;
ulong *puVar5;
ulong uVar6;
int8 uVar7;
ulong uVar8;
long lVar9;
long *in_RSI;
int4 in_register_0000003c;
string *psVar10;
long *plVar11;
... |
636 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int number,int need,int remaining){
if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5, 6, 10) , {11, 4}));
assert (issame(func0(4, 8, 9) , {12, 1}))... | O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %rdi,-0x58(%rbp)
mov %esi,-0x5c(%rbp)
mov %edx,-0x60(%rbp)
mov %ecx,-0x64(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov -0x60(%rbp),%eax
c... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_48], rdi
mov [rbp+var_4C], esi
mov [rbp+var_50], edx
mov [rbp+var_54], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_50]
cmp eax, [rbp+var_54]
jle short loc_12D6... | long long func0(long long a1, int a2, int a3, int a4)
{
char v5; // [rsp+2Fh] [rbp-31h] BYREF
char *v6; // [rsp+30h] [rbp-30h]
char *v7; // [rsp+38h] [rbp-28h]
int v8; // [rsp+40h] [rbp-20h] BYREF
int v9; // [rsp+44h] [rbp-1Ch]
unsigned long long v10; // [rsp+48h] [rbp-18h]
v10 = __readfsqword(0x28u);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV dword ptr [RBP + -0x50],EDX
MOV dword ptr [RBP + -0x54],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x54... | /* func0(int, int, int) */
int8 func0(int param_1,int param_2,int param_3)
{
int in_ECX;
int4 in_register_0000003c;
long in_FS_OFFSET;
__new_allocator<int> local_39;
__new_allocator<int> *local_38;
__new_allocator<int> *local_30;
int local_28;
int local_24;
long local_20;
local_20 = *(long *)(i... |
637 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int number,int need,int remaining){
if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5, 6, 10) , {11, 4}));
assert (issame(func0(4, 8, 9) , {12, 1}))... | O1 | cpp | func0(int, int, int):
endbr64
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %ecx,%edx
jle 129a <_Z5func0iii+0x91>
lea (%rcx,%rsi,1),%ebp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x8,%edi
callq 10f0 <_Zn... | _Z5func0iii:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
cmp edx, ecx
jle short loc_12CB
lea ebp, [rcx+rsi]
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov edi, 8; unsigned __int64
call __Znwm; operator new(ulong)
mov [rbx], rax
lea ... | unsigned long long ** func0(unsigned long long **a1, int a2, int a3, int a4)
{
unsigned long long v4; // rbp
unsigned long long *v5; // rax
if ( a3 <= a4 )
v4 = ((unsigned long long)(unsigned int)(a4 - a3) << 32) | (unsigned int)(a3 + a2);
else
v4 = (unsigned int)(a4 + a2);
*a1 = 0LL;
a1[1] = 0LL;
... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
CMP EDX,ECX
JLE 0x001012cb
LEA EBP,[RCX + RSI*0x1]
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV EDI,0x8
LAB_00101293:
CALL 0x001010e0
MOV qword ptr [RBX],RAX
LEA RDX,[RAX + 0x8]
MOV qword ptr [RBX + 0x10],RDX
MOV qword ... | /* func0(int, int, int) */
int8 * func0(int param_1,int param_2,int param_3)
{
ulong *puVar1;
int8 *puVar2;
int in_ECX;
int4 in_register_0000003c;
int8 *puVar3;
puVar3 = (int8 *)CONCAT44(in_register_0000003c,param_1);
if (in_ECX < param_3) {
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
... |
638 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int number,int need,int remaining){
if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5, 6, 10) , {11, 4}));
assert (issame(func0(4, 8, 9) , {12, 1}))... | O2 | cpp | func0(int, int, int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %ecx,%edx
jle 17c0 <_Z5func0iii+0x80>
movq $0x0,(%rdi)
lea (%rcx,%rsi,1),%ebx
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov $0x8,%edi
call... | _Z5func0iii:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
cmp edx, ecx
jle short loc_1670
mov qword ptr [rdi+10h], 0
pxor xmm0, xmm0
lea ebp, [rcx+rsi]
movups xmmword ptr [rdi], xmm0
mov edi, 8; unsigned __int64
call __Znwm; operator new(ulong)
loc_164D:
lea rdx, [rax+8... | long long func0(long long a1, int a2, int a3, int a4)
{
unsigned long long v4; // rbp
unsigned long long *v5; // rax
_QWORD *v6; // rdx
long long result; // rax
*(_QWORD *)(a1 + 16) = 0LL;
if ( a3 <= a4 )
{
*(_OWORD *)a1 = 0LL;
v4 = ((unsigned long long)(unsigned int)(a4 - a3) << 32) | (unsigned... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CMP EDX,ECX
JLE 0x00101670
MOV qword ptr [RDI + 0x10],0x0
PXOR XMM0,XMM0
LEA EBP,[RCX + RSI*0x1]
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x8
LAB_00101648:
CALL 0x001010e0
LAB_0010164d:
LEA RDX,[RAX + 0x8]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x10],RDX
MOV q... | /* func0(int, int, int) */
int (*) [16] func0(int param_1,int param_2,int param_3)
{
ulong *puVar1;
int in_ECX;
ulong uVar2;
int4 in_register_0000003c;
int (*pauVar3) [16];
pauVar3 = (int (*) [16])CONCAT44(in_register_0000003c,param_1);
if (in_ECX < param_3) {
*(int8 *)pauVar3[1] = 0;
uVar2 =... |
639 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int number,int need,int remaining){
if (need>remaining) return {number+remaining, 0};
return {number+need,remaining-need};
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(5, 6, 10) , {11, 4}));
assert (issame(func0(4, 8, 9) , {12, 1}))... | O3 | cpp | func0(int, int, int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %ecx,%edx
jle 17b0 <_Z5func0iii+0x70>
movq $0x0,0x10(%rdi)
pxor %xmm0,%xmm0
lea (%rcx,%rsi,1),%ebx
movups %xmm0,(%rdi)
mov $0x8,%edi
callq ... | _Z5func0iii:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
cmp edx, ecx
jle short loc_1750
mov qword ptr [rdi+10h], 0
pxor xmm0, xmm0
lea ebp, [rcx+rsi]
movups xmmword ptr [rdi], xmm0
mov edi, 8; unsigned __int64
call __Znwm; operator new(ulong)
loc_172D:
lea rdx, [rax+8... | long long func0(long long a1, int a2, int a3, int a4)
{
unsigned long long v4; // rbp
unsigned long long *v5; // rax
_QWORD *v6; // rdx
long long result; // rax
*(_QWORD *)(a1 + 16) = 0LL;
if ( a3 <= a4 )
{
*(_OWORD *)a1 = 0LL;
v4 = ((unsigned long long)(unsigned int)(a4 - a3) << 32) | (unsigned... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CMP EDX,ECX
JLE 0x00101750
MOV qword ptr [RDI + 0x10],0x0
PXOR XMM0,XMM0
LEA EBP,[RCX + RSI*0x1]
MOVUPS xmmword ptr [RDI],XMM0
MOV EDI,0x8
LAB_00101728:
CALL 0x001010e0
LAB_0010172d:
LEA RDX,[RAX + 0x8]
MOV qword ptr [RBX],RAX
MOV qword ptr [RBX + 0x10],RDX
MOV q... | /* func0(int, int, int) */
int (*) [16] func0(int param_1,int param_2,int param_3)
{
ulong *puVar1;
int in_ECX;
ulong uVar2;
int4 in_register_0000003c;
int (*pauVar3) [16];
pauVar3 = (int (*) [16])CONCAT44(in_register_0000003c,param_1);
if (in_ECX < param_3) {
*(int8 *)pauVar3[1] = 0;
uVar2 =... |
640 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<string> operato, vector<int> operand){
vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int i=0;i<operato.size();i++)
if (operato[i]=="**")
{
while (posto[posto[i]]!=posto[i]) posto[i]=posto[posto[i]];... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"**", "*", "+"}, {2, 3, 4, 5}) == 37);
assert (func0({"+", "*", "-"}, {2, 3, 4, 5}) == 9);
assert (func0({"//", "*"}, {7, 3, 4}) == 8);
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES_IiSaIiEE:
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
pxor xmm0, xmm0
movaps [rbp+var_50], xmm0
mov... | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rbx
long long v3; // rax
int *v4; // rax
int v5; // ebx
int *v6; // rax
int v7; // ebx
int *v8; // rax
int v9; // ebx
int *v10; // rax
int v11; // ebx
int *v12; // rax
unsigned int v13; // ebx
int *v14; // rax
unsigned ... | 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
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOVQ qword ptr [RBP + -0x40],XMM0
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL ... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<int,
std::allocator<int> >) */
int4 func0(vector param_1,vector param_2)
{
int iVar1;
int iVar2;
int4 uVar3;
bool bVar4;
ulong uVar5;
string *psVar6;
int *piVar7;
int4 *puVar8;
ulong uVar9;
int4 in_register_00000034;
... |
641 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<string> operato, vector<int> operand){
vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int i=0;i<operato.size();i++)
if (operato[i]=="**")
{
while (posto[posto[i]]!=posto[i]) posto[i]=posto[posto[i]];... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"**", "*", "+"}, {2, 3, 4, 5}) == 37);
assert (func0({"+", "*", "-"}, {2, 3, 4, 5}) == 9);
assert (func0({"//", "*"}, {7, 3, 4}) == 8);
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES_IiSaIiEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov [rsp+88h+var_78], 0
mov ... | long long func0(long long *a1, unsigned int **a2)
{
unsigned long long v4; // rbp
char *v5; // rsi
long long v6; // rax
unsigned long long v7; // rbp
unsigned int *v8; // r15
long long v9; // rax
_DWORD *v10; // rcx
int *v11; // r13
int v12; // eax
int v13; // edx
int *v14; // r14
long long v15... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP ... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<int,
std::allocator<int> >) */
int4 func0(vector param_1,vector param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
char cVar4;
int4 uVar5;
long lVar6;
int iVar7;
int8 *puVar8;
long lVar9;
ulong uVar10;
int4 in_regist... |
642 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<string> operato, vector<int> operand){
vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int i=0;i<operato.size();i++)
if (operato[i]=="**")
{
while (posto[posto[i]]!=posto[i]) posto[i]=posto[posto[i]];... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"**", "*", "+"}, {2, 3, 4, 5}) == 37);
assert (func0({"+", "*", "-"}, {2, 3, 4, 5}) == 9);
assert (func0({"//", "*"}, {7, 3, 4}) == 8);
}
| O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push ... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES_IiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, [rsi]
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
mov [r... | long long func0(long long *a1, unsigned int **a2)
{
unsigned int *v2; // r12
unsigned long long v4; // rbx
char *v5; // rdx
char *i; // rsi
unsigned int *v7; // rax
int v8; // ebp
int *v9; // rbx
long long v10; // rax
long long v11; // rbp
unsigned long long v12; // r8
int *v13; // r13
long lon... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x2c],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x60],0x0
MOVAPS xmmword ptr [RSP... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<int,
std::allocator<int> >) */
int4 func0(vector param_1,vector param_2)
{
int4 uVar1;
char *pcVar2;
int iVar3;
long lVar4;
long lVar5;
long lVar6;
int *piVar7;
int *piVar8;
ulong uVar9;
int4 in_register_00000034;
i... |
643 | func0 | #include<stdio.h>
#include<math.h>
#include<vector>
#include<string>
using namespace std;
#include<algorithm>
#include<stdlib.h>
| int func0(vector<string> operato, vector<int> operand){
vector<int> num={};
vector<int> posto={};
for (int i=0;i<operand.size();i++)
posto.push_back(i);
for (int i=0;i<operato.size();i++)
if (operato[i]=="**")
{
while (posto[posto[i]]!=posto[i]) posto[i]=posto[posto[i]];... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0({"**", "*", "+"}, {2, 3, 4, 5}) == 37);
assert (func0({"+", "*", "-"}, {2, 3, 4, 5}) == 9);
assert (func0({"//", "*"}, {7, 3, 4}) == 8);
}
| O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::vector<int, std::allocator<int> >):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
mov %rsi,%r13
... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EES_IiSaIiEE:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov rdx, [rsi+8]
mov r12, [rsi]
mov rax, fs:28h
mov [rsp+98h+var_40], rax
xor ... | long long func0(long long *a1, unsigned int **a2)
{
unsigned int *v2; // rdx
unsigned int *v3; // r12
unsigned long long v5; // rbx
char *v6; // rcx
char *i; // rsi
int v8; // r13d
int *v9; // rbx
long long v10; // rbp
int *v11; // r13
unsigned long long v12; // r8
long long v13; // r14
unsigne... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV RDX,qword ptr [RSI + 0x8]
MOV R12,qword ptr [RSI]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x1c],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x5... | /* func0(std::vector<std::string, std::allocator<std::string > >, std::vector<int,
std::allocator<int> >) */
int4 func0(vector param_1,vector param_2)
{
int4 uVar1;
char *pcVar2;
int iVar3;
long lVar4;
long lVar5;
long lVar6;
int *piVar7;
int *piVar8;
int4 *puVar9;
ulong uVar10;
int4 in_regis... |
644 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string s){
int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
else nletter+=1;
out=out+w;
}
if (nletter==s.length())
{
string p(s.rbegin(),s.r... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AsDf") == "aSdF");
assert (func0("1234") == "4321");
assert (func0("ab") == "AB");
assert (func0("#a@C") == "#A@c");
assert (func0("#AsdfW^45") == "#aSDFw^45");
assert (func0("#6@2") == "2@6#");
assert (func0("#$a^D") == "#$A^d");
... | O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
movl $0x0,-0x78(%rbp)
lea -0x68(%rbp),%rax
mov ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 98h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_88], 0
lea rax, [rbp+var_78]
mov [rbp+var_70], rax
n... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+16h] [rbp-8Ah] BYREF
char v4; // [rsp+17h] [rbp-89h]
int v5; // [rsp+18h] [rbp-88h]
int i; // [rsp+1Ch] [rbp-84h]
_BYTE v7[8]; // [rsp+20h] [rbp-80h] BYREF
_BYTE v8[8]; // [rsp+28h] [rbp-78h] BYREF
_BYTE *v9; // [rsp+30h] [rbp-70h]
char *v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x88],0x0
LEA RAX,[RBP + -0x78]
MOV qword ptr [RBP + -0x70],RAX
NOP
NOP
LEA RDX,[RBP + -0x78]
LEA RAX,[R... | /* func0(std::string) */
string * func0(string *param_1,ulong param_2)
{
char *pcVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
allocator local_92;
char local_91;
int local_90;
int local_8c;
int local_88 [8];
allocator local_80 [8];
allocator *local_78;
allocato... |
645 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string s){
int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
else nletter+=1;
out=out+w;
}
if (nletter==s.length())
{
string p(s.rbegin(),s.r... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AsDf") == "aSdF");
assert (func0("1234") == "4321");
assert (func0("ab") == "AB");
assert (func0("#a@C") == "#A@c");
assert (func0("#AsdfW^45") == "#aSDFw^45");
assert (func0("#6@2") == "2@6#");
assert (func0("#$a^D") == "#$A^d");
... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,(%rsp)
mov %rsi,%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%rdi
lea 0x30(%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r15, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rdi, [rsp+0A8h+var_88]
lea rax, [rsp+0A8h+var_7... | void ** func0(void **a1, unsigned long long *a2)
{
unsigned long long v4; // rbx
char v5; // al
char *v6; // rax
long long v7; // rcx
unsigned long long v8; // rax
unsigned long long v9; // rbp
void *v10; // r14
long long v11; // rdx
unsigned long long v12; // rdi
char *v13; // rax
char *v14; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R15,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x20]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LEA RSI,[0x10215f]
MOV RDX,RSI
LAB_0010130a:
CALL 0x00101e68
CMP qword... | /* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2)
{
char cVar1;
uint uVar2;
int8 uVar3;
ulong *puVar4;
ulong uVar5;
ulong uVar6;
uint uVar7;
int *puVar8;
long lVar9;
ulong uVar10;
int *puVar11;
long in_FS_OFFSET;
int local_9c;
ulong local_90;
ulong *local_88;
int8 loca... |
646 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string s){
int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
else nletter+=1;
out=out+w;
}
if (nletter==s.length())
{
string p(s.rbegin(),s.r... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AsDf") == "aSdF");
assert (func0("1234") == "4321");
assert (func0("ab") == "AB");
assert (func0("#a@C") == "#A@c");
assert (func0("#AsdfW^45") == "#aSDFw^45");
assert (func0("#6@2") == "2@6#");
assert (func0("#$a^D") == "#$A^d");
... | O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rax
cmpq $0x0,0x8(%rsi)
movq ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_B8], rdi
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
lea rax, [rsp+0D8h+var_80+8]
cmp qword ptr [rsi+8], 0... | void ** func0(void **a1, long long *a2)
{
bool v2; // zf
long long v3; // rbx
size_t v4; // r12
char v5; // al
double *v6; // rdi
size_t v7; // rdx
__m128 v8; // xmm0
double v9; // rdx
unsigned long long v10; // r12
void *v11; // rcx
_QWORD *v12; // rdx
long long v14; // rbx
double *v15; // ra... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
CMP qword ptr [RSI + 0x8],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2,int8 param_3,int8 *****param_4)
{
int8 *puVar1;
int8 *****pppppuVar2;
int *puVar3;
int8 ****ppppuVar4;
int8 ****ppppuVar5;
char cVar6;
uint uVar7;
int8 *****pppppuV... |
647 | func0 | #include<stdio.h>
#include<string>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string s){
int nletter=0;
string out="";
for (int i=0;i<s.length();i++)
{
char w=s[i];
if (w>=65 and w<=90) w=w+32;
else if (w>=97 and w<=122) w=w-32;
else nletter+=1;
out=out+w;
}
if (nletter==s.length())
{
string p(s.rbegin(),s.r... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("AsDf") == "aSdF");
assert (func0("1234") == "4321");
assert (func0("ab") == "AB");
assert (func0("#a@C") == "#A@c");
assert (func0("#AsdfW^45") == "#aSDFw^45");
assert (func0("#6@2") == "2@6#");
assert (func0("#$a^D") == "#$A^d");
... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov 0x8(%rsi),%rdx
mov %rdi,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rax
movb ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov rdx, [rsi+8]
mov [rsp+0D8h+var_B8], rdi
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
lea rax, [rsp+0D8h+var_80+8]
mov ... | void ** func0(void **a1, long long *a2)
{
_BYTE *v2; // rdx
unsigned long long v3; // rbx
size_t v4; // r12
char v5; // al
double *v6; // rdi
size_t v7; // rdx
__m128 v8; // xmm0
double v9; // rdx
unsigned long long v10; // r12
void *v11; // rcx
_QWORD *v12; // rdx
long long v14; // rbx
long l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
MOV byte ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RSP + 0x5... | /* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(std::string) */
int8 * func0(int8 *param_1,long *param_2,int8 param_3,int8 *****param_4)
{
int8 *puVar1;
int *puVar2;
int8 ****ppppuVar3;
int8 ****ppppuVar4;
char cVar5;
uint uVar6;
int8 *****pppppuVar7;
int8 *****pppppuV... |
648 | func0 | #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.c_str(), text.length());
MD5_Final(md, &c);
string out_str="";
for (int i=0;i<16;i++)
{
char w;
if (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
assert (func0("") == "None");
assert (func0("A B C") == "0ef78513b0cb8cef12743f5aeb35f888");
assert (func0("password") == "5f4dcc3b5aa765d61d8327deb882cf99");
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x108,%rsp
mov %rdi,-0x108(%rbp)
mov %rsi,-0x110(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x110(%rbp),%rax
mov %rax,%rdi
callq 239... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0F8h
mov [rbp+var_F8], rdi
mov [rbp+var_100], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_100]
mov rdi, rax
call __ZNKSt7__cxx1112basic_... | long long func0(long long a1, long long a2)
{
long long v2; // rbx
long long v3; // rax
char v4; // al
char v5; // al
char v7; // [rsp+1Ah] [rbp-E6h] BYREF
char v8; // [rsp+1Bh] [rbp-E5h]
int i; // [rsp+1Ch] [rbp-E4h]
char *v10; // [rsp+20h] [rbp-E0h]
char *v11; // [rsp+28h] [rbp-D8h]
_BYTE v12[32]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xf8
MOV qword ptr [RBP + -0xf8],RDI
MOV qword ptr [RBP + -0x100],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x100]
MOV RDI,RAX
CALL 0x00102370
TEST RAX,RAX
SETZ AL
TEST AL,AL
JZ 0x00102553
LEA RAX,[RBP + -0x... | /* func0(std::string) */
string * func0(string *param_1)
{
long lVar1;
size_t len;
void *data;
long in_FS_OFFSET;
allocator local_ee;
char local_ed;
int local_ec;
allocator *local_e8;
allocator *local_e0;
string local_d8 [32];
string local_b8 [32];
MD5_CTX local_98;
byte local_38 [24];
lon... |
649 | func0 | #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.c_str(), text.length());
MD5_Final(md, &c);
string out_str="";
for (int i=0;i<16;i++)
{
char w;
if (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
assert (func0("") == "None");
assert (func0("A B C") == "0ef78513b0cb8cef12743f5aeb35f888");
assert (func0("password") == "5f4dcc3b5aa765d61d8327deb882cf99");
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov %rdi,%r14
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
cmpq $0x0,0x8(%rsi)
jne 131e <_Z5func0NSt7__cxx1112... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0E8h
mov [rsp+118h+var_110], rdi
mov rax, fs:28h
mov [rsp+118h+var_40], rax
xor eax, eax
cmp qword ptr [rsi+8], 0
jnz short loc_13A2
lea ... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
unsigned __int8 *v3; // rbx
char v4; // al
char *v5; // rax
long long v6; // rcx
unsigned __int8 v7; // al
char v8; // dl
bool v9; // cc
char v10; // al
unsigned long long v11; // r12
_QWORD *v12; // r13
unsigned int v13; // edx
unsigned long long v14; //... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xd8],RAX
XOR EAX,EAX
CMP qword ptr [RSI + 0x8],0x0
JNZ 0x001013a2
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x102194]
LEA RSI,[RDX + -0x4]
LAB_001... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
ulong *puVar1;
byte bVar2;
uint uVar3;
int8 uVar4;
long lVar5;
ulong uVar6;
ulong uVar7;
uint uVar8;
byte *md;
long in_FS_OFFSET;
char local_fa;
char local_f9;
ulong *local_f8;
int8 local_f0;
ulong local_e8 [2];
ulong... |
650 | func0 | #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.c_str(), text.length());
MD5_Final(md, &c);
string out_str="";
for (int i=0;i<16;i++)
{
char w;
if (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
assert (func0("") == "None");
assert (func0("A B C") == "0ef78513b0cb8cef12743f5aeb35f888");
assert (func0("password") == "5f4dcc3b5aa765d61d8327deb882cf99");
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %rdi,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
cmpq $0x0,0x8(%rsi)
jne 1610 <_Z5func0NSt7_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov [rsp+138h+var_110], rdi
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
cmp qword ptr [rsi+8], 0
jnz short loc_1620
lea ... | long long func0(long long a1, _QWORD *a2)
{
size_t v3; // r13
unsigned __int8 *v4; // r12
__m128 v5; // xmm0
double v6; // rdx
unsigned __int8 v7; // al
size_t v8; // r13
char v9; // dl
bool v10; // cc
char v11; // al
double *v12; // rdi
size_t v13; // rdx
__m128 v14; // xmm0
double v15; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
CMP qword ptr [RSI + 0x8],0x0
JNZ 0x00101620
LEA RAX,[RDI + 0x10]
MOV dword ptr [RDI + 0x10],0x656e6f4e
MOV qword ptr [RDI],RAX
MOV qwo... | /* func0(std::string) */
int8 * func0(int8 *param_1,int8 *param_2)
{
ulong *puVar1;
byte bVar2;
uint uVar3;
long lVar4;
ulong uVar5;
uint uVar6;
byte *md;
long in_FS_OFFSET;
char local_fa;
char local_f9;
ulong *local_f8;
int8 local_f0;
ulong auStack_e8 [2];
ulong *local_d8;
size_t local_... |
651 | func0 | #include<stdio.h>
#include<string>
#include<openssl/md5.h>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| string func0(string text){
unsigned char md[16];
if (text.length()==0) return "None";
MD5_CTX c;
int i;
MD5_Init(&c);
MD5_Update(&c, (unsigned char*)text.c_str(), text.length());
MD5_Final(md, &c);
string out_str="";
for (int i=0;i<16;i++)
{
char w;
if (... | #undef NDEBUG
#include<assert.h>
int main(){
assert (func0("Hello world") == "3e25960a79dbc69b674cd4ec67a72c62");
assert (func0("") == "None");
assert (func0("A B C") == "0ef78513b0cb8cef12743f5aeb35f888");
assert (func0("password") == "5f4dcc3b5aa765d61d8327deb882cf99");
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x138,%rsp
mov %rdi,0x28(%rsp)
mov %fs:0x28,%rax
mov %rax,0x128(%rsp)
xor %eax,%eax
cmpq $0x0,0x8(%rsi)
jne 16e0 <_Z5func0NSt7_... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 108h
mov [rsp+138h+var_110], rdi
mov rax, fs:28h
mov [rsp+138h+var_40], rax
xor eax, eax
cmp qword ptr [rsi+8], 0
jnz short loc_1620
lea ... | long long func0(long long a1, _QWORD *a2)
{
size_t v3; // r13
unsigned __int8 *v4; // r12
__m128 v5; // xmm0
double v6; // rdx
unsigned __int8 v7; // al
size_t v8; // r13
char v9; // dl
bool v10; // cc
char v11; // al
double *v12; // rdi
size_t v13; // rdx
__m128 v14; // xmm0
double v15; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x108
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xf8],RAX
XOR EAX,EAX
CMP qword ptr [RSI + 0x8],0x0
JNZ 0x00101620
LEA RAX,[RDI + 0x10]
MOV dword ptr [RDI + 0x10],0x656e6f4e
MOV qword ptr [RDI],RAX
MOV qwo... | /* func0(std::string) */
int8 * func0(int8 *param_1,int8 *param_2)
{
ulong *puVar1;
byte bVar2;
uint uVar3;
long lVar4;
ulong uVar5;
uint uVar6;
byte *md;
long in_FS_OFFSET;
char local_fa;
char local_f9;
ulong *local_f8;
ulong local_f0;
ulong auStack_e8 [2];
ulong *local_d8;
size_t local... |
652 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int a,int b){
int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2, 10) , {2, 4, 6, 8}));
assert (issame(func0(10, 2) , {2, 4, 6,... | O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x30(%rbp),%eax
cmp -0x2c(%rbp),%eax
jge 1269 <_Z5func0ii+0x40>
mov -0x2c(%rbp),%eax
... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_30]
cmp eax, [rbp+var_2C]
jge short loc_1289
mov eax, [rbp+var_2C]
... | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+0h] [rbp-30h]
int v5; // [rsp+4h] [rbp-2Ch]
_DWORD v6[2]; // [rsp+10h] [rbp-20h] BYREF
unsigned long long v7; // [rsp+18h] [rbp-18h]
v5 = a2;
v4 = a3;
v7 = __readfsqword(0x28u);
if ( a3 < a2 )
{
v6[1] = a2;
v5 = a3;
v4 = a2;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x30]
CMP EAX,dword ptr [RBP + -0x2c]
JGE 0x00101289
MOV EAX,dword p... | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint in_EDX;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_38;
uint local_34;
uint local_28;
int local_24;
long local_20;
this = (vector<int,std::allocator<... |
653 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int a,int b){
int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2, 10) , {2, 4, 6, 8}));
assert (issame(func0(10, 2) , {2, 4, 6,... | O1 | cpp | func0(int, int):
endbr64
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbp
mov %edx,%ebx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %esi,%edx
jge 1329 <_Z5func0ii+0xa9>
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov %edx,0x4(%rsp)
mov %esi,%e... | _Z5func0ii:
endbr64
push r12
push rbp
push rbx
sub rsp, 10h
mov r12, rdi
mov ebp, esi
mov ebx, edx
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
cmp edx, esi
jl short loc_12AE
mov ebx, esi
mov ebp, edx
loc_12AE:
pxor xmm0, xmm0
movups xmmword ptr [r12],... | long long func0(long long a1, int a2, int a3)
{
int v3; // ebp
int v4; // ebx
int *v5; // rsi
int v7; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-20h]
v3 = a2;
v4 = a3;
v8 = __readfsqword(0x28u);
if ( a3 >= a2 )
{
v4 = a2;
v3 = a3;
}
*(_OWORD *)a1 = 0LL;
*(_QW... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV R12,RDI
MOV EBP,ESI
MOV EBX,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP EDX,ESI
JL 0x001012ae
MOV EBX,ESI
MOV EBP,EDX
LAB_001012ae:
PXOR XMM0,XMM0
MOVUPS xmmword ptr [R12],XMM0
MOV qword ptr [R12 + 0x10],0x0
MOV dword ptr [RSP ... | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint in_EDX;
uint uVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_24;
long local_20;
this = (vector<int,std::allocator<int>> ... |
654 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int a,int b){
int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2, 10) , {2, 4, 6, 8}));
assert (issame(func0(10, 2) , {2, 4, 6,... | O2 | cpp | func0(int, int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %esi,%edx
jge 17eb <_Z5func0ii+0x2b>
mov %esi,%eax
mov %edx,%esi
mov %eax,%ebx
movq $0x0,(%r12)
lea 0x4(%rsp),%rbp
movq $... | _Z5func0ii:
endbr64
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
mov ebx, edx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
cmp edx, esi
jl short loc_16CB
mov ebx, esi
mov ebp, edx
loc_16CB:
pxor xmm0, xmm0
mov [rsp+28h+var_24], ... | long long func0(long long a1, int a2, int a3)
{
int v3; // ebp
int v4; // ebx
_DWORD *v5; // rsi
int v7; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-20h]
v3 = a2;
v4 = a3;
v8 = __readfsqword(0x28u);
if ( a3 >= a2 )
{
v4 = a2;
v3 = a3;
}
v7 = v4;
*(_QWORD *)(a1... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP EDX,ESI
JL 0x001016cb
MOV EBX,ESI
MOV EBP,EDX
LAB_001016cb:
PXOR XMM0,XMM0
MOV dword ptr [RSP + 0x4],EBX
MOV qword ptr [R12 + 0x10],0x0
MOVUPS xmmword ptr ... | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint in_EDX;
uint uVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_24;
long local_20;
this = (vector<int,std::allocator<int>> ... |
655 | func0 | #include<stdio.h>
#include<vector>
using namespace std;
#include<algorithm>
#include<math.h>
#include<stdlib.h>
| vector<int> func0(int a,int b){
int m;
if (b<a)
{
m=a;a=b;b=m;
}
vector<int> out={};
for (int i=a;i<=b;i++)
if (i<10 and i%2==0) out.push_back(i);
return out;
}
| #undef NDEBUG
#include<assert.h>
bool issame(vector<int> a,vector<int>b){
if (a.size()!=b.size()) return false;
for (int i=0;i<a.size();i++)
{
if (a[i]!=b[i]) return false;
}
return true;
}
int main(){
assert (issame(func0(2, 10) , {2, 4, 6, 8}));
assert (issame(func0(10, 2) , {2, 4, 6,... | O3 | cpp | func0(int, int):
endbr64
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %esi,%edx
jge 179b <_Z5func0ii+0x2b>
mov %esi,%eax
mov %edx,%esi
mov %eax,%ebx
pxor %xmm0,%xmm0
mov %esi,0x4(%rsp)
lea 0... | _Z5func0ii:
endbr64
push r12
mov r12, rdi
push rbp
mov ebp, esi
push rbx
mov ebx, edx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
cmp edx, esi
jl short loc_17AB
mov ebx, esi
mov ebp, edx
loc_17AB:
pxor xmm0, xmm0
mov [rsp+28h+var_24], ... | long long func0(long long a1, int a2, int a3)
{
int v3; // ebp
int v4; // ebx
_DWORD *v5; // rsi
int v7; // [rsp+4h] [rbp-24h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-20h]
v3 = a2;
v4 = a3;
v8 = __readfsqword(0x28u);
if ( a3 >= a2 )
{
v4 = a2;
v3 = a3;
}
v7 = v4;
*(_QWORD *)(a1... | func0:
ENDBR64
PUSH R12
MOV R12,RDI
PUSH RBP
MOV EBP,ESI
PUSH RBX
MOV EBX,EDX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP EDX,ESI
JL 0x001017ab
MOV EBX,ESI
MOV EBP,EDX
LAB_001017ab:
PXOR XMM0,XMM0
MOV dword ptr [RSP + 0x4],EBX
MOV qword ptr [R12 + 0x10],0x0
MOVUPS xmmword ptr ... | /* func0(int, int) */
vector<int,std::allocator<int>> * func0(int param_1,int param_2)
{
uint *puVar1;
uint uVar2;
uint in_EDX;
uint uVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
uint local_24;
long local_20;
this = (vector<int,std::allocator<int>> ... |
656 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(float numbers[], int size, float threshold) {
int i, j;
for (i = 0; i < size; i++)
for (j = i + 1; j < size; j++)
if (fabs(numbers[i] - numbers[j]) < threshold)
return 1;
return 0;
} | #include <stdio.h>
#include <assert.h>
int main(){
float a[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert(func0(a, 6, 0.3) == 1);
assert(func0(a, 6, 0.05) == 0);
float b[] = {1.0, 2.0, 5.9, 4.0, 5.0};
assert(func0(b, 5, 0.95) == 1);
assert(func0(b, 5, 0.8) == 0);
float c[] = {1.0, 2.0, 3.... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movss %xmm0,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11f1 <func0+0x88>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11e5 <func0+0x7c>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
movss [rbp+var_20], xmm0
mov [rbp+var_8], 0
jmp short loc_11F1
loc_1186:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11E5
loc_1191:
mov eax, [rbp+var_8]
cdqe
lea rdx, ... | long long func0(long long a1, int a2, float a3)
{
int i; // [rsp+18h] [rbp-8h]
int j; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( a3 > fabs(*(float *)(4LL * i + a1) - *(float *)(4LL * j + a1)) )
return 1LL;
}
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOVSS dword ptr [RBP + -0x20],XMM0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011f1
LAB_00101186:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011e5
LAB_00101191:
MOV EAX,dword ptr [RBP... | int8 func0(float param_1,long param_2,int param_3)
{
int local_10;
int local_c;
local_10 = 0;
do {
local_c = local_10;
if (param_3 <= local_10) {
return 0;
}
while (local_c = local_c + 1, local_c < param_3) {
if ((float)(DAT_001020d0 &
(uint)(*(float *)(param_2 +... |
657 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(float numbers[], int size, float threshold) {
int i, j;
for (i = 0; i < size; i++)
for (j = i + 1; j < size; j++)
if (fabs(numbers[i] - numbers[j]) < threshold)
return 1;
return 0;
} | #include <stdio.h>
#include <assert.h>
int main(){
float a[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert(func0(a, 6, 0.3) == 1);
assert(func0(a, 6, 0.05) == 0);
float b[] = {1.0, 2.0, 5.9, 4.0, 5.0};
assert(func0(b, 5, 0.95) == 1);
assert(func0(b, 5, 0.8) == 0);
float c[] = {1.0, 2.0, 3.... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b1 <func0+0x48>
lea -0x1(%rsi),%ecx
add $0x1,%rcx
mov $0x1,%edx
movss 0xf6b(%rip),%xmm3
cmp %rcx,%rdx
je 11b7 <func0+0x4e>
movss -0x4(%rdi,%rdx,4),%xmm2
mov %rdx,%rax
movaps %xmm2,%xmm1
subss (%rdi,%rax,4),%xmm1
andps %xmm3,%xmm1
comiss %xmm1,%xmm0
ja ... | func0:
endbr64
test esi, esi
jle short loc_11BD
mov ecx, esi
movsxd r8, esi
mov edx, 1
movss xmm3, cs:dword_20E0
loc_1183:
cmp rdx, rcx
jz short loc_11C3
movss xmm2, dword ptr [rdi+rdx*4-4]
mov rax, rdx
loc_1191:
movaps xmm1, xmm2
subss xmm1, dword ptr [rdi+rax*4]
andps xmm1, xmm3
... | long long func0(long long a1, int a2, float a3)
{
long long v3; // rdx
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v3 = 1LL;
while ( 2 )
{
if ( v3 == a2 )
return 0LL;
v4 = v3;
do
{
if ( a3 > fabs(*(float *)(a1 + 4 * v3 - 4) - *(float *)(a1 + 4 * v4)) )
return 1L... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011bd
MOV ECX,ESI
MOVSXD R8,ESI
MOV EDX,0x1
MOVSS XMM3,dword ptr [0x001020e0]
LAB_00101183:
CMP RDX,RCX
JZ 0x001011c3
MOVSS XMM2,dword ptr [RDI + RDX*0x4 + -0x4]
MOV RAX,RDX
LAB_00101191:
MOVAPS XMM1,XMM2
SUBSS XMM1,dword ptr [RDI + RAX*0x4]
ANDPS XMM1,XMM3
COMISS XMM0,XMM1
JA 0x001... | int8 func0(float param_1,long param_2,uint param_3)
{
ulong uVar1;
ulong uVar2;
bool bVar3;
if ((int)param_3 < 1) {
return 0;
}
uVar2 = 1;
do {
if (uVar2 == param_3) {
return 0;
}
uVar1 = uVar2;
do {
if ((float)((uint)(*(float *)(param_2 + -4 + uVar2 * 4) - *(float *)(p... |
658 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(float numbers[], int size, float threshold) {
int i, j;
for (i = 0; i < size; i++)
for (j = i + 1; j < size; j++)
if (fabs(numbers[i] - numbers[j]) < threshold)
return 1;
return 0;
} | #include <stdio.h>
#include <assert.h>
int main(){
float a[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert(func0(a, 6, 0.3) == 1);
assert(func0(a, 6, 0.05) == 0);
float b[] = {1.0, 2.0, 5.9, 4.0, 5.0};
assert(func0(b, 5, 0.95) == 1);
assert(func0(b, 5, 0.8) == 0);
float c[] = {1.0, 2.0, 3.... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1519 <func0+0x59>
lea -0x1(%rsi),%ecx
mov $0x1,%edx
movss 0xc08(%rip),%xmm3
add $0x1,%rcx
cmp %rcx,%rdx
je 1519 <func0+0x59>
movss -0x4(%rdi,%rdx,4),%xmm2
mov %rdx,%rax
jmp 14f8 <func0+0x38>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 1510 <fu... | func0:
endbr64
test esi, esi
jle short loc_13F9
mov ecx, esi
mov edx, 1
movss xmm3, cs:dword_20E0
cmp rdx, rcx
jz short loc_13F9
loc_13BC:
movss xmm2, dword ptr [rdi+rdx*4-4]
mov rax, rdx
jmp short loc_13D8
loc_13D0:
add rax, 1
cmp esi, eax
jle short loc_13F0
loc_13D8:
mo... | long long func0(long long a1, int a2, float a3)
{
long long i; // rdx
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 1LL; i != a2; ++i )
{
v4 = i;
do
{
if ( a3 > fabs(*(float *)(a1 + 4 * i - 4) - *(float *)(a1 + 4 * v4)) )
return 1LL;
++v4;
}
whi... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013f9
MOV ECX,ESI
MOV EDX,0x1
MOVSS XMM3,dword ptr [0x001020e0]
CMP RDX,RCX
JZ 0x001013f9
LAB_001013bc:
MOVSS XMM2,dword ptr [RDI + RDX*0x4 + -0x4]
MOV RAX,RDX
JMP 0x001013d8
LAB_001013d0:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001013f0
LAB_001013d8:
MOVAPS XMM1,XMM2
SUBSS XMM1,dword ptr [RD... | int8 func0(float param_1,long param_2,uint param_3)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_3) {
uVar2 = 1;
if ((ulong)param_3 != 1) {
do {
uVar1 = uVar2;
do {
if ((float)((uint)(*(float *)(param_2 + -4 + uVar2 * 4) - *(float *)(param_2 + uVar1 * 4))
... |
659 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
| int func0(float numbers[], int size, float threshold) {
int i, j;
for (i = 0; i < size; i++)
for (j = i + 1; j < size; j++)
if (fabs(numbers[i] - numbers[j]) < threshold)
return 1;
return 0;
} | #include <stdio.h>
#include <assert.h>
int main(){
float a[] = {1.0, 2.0, 3.9, 4.0, 5.0, 2.2};
assert(func0(a, 6, 0.3) == 1);
assert(func0(a, 6, 0.05) == 0);
float b[] = {1.0, 2.0, 5.9, 4.0, 5.0};
assert(func0(b, 5, 0.95) == 1);
assert(func0(b, 5, 0.8) == 0);
float c[] = {1.0, 2.0, 3.... | O3 | c | func0:
endbr64
test %esi,%esi
jle 18a9 <func0+0x59>
lea -0x1(%rsi),%ecx
mov $0x1,%edx
movss 0x878(%rip),%xmm3
add $0x1,%rcx
cmp %rdx,%rcx
je 18a9 <func0+0x59>
movss -0x4(%rdi,%rdx,4),%xmm2
mov %rdx,%rax
jmp 1888 <func0+0x38>
nopl 0x0(%rax)
add $0x1,%rax
cmp %eax,%esi
jle 18a0 <fu... | func0:
endbr64
test esi, esi
jle short loc_1199
mov ecx, esi
mov edx, 1
movss xmm3, cs:dword_2010
cmp rcx, rdx
jz short loc_1199
loc_115C:
movss xmm2, dword ptr [rdi+rdx*4-4]
mov rax, rdx
jmp short loc_1178
loc_1170:
add rax, 1
cmp esi, eax
jle short loc_1190
loc_1178:
mo... | long long func0(long long a1, int a2, float a3)
{
long long i; // rdx
long long v4; // rax
if ( a2 > 0 )
{
for ( i = 1LL; a2 != i; ++i )
{
v4 = i;
do
{
if ( a3 > fabs(*(float *)(a1 + 4 * i - 4) - *(float *)(a1 + 4 * v4)) )
return 1LL;
++v4;
}
whi... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101199
MOV ECX,ESI
MOV EDX,0x1
MOVSS XMM3,dword ptr [0x00102010]
CMP RCX,RDX
JZ 0x00101199
LAB_0010115c:
MOVSS XMM2,dword ptr [RDI + RDX*0x4 + -0x4]
MOV RAX,RDX
JMP 0x00101178
LAB_00101170:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101190
LAB_00101178:
MOVAPS XMM1,XMM2
SUBSS XMM1,dword ptr [RD... | int8 func0(float param_1,long param_2,uint param_3)
{
ulong uVar1;
ulong uVar2;
if (0 < (int)param_3) {
uVar2 = 1;
if ((ulong)param_3 != 1) {
do {
uVar1 = uVar2;
do {
if ((float)((uint)(*(float *)(param_2 + -4 + uVar2 * 4) - *(float *)(param_2 + uVar1 * 4))
... |
660 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* paren_string, int* group_count) {
int length = strlen(paren_string);
int level = 0;
int capacity = 10;
char** groups = malloc(capacity * sizeof(char*));
char* buffer = malloc(length + 1);
int buffer_index = 0;
*group_count = 0;
for (int i = 0; i < length; ++i) {... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char** a, int a_size, const char* b[], int b_size) {
if (a_size != b_size) {
return 0;
}
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
retu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x24(%rbp)
movl $0x0,-0x34(%rbp)
movl $0xa,-0x30(%rbp)
mov -0x30(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+s], rdi
mov [rbp+var_50], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_24], eax
mov [rbp+var_34], 0
mov [rbp+var_30], 0Ah
mov eax, [rbp+var_30]
cdqe
shl rax, 3
mov rdi, rax; siz... | char * func0(const char *a1, int *a2)
{
int v2; // eax
int v3; // eax
char **v4; // rbx
char v6; // [rsp+1Bh] [rbp-35h]
int v7; // [rsp+1Ch] [rbp-34h]
int v8; // [rsp+20h] [rbp-30h]
int v9; // [rsp+24h] [rbp-2Ch]
int i; // [rsp+28h] [rbp-28h]
int v11; // [rsp+2Ch] [rbp-24h]
char *ptr; // [rsp+30h] [... | 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 [RBP + -0x48]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x34],0x0
MOV dword ptr [RBP + -0x30],0xa
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL R... | void * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *__s;
char *pcVar3;
int local_3c;
int local_38;
int local_34;
int local_30;
void *local_28;
sVar2 = strlen(param_1);
local_3c = 0;
local_38 = 10;
local_28 = malloc(0x50);
__s = (char *)malloc((long)((int)sVar2 + 1))... |
661 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* paren_string, int* group_count) {
int length = strlen(paren_string);
int level = 0;
int capacity = 10;
char** groups = malloc(capacity * sizeof(char*));
char* buffer = malloc(length + 1);
int buffer_index = 0;
*group_count = 0;
for (int i = 0; i < length; ++i) {... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char** a, int a_size, const char* b[], int b_size) {
if (a_size != b_size) {
return 0;
}
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
retu... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%r13
mov %rsi,%r14
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
mov $0x50,%edi
callq 1110 <malloc@plt>
mov %rax,%r15
lea 0x1(... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov r13, rdi
mov r14, rsi
call _strlen
mov rbp, rax
mov edi, 50h ; 'P'; size
call _malloc
mov r15, rax
lea edi, [rbp+1]
movsxd rdi, edi; size
call _malloc
mov r12, rax
mov dw... | char * func0(const char *a1, int *a2)
{
int v2; // ebp
char *v3; // r15
char *v4; // r12
const char *v5; // rbx
long long v6; // r13
int v7; // edx
int v8; // ebp
int v9; // eax
int v10; // eax
int v12; // [rsp+4h] [rbp-44h]
char **v13; // [rsp+8h] [rbp-40h]
v2 = strlen(a1);
v3 = (char *)mall... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV R13,RDI
MOV R14,RSI
CALL 0x001010f0
MOV RBP,RAX
MOV EDI,0x50
CALL 0x00101130
MOV R15,RAX
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
CALL 0x00101130
MOV R12,RAX
MOV dword ptr [R14],0x0
TEST EBP,EBP
JLE 0x0010133a
MOV RBX,R13
LEA EAX,[RBP + -0x... | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
size_t sVar2;
void *__ptr;
char *__s;
char *pcVar3;
int iVar4;
int iVar5;
int iVar6;
int local_44;
sVar2 = strlen(param_1);
__ptr = malloc(0x50);
iVar5 = (int)sVar2;
__s = (char *)malloc((long)(iVar5 + 1));
*param_2 = 0;
if (0 < ... |
662 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* paren_string, int* group_count) {
int length = strlen(paren_string);
int level = 0;
int capacity = 10;
char** groups = malloc(capacity * sizeof(char*));
char* buffer = malloc(length + 1);
int buffer_index = 0;
*group_count = 0;
for (int i = 0; i < length; ++i) {... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char** a, int a_size, const char* b[], int b_size) {
if (a_size != b_size) {
return 0;
}
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
retu... | O2 | c | func0:
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
callq 10f0 <strlen@plt>
mov $0x50,%edi
mov %rax,%rbp
callq 1130 <malloc@plt>
lea 0x1(%rbp),%edi
movslq %edi,%rdi
mov %rax,%r12
callq 1130 <malloc@plt>
movl $0x0,(%r... | func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
call _strlen
mov edi, 50h ; 'P'; size
mov rbp, rax
call _malloc
lea edi, [rbp+1]
movsxd rdi, edi; size
mov [rsp+48h+ptr], rax
call _malloc
mov dword ptr... | char * func0(const char *a1, int *a2)
{
const char *v2; // rbx
int v3; // ebp
char *v4; // rax
char *v5; // r15
long long v6; // rax
int v7; // ecx
int v8; // ebp
int v9; // r12d
long long v10; // r13
long long v11; // rax
long long v13; // rax
long long v14; // rax
char **v15; // rbp
char *... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010f0
MOV EDI,0x50
MOV RBP,RAX
CALL 0x00101130
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
MOV qword ptr [RSP],RAX
CALL 0x00101130
MOV dword ptr [R14],0x0
MOV R15,RAX
TEST EBP,EBP
JLE 0x001015dc
LEA EAX,[RBP + -0x... | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__s;
long lVar4;
char *pcVar5;
int iVar6;
int iVar7;
int iVar8;
void *local_48;
sVar3 = strlen(param_1);
local_48 = malloc(0x50);
iVar2 = (int)sVar3;
__s = (char *)malloc((long)(iVar2 + 1));
*param_... |
663 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char** func0(const char* paren_string, int* group_count) {
int length = strlen(paren_string);
int level = 0;
int capacity = 10;
char** groups = malloc(capacity * sizeof(char*));
char* buffer = malloc(length + 1);
int buffer_index = 0;
*group_count = 0;
for (int i = 0; i < length; ++i) {... | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
int issame(char** a, int a_size, const char* b[], int b_size) {
if (a_size != b_size) {
return 0;
}
for (int i = 0; i < a_size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
retu... | O3 | c | func0:
endbr64
push %r15
mov %rsi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x18,%rsp
callq 10f0 <strlen@plt>
mov $0x50,%edi
mov %rax,%rbp
callq 1130 <malloc@plt>
lea 0x1(%rbp),%edi
movslq %edi,%rdi
mov %rax,%r12
callq 1130 <malloc@plt>
movl $0x0,(%r... | func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 18h
call _strlen
mov edi, 50h ; 'P'; size
mov rbp, rax
call _malloc
lea edi, [rbp+1]
movsxd rdi, edi; size
mov [rsp+48h+ptr], rax
call _malloc
mov dword ptr... | char * func0(const char *a1, int *a2)
{
const char *v2; // rbx
int v3; // ebp
char *v4; // rax
char *v5; // r15
long long v6; // rax
int v7; // ecx
int v8; // ebp
int v9; // r12d
long long v10; // r13
long long v11; // rax
long long v13; // rax
long long v14; // rax
char **v15; // rbp
char *... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x18
CALL 0x001010f0
MOV EDI,0x50
MOV RBP,RAX
CALL 0x00101130
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
MOV qword ptr [RSP],RAX
CALL 0x00101130
MOV dword ptr [R14],0x0
MOV R15,RAX
TEST EBP,EBP
JLE 0x001015dc
LEA EAX,[RBP + -0x... | void * func0(char *param_1,int *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *__s;
long lVar4;
char *pcVar5;
int iVar6;
int iVar7;
int iVar8;
void *local_48;
sVar3 = strlen(param_1);
local_48 = malloc(0x50);
iVar2 = (int)sVar3;
__s = (char *)malloc((long)(iVar2 + 1));
*param_... |
664 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float number) {
return number - (int)number;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(func0(3.5f) == 0.5f);
assert(fabs(func0(1.33f) - 0.33f) < 1e-4);
assert(fabs(func0(123.456f) - 0.456f) < 1e-4);
return 0;
} | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movss %xmm0,-0x4(%rbp)
movss -0x4(%rbp),%xmm0
cvttss2si %xmm0,%eax
cvtsi2ss %eax,%xmm1
movss -0x4(%rbp),%xmm0
subss %xmm1,%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movss [rbp+var_4], xmm0
movss xmm0, [rbp+var_4]
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
movss xmm0, [rbp+var_4]
subss xmm0, xmm1
pop rbp
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSS dword ptr [RBP + -0x4],XMM0
MOVSS XMM0,dword ptr [RBP + -0x4]
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
MOVSS XMM0,dword ptr [RBP + -0x4]
SUBSS XMM0,XMM1
POP RBP
RET | float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
665 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float number) {
return number - (int)number;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(func0(3.5f) == 0.5f);
assert(fabs(func0(1.33f) - 0.33f) < 1e-4);
assert(fabs(func0(123.456f) - 0.456f) < 1e-4);
return 0;
} | O1 | c | func0:
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
| func0:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
666 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float number) {
return number - (int)number;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(func0(3.5f) == 0.5f);
assert(fabs(func0(1.33f) - 0.33f) < 1e-4);
assert(fabs(func0(123.456f) - 0.456f) < 1e-4);
return 0;
} | O2 | c | func0:
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
667 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float number) {
return number - (int)number;
} | #include <stdio.h>
#include <assert.h>
#include <math.h>
int main() {
assert(func0(3.5f) == 0.5f);
assert(fabs(func0(1.33f) - 0.33f) < 1e-4);
assert(fabs(func0(123.456f) - 0.456f) < 1e-4);
return 0;
} | O3 | c | func0:
endbr64
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
subss %xmm1,%xmm0
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
cvttss2si eax, xmm0
pxor xmm1, xmm1
cvtsi2ss xmm1, eax
subss xmm0, xmm1
retn | float func0(float a1)
{
return a1 - (float)(int)a1;
} | func0:
ENDBR64
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
CVTSI2SS XMM1,EAX
SUBSS XMM0,XMM1
RET | float func0(float param_1)
{
return param_1 - (float)(int)param_1;
} |
668 | func0 | #include <stdio.h>
| int func0(int operations[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
num += operations[i];
if (num < 0) return 1;
}
return 0;
} | #include <assert.h>
int main() {
int case1[] = {};
assert(func0(case1, 0) == 0);
int case2[] = {1, 2, -3, 1, 2, -3};
assert(func0(case2, 6) == 0);
int case3[] = {1, 2, -4, 5, 6};
assert(func0(case3, 5) == 1);
int case4[] = {1, -1, 2, -2, 5, -5, 4, -4};
assert(func0(case4, 8) == 0);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b2 <func0+0x49>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11B2
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
cmp... | long long func0(long long a1, int a2)
{
int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
v3 += *(_DWORD *)(4LL * i + a1);
if ( v3 < 0 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b2
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dwo... | int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 0;
}
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
if (local_10 < 0) break;
local_c = local_c + 1;
}
return 1;
} |
669 | func0 | #include <stdio.h>
| int func0(int operations[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
num += operations[i];
if (num < 0) return 1;
}
return 0;
} | #include <assert.h>
int main() {
int case1[] = {};
assert(func0(case1, 0) == 0);
int case2[] = {1, 2, -3, 1, 2, -3};
assert(func0(case2, 6) == 0);
int case3[] = {1, 2, -4, 5, 6};
assert(func0(case3, 5) == 1);
int case4[] = {1, -1, 2, -2, 5, -5, 4, -4};
assert(func0(case4, 8) == 0);
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11a1 <func0+0x38>
mov (%rdi),%edx
test %edx,%edx
js 11a7 <func0+0x3e>
add $0x4,%rdi
lea -0x1(%rsi),%eax
lea (%rdi,%rax,4),%rcx
cmp %rcx,%rdi
je 119b <func0+0x32>
mov %edx,%eax
add (%rdi),%eax
mov %eax,%edx
add $0x4,%rdi
test %eax,%eax
jns ... | func0:
endbr64
test esi, esi
jle short loc_11A1
mov edx, [rdi]
test edx, edx
js short loc_11A7
add rdi, 4
lea eax, [rsi-1]
lea rcx, [rdi+rax*4]
loc_1182:
cmp rdi, rcx
jz short loc_119B
mov eax, edx
add eax, [rdi]
mov edx, eax
add rdi, 4
test eax, eax
jns sh... | long long func0(int *a1, int a2)
{
int v2; // edx
_DWORD *v3; // rdi
_DWORD *v4; // rcx
if ( a2 <= 0 )
return 0LL;
v2 = *a1;
if ( *a1 < 0 )
return 1LL;
v3 = a1 + 1;
v4 = &v3[a2 - 1];
while ( v3 != v4 )
{
v2 += *v3++;
if ( v2 < 0 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a1
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
JS 0x001011a7
ADD RDI,0x4
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4]
LAB_00101182:
CMP RDI,RCX
JZ 0x0010119b
MOV EAX,EDX
ADD EAX,dword ptr [RDI]
MOV EDX,EAX
ADD RDI,0x4
TEST EAX,EAX
JNS 0x00101182
MOV EAX,0x1
RET
LAB_0010119b:
MOV EAX,0x0... | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
return 0;
}
iVar2 = *param_1;
if (-1 < iVar2) {
param_1 = param_1 + 1;
piVar1 = param_1 + (param_2 - 1);
do {
if (param_1 == piVar1) {
return 0;
}
iVar2 = iVar2 + *param_1;
p... |
670 | func0 | #include <stdio.h>
| int func0(int operations[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
num += operations[i];
if (num < 0) return 1;
}
return 0;
} | #include <assert.h>
int main() {
int case1[] = {};
assert(func0(case1, 0) == 0);
int case2[] = {1, 2, -3, 1, 2, -3};
assert(func0(case2, 6) == 0);
int case3[] = {1, 2, -4, 5, 6};
assert(func0(case3, 5) == 1);
int case4[] = {1, -1, 2, -2, 5, -5, 4, -4};
assert(func0(case4, 8) == 0);
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 137f <func0+0x2f>
mov (%rdi),%eax
test %eax,%eax
js 1388 <func0+0x38>
add $0x4,%rdi
lea -0x1(%rsi),%edx
lea (%rdi,%rdx,4),%rdx
jmp 137a <func0+0x2a>
nopl 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
test %eax,%eax
js 1388 <func0+0x38>
cmp %r... | func0:
endbr64
test esi, esi
jle short loc_135F
mov eax, [rdi]
test eax, eax
js short loc_1368
add rdi, 4
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4]
jmp short loc_135A
loc_1350:
add eax, [rdi]
add rdi, 4
test eax, eax
js short loc_1368
loc_135A:
cmp rdi, rdx
jnz sho... | long long func0(int *a1, int a2)
{
int v2; // eax
_DWORD *v3; // rdi
_DWORD *v4; // rdx
if ( a2 <= 0 )
return 0LL;
v2 = *a1;
if ( *a1 >= 0 )
{
v3 = a1 + 1;
v4 = &v3[a2 - 1];
while ( v3 != v4 )
{
v2 += *v3++;
if ( v2 < 0 )
return 1LL;
}
return 0LL;
}
re... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010135f
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JS 0x00101368
ADD RDI,0x4
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4]
JMP 0x0010135a
LAB_00101350:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
TEST EAX,EAX
JS 0x00101368
LAB_0010135a:
CMP RDI,RDX
JNZ 0x00101350
LAB_0010135f:
XOR EAX,EAX
RET
LAB_00... | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
return 0;
}
iVar2 = *param_1;
if (-1 < iVar2) {
param_1 = param_1 + 1;
piVar1 = param_1 + (param_2 - 1);
do {
if (param_1 == piVar1) {
return 0;
}
iVar2 = iVar2 + *param_1;
p... |
671 | func0 | #include <stdio.h>
| int func0(int operations[], int size) {
int num = 0;
for (int i = 0; i < size; i++) {
num += operations[i];
if (num < 0) return 1;
}
return 0;
} | #include <assert.h>
int main() {
int case1[] = {};
assert(func0(case1, 0) == 0);
int case2[] = {1, 2, -3, 1, 2, -3};
assert(func0(case2, 6) == 0);
int case3[] = {1, 2, -4, 5, 6};
assert(func0(case3, 5) == 1);
int case4[] = {1, -1, 2, -2, 5, -5, 4, -4};
assert(func0(case4, 8) == 0);
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 135f <func0+0x2f>
mov (%rdi),%eax
test %eax,%eax
js 1368 <func0+0x38>
add $0x4,%rdi
lea -0x1(%rsi),%edx
lea (%rdi,%rdx,4),%rdx
jmp 135a <func0+0x2a>
nopl 0x0(%rax,%rax,1)
add (%rdi),%eax
add $0x4,%rdi
test %eax,%eax
js 1368 <func0+0x38>
cmp %r... | func0:
endbr64
test esi, esi
jle short loc_116F
mov eax, [rdi]
test eax, eax
js short loc_1178
add rdi, 4
lea edx, [rsi-1]
lea rdx, [rdi+rdx*4]
jmp short loc_116A
loc_1160:
add eax, [rdi]
add rdi, 4
test eax, eax
js short loc_1178
loc_116A:
cmp rdi, rdx
jnz sho... | long long func0(int *a1, int a2)
{
int v2; // eax
_DWORD *v3; // rdi
_DWORD *v4; // rdx
if ( a2 <= 0 )
return 0LL;
v2 = *a1;
if ( *a1 >= 0 )
{
v3 = a1 + 1;
v4 = &v3[a2 - 1];
while ( v3 != v4 )
{
v2 += *v3++;
if ( v2 < 0 )
return 1LL;
}
return 0LL;
}
re... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010116f
MOV EAX,dword ptr [RDI]
TEST EAX,EAX
JS 0x00101178
ADD RDI,0x4
LEA EDX,[RSI + -0x1]
LEA RDX,[RDI + RDX*0x4]
JMP 0x0010116a
LAB_00101160:
ADD EAX,dword ptr [RDI]
ADD RDI,0x4
TEST EAX,EAX
JS 0x00101178
LAB_0010116a:
CMP RDI,RDX
JNZ 0x00101160
LAB_0010116f:
XOR EAX,EAX
RET
LAB_00... | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
return 0;
}
iVar2 = *param_1;
if (-1 < iVar2) {
param_1 = param_1 + 1;
piVar1 = param_1 + (param_2 - 1);
do {
if (param_1 == piVar1) {
return 0;
}
iVar2 = iVar2 + *param_1;
p... |
672 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float numbers[], int size) {
float sum = 0;
float avg, msum, mavg;
int i = 0;
for (i = 0; i < size; i++)
sum += numbers[i];
avg = sum / size;
msum = 0;
for (i = 0; i < size; i++)
msum += fabs(numbers[i] - avg);
return msum / size;
} | #include <assert.h>
#include <math.h>
int main() {
float case1[] = {1.0, 2.0, 3.0};
assert(fabs(func0(case1, 3) - 2.0/3.0) < 1e-4);
float case2[] = {1.0, 2.0, 3.0, 4.0};
assert(fabs(func0(case2, 4) - 1.0) < 1e-4);
float case3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
assert(fabs(func0(case3, 5) - 6.0/5.... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
pxor %xmm0,%xmm0
movss %xmm0,-0x10(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11bb <func0+0x52>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
pxor xmm0, xmm0
movss [rbp+var_10], xmm0
mov [rbp+var_8], 0
mov [rbp+var_8], 0
jmp short loc_11BB
loc_1191:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
m... | float func0(long long a1, int a2)
{
float v3; // [rsp+Ch] [rbp-10h]
float v4; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+14h] [rbp-8h]
v3 = 0.0;
for ( i = 0; i < a2; ++i )
v3 = *(float *)(4LL * i + a1) + v3;
v4 = 0.0;
for ( j = 0; j < a2; ++j )
v4 = fabs(*(float *)(4LL *... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
PXOR XMM0,XMM0
MOVSS dword ptr [RBP + -0x10],XMM0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011bb
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + ... | float func0(long param_1,int param_2)
{
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0.0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
local_18 = *(float *)(param_1 + (long)local_10 * 4) + local_18;
}
local_14 = 0.0;
for (local_10 = 0; local_10 < param_2; local_10... |
673 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float numbers[], int size) {
float sum = 0;
float avg, msum, mavg;
int i = 0;
for (i = 0; i < size; i++)
sum += numbers[i];
avg = sum / size;
msum = 0;
for (i = 0; i < size; i++)
msum += fabs(numbers[i] - avg);
return msum / size;
} | #include <assert.h>
#include <math.h>
int main() {
float case1[] = {1.0, 2.0, 3.0};
assert(fabs(func0(case1, 3) - 2.0/3.0) < 1e-4);
float case2[] = {1.0, 2.0, 3.0, 4.0};
assert(fabs(func0(case2, 4) - 1.0) < 1e-4);
float case3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
assert(fabs(func0(case3, 5) - 6.0/5.... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11c5 <func0+0x5c>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rdx
pxor %xmm0,%xmm0
addss (%rdi),%xmm0
add $0x4,%rdi
cmp %rdx,%rdi
jne 1180 <func0+0x17>
pxor %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
divss %xmm4,%xmm0
pxor %xmm2,%xmm2
movss 0xf2b(%rip),... | func0:
endbr64
test esi, esi
jle short loc_11C4
mov rax, rdi
movsxd rdx, esi
lea rdx, [rdi+rdx*4]
pxor xmm0, xmm0
loc_117F:
addss xmm0, dword ptr [rdi]
add rdi, 4
cmp rdi, rdx
jnz short loc_117F
pxor xmm4, xmm4
cvtsi2ss xmm4, esi
divss xmm0, xmm4
pxor xmm2, xmm2
movss xmm3, cs... | __int128 __usercall func0@<xmm0>(float *a1@<rdi>, int a2@<esi>)
{
float *v2; // rax
float *v3; // rdx
float v4; // xmm0_4
float v5; // xmm4_4
float v6; // xmm0_4
__int128 v7; // xmm2
if ( a2 <= 0 )
{
v5 = (float)a2;
v7 = 0LL;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0.0;
do
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011c4
MOV RAX,RDI
MOVSXD RDX,ESI
LEA RDX,[RDI + RDX*0x4]
PXOR XMM0,XMM0
LAB_0010117f:
ADDSS XMM0,dword ptr [RDI]
ADD RDI,0x4
CMP RDI,RDX
JNZ 0x0010117f
PXOR XMM4,XMM4
CVTSI2SS XMM4,ESI
DIVSS XMM0,XMM4
PXOR XMM2,XMM2
MOVSS XMM3,dword ptr [0x001020b0]
LAB_001011a4:
MOVSS XMM1,dword pt... | void func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
if (0 < param_2) {
lVar1 = param_1 + (long)param_2 * 4;
lVar2 = param_1;
do {
lVar2 = lVar2 + 4;
} while (lVar2 != lVar1);
do {
param_1 = param_1 + 4;
} while (param_1 != lVar1);
}
return;
} |
674 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float numbers[], int size) {
float sum = 0;
float avg, msum, mavg;
int i = 0;
for (i = 0; i < size; i++)
sum += numbers[i];
avg = sum / size;
msum = 0;
for (i = 0; i < size; i++)
msum += fabs(numbers[i] - avg);
return msum / size;
} | #include <assert.h>
#include <math.h>
int main() {
float case1[] = {1.0, 2.0, 3.0};
assert(fabs(func0(case1, 3) - 2.0/3.0) < 1e-4);
float case2[] = {1.0, 2.0, 3.0, 4.0};
assert(fabs(func0(case2, 4) - 1.0) < 1e-4);
float case3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
assert(fabs(func0(case3, 5) - 6.0/5.... | O2 | c | func0:
endbr64
pxor %xmm4,%xmm4
cvtsi2ss %esi,%xmm4
test %esi,%esi
jle 12c0 <func0+0x60>
lea -0x1(%rsi),%eax
pxor %xmm0,%xmm0
lea 0x4(%rdi,%rax,4),%rdx
mov %rdi,%rax
addss (%rax),%xmm0
add $0x4,%rax
cmp %rax,%rdx
jne 1280 <func0+0x20>
divss %xmm4,%xmm0
pxor %xmm2,%xmm2
movss 0xde3(%rip),... | func0:
endbr64
pxor xmm4, xmm4
cvtsi2ss xmm4, esi
test esi, esi
jle short loc_1330
movsxd rsi, esi
mov rax, rdi
pxor xmm0, xmm0
lea rdx, [rdi+rsi*4]
and esi, 1
jz short loc_12E0
lea rax, [rdi+4]
addss xmm0, dword ptr [rdi]
cmp rdx, rax
jz short loc_12F2
loc_12E0:
addss xm... | __int128 __usercall func0@<xmm0>(float *a1@<rdi>, int a2@<esi>)
{
float v2; // xmm4_4
float *v3; // rax
float v4; // xmm0_4
float *v5; // rdx
float v6; // xmm0_4
float v7; // xmm0_4
__int128 v8; // xmm2
float v9; // xmm1_4
__int128 v11; // xmm2
v2 = (float)a2;
if ( a2 <= 0 )
{
v11 = 0LL;
... | func0:
ENDBR64
PXOR XMM4,XMM4
CVTSI2SS XMM4,ESI
TEST ESI,ESI
JLE 0x00101330
MOVSXD RSI,ESI
MOV RAX,RDI
PXOR XMM0,XMM0
LEA RDX,[RDI + RSI*0x4]
AND ESI,0x1
JZ 0x001012e0
LEA RAX,[RDI + 0x4]
ADDSS XMM0,dword ptr [RDI]
CMP RDX,RAX
JZ 0x001012f2
LAB_001012e0:
ADDSS XMM0,dword ptr [RAX]
ADD RAX,0x8
ADDSS XMM0,dword ptr [RAX ... | void func0(long param_1,uint param_2)
{
long lVar1;
long lVar2;
if (0 < (int)param_2) {
lVar1 = param_1 + (long)(int)param_2 * 4;
lVar2 = param_1;
if ((param_2 & 1) == 0) goto LAB_001012e0;
for (lVar2 = param_1 + 4; lVar1 != lVar2; lVar2 = lVar2 + 8) {
LAB_001012e0:
}
do {
param_... |
675 | func0 | #include <stdio.h>
#include <math.h>
| float func0(float numbers[], int size) {
float sum = 0;
float avg, msum, mavg;
int i = 0;
for (i = 0; i < size; i++)
sum += numbers[i];
avg = sum / size;
msum = 0;
for (i = 0; i < size; i++)
msum += fabs(numbers[i] - avg);
return msum / size;
} | #include <assert.h>
#include <math.h>
int main() {
float case1[] = {1.0, 2.0, 3.0};
assert(fabs(func0(case1, 3) - 2.0/3.0) < 1e-4);
float case2[] = {1.0, 2.0, 3.0, 4.0};
assert(fabs(func0(case2, 4) - 1.0) < 1e-4);
float case3[] = {1.0, 2.0, 3.0, 4.0, 5.0};
assert(fabs(func0(case3, 5) - 6.0/5.... | O3 | c | func0:
endbr64
pxor %xmm5,%xmm5
cvtsi2ss %esi,%xmm5
test %esi,%esi
jle 1318 <func0+0x178>
lea -0x1(%rsi),%ecx
cmp $0x2,%ecx
jbe 1325 <func0+0x185>
mov %esi,%edx
pxor %xmm0,%xmm0
mov %rdi,%rax
shr $0x2,%edx
movaps %xmm0,%xmm3
shl $0x4,%rdx
add %rdi,%rdx
nopw %cs:0x0(%rax,%rax,1)
movups... | func0:
endbr64
pxor xmm4, xmm4
mov edx, esi
cvtsi2ss xmm4, esi
test esi, esi
jle loc_12B0
lea esi, [rsi-1]
cmp esi, 2
jbe loc_12C1
mov ecx, edx
mov rax, rdi
pxor xmm0, xmm0
shr ecx, 2
shl rcx, 4
add rcx, rdi
nop dword ptr [rax]
loc_1178:
addss xmm0, dword ptr [rax]... | float func0(float *a1, int a2)
{
float v3; // xmm4_4
unsigned int v4; // esi
float *v5; // rax
__m128 v6; // xmm0
float v7; // xmm0_4
signed int v8; // eax
long long v9; // r8
__m128 v10; // xmm2
__m128 *v11; // rax
float v12; // xmm0_4
__m128 v13; // xmm6
__m128 v14; // xmm5
__m128 v15; // x... | func0:
ENDBR64
PXOR XMM4,XMM4
MOV EDX,ESI
CVTSI2SS XMM4,ESI
TEST ESI,ESI
JLE 0x001012b0
LEA ESI,[RSI + -0x1]
CMP ESI,0x2
JBE 0x001012c1
MOV ECX,EDX
MOV RAX,RDI
PXOR XMM0,XMM0
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101178:
ADDSS XMM0,dword ptr [RAX]
ADD RAX,0x10
ADDSS XMM0,dword ptr [RAX + -0xc]
A... | int8 func0(float *param_1,uint param_2)
{
float fVar1;
float *pfVar2;
float *pfVar3;
uint uVar4;
float *pfVar5;
float *pfVar6;
float fVar7;
float fVar8;
int auVar9 [16];
int auVar12 [12];
int auVar10 [16];
int auVar11 [16];
float fVar13;
float fVar14;
float fVar15;
fVar15 = (float)(i... |
676 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(const int numbers[], int size, int delimiter, int *out_size) {
*out_size = size > 0 ? (size * 2) - 1 : 0;
int *out = (int *)malloc(*out_size * sizeof(int));
if (size > 0) out[0] = numbers[0];
for (int i = 1, j = 1; i < size; ++i) {
out[j++] = delimiter;
out[j++] = numbers[i];
... | #include <assert.h>
#include <string.h>
int issame(const int a[], const int b[], int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int out_size;
// Test with an empty array
int *resul... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
cmpl $0x0,-0x1c(%rbp)
jle 11d3 <func0+0x2a>
mov -0x1c(%rbp),%eax
add %eax,%eax
lea -0x1(%rax),%edx
jmp 11d8 <func0+0x2f>
mov $0x0,%edx
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
cmp [rbp+var_1C], 0
jle short loc_11D3
mov eax, [rbp+var_1C]
add eax, eax
lea edx, [rax-1]
jmp short loc_11D8
loc_11D3:
mov edx... | _DWORD * func0(_DWORD *a1, int a2, int a3, int *a4)
{
int v4; // edx
int v5; // eax
int v8; // [rsp+20h] [rbp-10h]
int v9; // [rsp+24h] [rbp-Ch]
_DWORD *v10; // [rsp+28h] [rbp-8h]
if ( a2 <= 0 )
v4 = 0;
else
v4 = 2 * a2 - 1;
*a4 = v4;
v10 = malloc(4LL * *a4);
if ( a2 > 0 )
*v10 = *a1;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x001011d3
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,EAX
LEA EDX,[RAX + -0x1]
JMP 0x001011d8
LAB_001011d3:
MO... | int4 * func0(int4 *param_1,int param_2,int4 param_3,int *param_4)
{
int4 *puVar1;
int iVar2;
int local_18;
int local_14;
if (param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = param_2 * 2 + -1;
}
*param_4 = iVar2;
puVar1 = (int4 *)malloc((long)*param_4 << 2);
if (0 < param_2) {
*puVar1 = *... |
677 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(const int numbers[], int size, int delimiter, int *out_size) {
*out_size = size > 0 ? (size * 2) - 1 : 0;
int *out = (int *)malloc(*out_size * sizeof(int));
if (size > 0) out[0] = numbers[0];
for (int i = 1, j = 1; i < size; ++i) {
out[j++] = delimiter;
out[j++] = numbers[i];
... | #include <assert.h>
#include <string.h>
int issame(const int a[], const int b[], int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int out_size;
// Test with an empty array
int *resul... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
test %esi,%esi
jle 11ff <func0+0x56>
mov %rdi,%rbx
mov %esi,%r12d
mov %edx,%ebp
lea -0x1(%rsi,%rsi,1),%edi
mov %edi,(%rcx)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%edx
mov %edx,(%rax)
cmp $0x1,%r12d
jle 11fa... | func0:
endbr64
push r12
push rbp
push rbx
test esi, esi
jle short loc_11F9
mov rbx, rdi
mov r12d, esi
mov ebp, edx
lea edi, [rsi+rsi-1]
mov [rcx], edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov edx, [rbx]
mov [rax], edx
cmp r12d, 1
jle short loc_11F4
mo... | _DWORD * func0(_DWORD *a1, int a2, int a3, int *a4)
{
int v6; // edi
_DWORD *result; // rax
long long i; // rdx
if ( a2 <= 0 )
{
*a4 = 0;
return malloc(0LL);
}
else
{
v6 = 2 * a2 - 1;
*a4 = v6;
result = malloc(4LL * v6);
*result = *a1;
if ( a2 > 1 )
{
for ( i = 1LL... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
TEST ESI,ESI
JLE 0x001011f9
MOV RBX,RDI
MOV R12D,ESI
MOV EBP,EDX
LEA EDI,[RSI + RSI*0x1 + -0x1]
MOV dword ptr [RCX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV EDX,dword ptr [RBX]
MOV dword ptr [RAX],EDX
CMP R12D,0x1
JLE 0x001011f4
MOV ESI,R12D
MOV EDX,0x1
LAB_001011e1:
... | void func0(int4 *param_1,uint param_2,int4 param_3,int *param_4)
{
int iVar1;
int4 *puVar2;
ulong uVar3;
if ((int)param_2 < 1) {
*param_4 = 0;
malloc(0);
}
else {
iVar1 = param_2 * 2 + -1;
*param_4 = iVar1;
puVar2 = (int4 *)malloc((long)iVar1 << 2);
*puVar2 = *param_1;
if (1 ... |
678 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(const int numbers[], int size, int delimiter, int *out_size) {
*out_size = size > 0 ? (size * 2) - 1 : 0;
int *out = (int *)malloc(*out_size * sizeof(int));
if (size > 0) out[0] = numbers[0];
for (int i = 1, j = 1; i < size; ++i) {
out[j++] = delimiter;
out[j++] = numbers[i];
... | #include <assert.h>
#include <string.h>
int issame(const int a[], const int b[], int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int out_size;
// Test with an empty array
int *resul... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1420 <func0+0x60>
push %r12
mov %esi,%r12d
push %rbp
mov %edx,%ebp
push %rbx
mov %rdi,%rbx
lea -0x1(%rsi,%rsi,1),%edi
mov %edi,(%rcx)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%edx
mov %edx,(%rax)
cmp $0x1,%r12d
je 1413... | func0:
endbr64
push rbp
push rbx
sub rsp, 18h
mov [rsp+28h+var_1C], edx
test esi, esi
jle short loc_13F8
mov rbx, rdi
lea edi, [rsi+rsi-1]
mov ebp, esi
mov [rcx], edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov edx, [rbx]
cmp ebp, 1
movd xmm1, [rsp+28h+var_1... | _DWORD * func0(_DWORD *a1, int a2, unsigned int a3, int *a4)
{
int v5; // edi
_DWORD *result; // rax
__m128i v7; // xmm1
long long v8; // rcx
if ( a2 <= 0 )
{
*a4 = 0;
return malloc(0LL);
}
else
{
v5 = 2 * a2 - 1;
*a4 = v5;
result = malloc(4LL * v5);
v7 = _mm_cvtsi32_si128(a3)... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDX
TEST ESI,ESI
JLE 0x001013f8
MOV RBX,RDI
LEA EDI,[RSI + RSI*0x1 + -0x1]
MOV EBP,ESI
MOV dword ptr [RCX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV EDX,dword ptr [RBX]
CMP EBP,0x1
MOVD XMM1,dword ptr [RSP + 0xc]
MOV ECX,0x1
MOV dword ptr ... | void func0(int4 *param_1,uint param_2,int4 param_3,int *param_4)
{
int iVar1;
int4 *puVar2;
ulong uVar3;
if (0 < (int)param_2) {
iVar1 = param_2 * 2 + -1;
*param_4 = iVar1;
puVar2 = (int4 *)malloc((long)iVar1 << 2);
uVar3 = 1;
*puVar2 = *param_1;
if (param_2 != 1) {
do {
... |
679 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(const int numbers[], int size, int delimiter, int *out_size) {
*out_size = size > 0 ? (size * 2) - 1 : 0;
int *out = (int *)malloc(*out_size * sizeof(int));
if (size > 0) out[0] = numbers[0];
for (int i = 1, j = 1; i < size; ++i) {
out[j++] = delimiter;
out[j++] = numbers[i];
... | #include <assert.h>
#include <string.h>
int issame(const int a[], const int b[], int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int out_size;
// Test with an empty array
int *resul... | O3 | c | func0:
endbr64
test %esi,%esi
jle 14a0 <func0+0xf0>
push %r12
mov %edx,%r12d
push %rbp
mov %esi,%ebp
push %rbx
mov %rdi,%rbx
lea -0x1(%rsi,%rsi,1),%edi
mov %edi,(%rcx)
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
mov (%rbx),%edx
mov %edx,(%rax)
cmp $0x1,%ebp
je 1492 ... | func0:
endbr64
push rbp
push rbx
sub rsp, 18h
mov [rsp+28h+var_1C], edx
test esi, esi
jle loc_14A0
mov rbx, rdi
lea edi, [rsi+rsi-1]
mov ebp, esi
mov [rcx], edi
movsxd rdi, edi
shl rdi, 2; size
call _malloc
cmp ebp, 1
movd xmm2, [rsp+28h+var_1C]
mov rcx, rax
mov ... | _DWORD * func0(_DWORD *a1, int a2, unsigned int a3, int *a4)
{
int v5; // edi
__m128i v6; // xmm2
_DWORD *v7; // rcx
unsigned int v8; // edx
__m128i v9; // xmm0
unsigned long long v10; // rax
__m128i v11; // xmm3
unsigned int v12; // edx
int v13; // eax
int v14; // edx
long long v15; // rdi
long... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RSP + 0xc],EDX
TEST ESI,ESI
JLE 0x001014a0
MOV RBX,RDI
LEA EDI,[RSI + RSI*0x1 + -0x1]
MOV EBP,ESI
MOV dword ptr [RCX],EDI
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
CMP EBP,0x1
MOVD XMM2,dword ptr [RSP + 0xc]
MOV RCX,RAX
MOV EAX,dword ptr [RBX]
MOV dword ptr ... | int4 * func0(int4 *param_1,int param_2,int4 param_3,int *param_4)
{
int4 *puVar1;
int8 *puVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int iVar6;
int4 *puVar7;
long lVar8;
uint uVar9;
int iVar10;
if (param_2 < 1) {
*param_4 = 0;
puVar7 = (int4 *)malloc(0);
return puVar7;
}
iVar6 =... |
680 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(const char* paren_string, int* returnSize) {
int* all_levels = NULL;
int level = 0, max_level = 0, i = 0, count = 0;
char chr;
for (i = 0; paren_string[i] != '\0'; i++) {
chr = paren_string[i];
if (chr == '(') {
level += 1;
if (level > max_level) max_le... | #include <assert.h>
int issame(const int* a, const int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int returnSize;
int* result;
result = func0("(()()) ((())) () ((())()())",... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movq $0x0,-0x8(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 1277 <func0+0xce>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+ptr], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_10], 0
jmp loc_1277
loc_11ED:
mov eax, [rbp+var_10]
movsxd rdx, e... | void * func0(long long a1, _DWORD *a2)
{
int v2; // eax
char v4; // [rsp+17h] [rbp-19h]
int v5; // [rsp+18h] [rbp-18h]
int v6; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int v8; // [rsp+24h] [rbp-Ch]
void *ptr; // [rsp+28h] [rbp-8h]
ptr = 0LL;
v5 = 0;
v6 = 0;
v8 = 0;
for ( i = 0; *(_B... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV qword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101277
LA... | void * func0(long param_1,int *param_2)
{
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
int8 local_10;
local_10 = (void *)0x0;
local_20 = 0;
local_1c = 0;
local_14 = 0;
for (local_18 = 0; *(char *)(param_1 + local_18) != '\0'; local_18 = local_18 + 1) {
if (*(char *)(param_1 + ... |
681 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(const char* paren_string, int* returnSize) {
int* all_levels = NULL;
int level = 0, max_level = 0, i = 0, count = 0;
char chr;
for (i = 0; paren_string[i] != '\0'; i++) {
chr = paren_string[i];
if (chr == '(') {
level += 1;
if (level > max_level) max_le... | #include <assert.h>
int issame(const int* a, const int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int returnSize;
int* result;
result = func0("(()()) ((())) () ((())()())",... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rsi,%r13
movzbl (%rdi),%edx
test %dl,%dl
je 1226 <func0+0x7d>
lea 0x1(%rdi),%rbx
mov $0x0,%r14d
mov $0x0,%r12d
mov $0x0,%ebp
mov $0x0,%eax
jmp 11f7 <func0+0x4e>
add $0x1,%ebp
cmp ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rsi
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_1226
lea rbx, [rdi+1]
mov r14d, 0
mov r12d, 0
mov ebp, 0
mov eax, 0
jmp short loc_11F7
loc_11E1:
add ebp, 1
cmp ... | void * func0(char *a1, _DWORD *a2)
{
char v2; // dl
char *v3; // rbx
int v4; // r14d
int v5; // r12d
int v6; // ebp
void *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = 0;
result = 0LL;
do
{
if ( v2 == 40 )
{
if ( v5 < ++v6 )
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RSI
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x00101226
LEA RBX,[RDI + 0x1]
MOV R14D,0x0
MOV R12D,0x0
MOV EBP,0x0
MOV EAX,0x0
JMP 0x001011f7
LAB_001011e1:
ADD EBP,0x1
CMP R12D,EBP
CMOVL R12D,EBP
LAB_001011eb:
ADD RBX,0x1
MOVZX EDX,by... | void * func0(char *param_1,int *param_2)
{
void *__ptr;
char cVar1;
char *pcVar2;
int iVar3;
int iVar4;
int iVar5;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar5 = 0;
__ptr = (void *)0x0;
}
else {
iVar5 = 0;
iVar4 = 0;
iVar3 = 0;
__ptr = (void *)0x0;
pcVar2 = param_1 + ... |
682 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(const char* paren_string, int* returnSize) {
int* all_levels = NULL;
int level = 0, max_level = 0, i = 0, count = 0;
char chr;
for (i = 0; paren_string[i] != '\0'; i++) {
chr = paren_string[i];
if (chr == '(') {
level += 1;
if (level > max_level) max_le... | #include <assert.h>
int issame(const int* a, const int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int returnSize;
int* result;
result = func0("(()()) ((())) () ((())()())",... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%edx
test %dl,%dl
je 1408 <func0+0x98>
lea 0x1(%rdi),%rbx
xor %r14d,%r14d
xor %r12d,%r12d
xor %ebp,%ebp
xor %eax,%eax
jmp 13b0 <func0+0x40>
nopl 0x0(%rax)
cmp ... | func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_13D8
lea rbx, [rdi+1]
xor r14d, r14d
xor r12d, r12d
xor ebp, ebp
xor eax, eax
jmp short loc_1380
loc_1370:
cmp d... | void * func0(char *a1, _DWORD *a2)
{
char v2; // dl
char *v3; // rbx
int v4; // r14d
int v5; // r12d
int v6; // ebp
void *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = 0;
result = 0LL;
do
{
while ( v2 == 40 )
{
if ( v5 < ++v6 )... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x001013d8
LEA RBX,[RDI + 0x1]
XOR R14D,R14D
XOR R12D,R12D
XOR EBP,EBP
XOR EAX,EAX
JMP 0x00101380
LAB_00101370:
CMP DL,0x29
JZ 0x001013b0
LAB_00101375:
MOVZX EDX,byte ptr [RBX]
ADD RBX,0x1... | void * func0(char *param_1,int *param_2)
{
void *__ptr;
char cVar1;
int iVar2;
int iVar3;
int iVar4;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
__ptr = (void *)0x0;
}
else {
param_1 = param_1 + 1;
iVar4 = 0;
iVar3 = 0;
iVar2 = 0;
__ptr = (void *)0x0;
do {
... |
683 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| int* func0(const char* paren_string, int* returnSize) {
int* all_levels = NULL;
int level = 0, max_level = 0, i = 0, count = 0;
char chr;
for (i = 0; paren_string[i] != '\0'; i++) {
chr = paren_string[i];
if (chr == '(') {
level += 1;
if (level > max_level) max_le... | #include <assert.h>
int issame(const int* a, const int* b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int returnSize;
int* result;
result = func0("(()()) ((())) () ((())()())",... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
movzbl (%rdi),%edx
test %dl,%dl
je 13e8 <func0+0x98>
lea 0x1(%rdi),%rbx
xor %r14d,%r14d
xor %r12d,%r12d
xor %ebp,%ebp
xor %eax,%eax
jmp 1390 <func0+0x40>
nopl 0x0(%rax)
cmp ... | func0:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
sub rsp, 8
movzx edx, byte ptr [rdi]
test dl, dl
jz short loc_13D8
lea rbx, [rdi+1]
xor r14d, r14d
xor r12d, r12d
xor ebp, ebp
xor eax, eax
jmp short loc_1380
loc_1370:
cmp d... | void * func0(char *a1, _DWORD *a2)
{
char v2; // dl
char *v3; // rbx
int v4; // r14d
int v5; // r12d
int v6; // ebp
void *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = a1 + 1;
v4 = 0;
v5 = 0;
v6 = 0;
result = 0LL;
do
{
while ( v2 == 40 )
{
if ( v5 < ++v6 )... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOVZX EDX,byte ptr [RDI]
TEST DL,DL
JZ 0x001013d8
LEA RBX,[RDI + 0x1]
XOR R14D,R14D
XOR R12D,R12D
XOR EBP,EBP
XOR EAX,EAX
JMP 0x00101380
LAB_00101370:
CMP DL,0x29
JZ 0x001013b0
LAB_00101375:
MOVZX EDX,byte ptr [RBX]
ADD RBX,0x1... | void * func0(char *param_1,int *param_2)
{
void *__ptr;
char cVar1;
int iVar2;
int iVar3;
int iVar4;
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar4 = 0;
__ptr = (void *)0x0;
}
else {
param_1 = param_1 + 1;
iVar4 = 0;
iVar3 = 0;
iVar2 = 0;
__ptr = (void *)0x0;
do {
... |
684 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char **strings, int size, const char *substring, int *out_size) {
char **out = NULL;
int count = 0;
for (int i = 0; i < size; i++) {
if (strstr(strings[i], substring) != NULL) {
out = (char **)realloc(out, sizeof(char *) * (count + 1));
out[count] = strings[i];
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int out_size;
cha... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
movq $0x0,-0x8(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 12a4 <func0+0xbb>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+needle], rdx
mov [rbp+var_30], rcx
mov [rbp+ptr], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp loc_12A4
loc_121F:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov ... | void * func0(long long a1, int a2, const char *a3, _DWORD *a4)
{
int v7; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
void *ptr; // [rsp+28h] [rbp-8h]
ptr = 0LL;
v7 = 0;
for ( i = 0; i < a2; ++i )
{
if ( strstr(*(const char **)(8LL * i + a1), a3) )
{
ptr = realloc(ptr, 8LL * (v7 + 1)... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012a4
LAB_0010121f:
MOV EAX,dword ptr [R... | void * func0(long param_1,int param_2,char *param_3,int *param_4)
{
char *pcVar1;
int4 local_18;
int4 local_14;
int8 local_10;
local_10 = (void *)0x0;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
pcVar1 = strstr(*(char **)(param_1 + (long)local_14 * 8),param_3);
... |
685 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char **strings, int size, const char *substring, int *out_size) {
char **out = NULL;
int count = 0;
for (int i = 0; i < size; i++) {
if (strstr(strings[i], substring) != NULL) {
out = (char **)realloc(out, sizeof(char *) * (count + 1));
out[count] = strings[i];
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int out_size;
cha... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdx,(%rsp)
mov %rcx,0x8(%rsp)
test %esi,%esi
jle 125d <func0+0x74>
mov %rdi,%rbx
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r15
mov $0x0,%r14d
mov $0x0,%ebp
jmp 1247 <func0+0x5e>
add... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+needle], rdx
mov [rsp+48h+var_40], rcx
test esi, esi
jle short loc_125C
mov rbx, rdi
movsxd rsi, esi
lea r15, [rdi+rsi*8]
mov r14d, 0
mov ebp, 0
jmp short loc_1228
loc... | void * func0(const char **a1, int a2, const char *a3, _DWORD *a4)
{
const char **v4; // rbx
int v5; // r14d
void *v6; // rbp
const char *v7; // r13
if ( a2 <= 0 )
{
v5 = 0;
v6 = 0LL;
}
else
{
v4 = a1;
v5 = 0;
v6 = 0LL;
do
{
v7 = *v4;
if ( strstr(*v4, a3) )
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x8],RCX
TEST ESI,ESI
JLE 0x0010125c
MOV RBX,RDI
MOVSXD RSI,ESI
LEA R15,[RDI + RSI*0x8]
MOV R14D,0x0
MOV EBP,0x0
JMP 0x00101228
LAB_0010121f:
ADD RBX,0x8
CMP RBX,R15
JZ 0x00101267
LAB_00101228:... | void * func0(int8 *param_1,int param_2,char *param_3,int *param_4)
{
int8 *puVar1;
char *__haystack;
char *pcVar2;
void *__ptr;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
__ptr = (void *)0x0;
}
else {
puVar1 = param_1 + param_2;
iVar3 = 0;
__ptr = (void *)0x0;
do {
__hays... |
686 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char **strings, int size, const char *substring, int *out_size) {
char **out = NULL;
int count = 0;
for (int i = 0; i < size; i++) {
if (strstr(strings[i], substring) != NULL) {
out = (char **)realloc(out, sizeof(char *) * (count + 1));
out[count] = strings[i];
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int out_size;
cha... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rcx,0x8(%rsp)
test %esi,%esi
jle 15c8 <func0+0x98>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%rax
xor %ebp,%ebp
mov %rax,(%rsp)
nopw 0x0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+needle], rdx
mov [rsp+48h+var_40], rcx
test esi, esi
jle short loc_1610
movsxd rsi, esi
mov r15, rdi
xor r12d, r12d
xor ebx, ebx
lea r14, [rdi+rsi*8]
xchg ax, ax
loc_15... | void * func0(const char **a1, int a2, const char *a3, _DWORD *a4)
{
const char **v4; // r15
int v5; // r12d
void *v6; // rbx
const char *v7; // rbp
_QWORD *v8; // rax
if ( a2 <= 0 )
{
v5 = 0;
v6 = 0LL;
}
else
{
v4 = a1;
v5 = 0;
v6 = 0LL;
do
{
v7 = *v4;
if ( s... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x8],RCX
TEST ESI,ESI
JLE 0x00101610
MOVSXD RSI,ESI
MOV R15,RDI
XOR R12D,R12D
XOR EBX,EBX
LEA R14,[RDI + RSI*0x8]
NOP
LAB_001015b0:
MOV RBP,qword ptr [R15]
MOV RSI,qword ptr [RSP]
MOV RDI,RBP
C... | void * func0(int8 *param_1,int param_2,char *param_3,int *param_4)
{
int8 *puVar1;
char *__haystack;
char *pcVar2;
void *__ptr;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
__ptr = (void *)0x0;
}
else {
iVar3 = 0;
__ptr = (void *)0x0;
puVar1 = param_1 + param_2;
do {
__hays... |
687 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <string.h>
| char **func0(char **strings, int size, const char *substring, int *out_size) {
char **out = NULL;
int count = 0;
for (int i = 0; i < size; i++) {
if (strstr(strings[i], substring) != NULL) {
out = (char **)realloc(out, sizeof(char *) * (count + 1));
out[count] = strings[i];
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, char **b, int size_a, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
int main() {
int out_size;
cha... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rcx,0x8(%rsp)
test %esi,%esi
jle 15e8 <func0+0x98>
lea -0x1(%rsi),%eax
mov %rdx,%r13
mov %rdi,%rbx
xor %r12d,%r12d
lea 0x8(%rdi,%rax,8),%rax
xor %ebp,%ebp
mov %rax,(%rsp)
nopw 0x0... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+needle], rdx
mov [rsp+48h+var_40], rcx
test esi, esi
jle short loc_1610
movsxd rsi, esi
mov r15, rdi
xor r12d, r12d
xor ebx, ebx
lea r14, [rdi+rsi*8]
xchg ax, ax
loc_15... | void * func0(const char **a1, int a2, const char *a3, _DWORD *a4)
{
const char **v4; // r15
int v5; // r12d
void *v6; // rbx
const char *v7; // rbp
_QWORD *v8; // rax
if ( a2 <= 0 )
{
v5 = 0;
v6 = 0LL;
}
else
{
v4 = a1;
v5 = 0;
v6 = 0LL;
do
{
v7 = *v4;
if ( s... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP],RDX
MOV qword ptr [RSP + 0x8],RCX
TEST ESI,ESI
JLE 0x00101610
MOVSXD RSI,ESI
MOV R15,RDI
XOR R12D,R12D
XOR EBX,EBX
LEA R14,[RDI + RSI*0x8]
NOP
LAB_001015b0:
MOV RBP,qword ptr [R15]
MOV RSI,qword ptr [RSP]
MOV RDI,RBP
C... | void * func0(int8 *param_1,int param_2,char *param_3,int *param_4)
{
int8 *puVar1;
char *__haystack;
char *pcVar2;
void *__ptr;
int iVar3;
if (param_2 < 1) {
iVar3 = 0;
__ptr = (void *)0x0;
}
else {
iVar3 = 0;
__ptr = (void *)0x0;
puVar1 = param_1 + param_2;
do {
__hays... |
688 | func0 | #include <stdio.h>
| void func0(int *numbers, int size, int *result) {
int sum = 0, product = 1;
for (int i = 0; i < size; i++) {
sum += numbers[i];
product *= numbers[i];
}
result[0] = sum;
result[1] = product;
} | #include <assert.h>
int issame(const int *a, const int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[2];
// First test case
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 1}, 2));
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cf <func0+0x66>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_11CF
loc_1193:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rd... | long long func0(long long a1, int a2, _DWORD *a3)
{
long long result; // rax
int v4; // [rsp+1Ch] [rbp-Ch]
unsigned int v5; // [rsp+20h] [rbp-8h]
int i; // [rsp+24h] [rbp-4h]
v4 = 0;
v5 = 1;
for ( i = 0; i < a2; ++i )
{
v4 += *(_DWORD *)(4LL * i + a1);
v5 *= *(_DWORD *)(4LL * i + a1);
}
*a... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cf
LAB_00101193:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qwor... | void func0(long param_1,int param_2,int *param_3)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
local_14 = local_14 + *(int *)(param_1 + (long)local_c * 4);
local_10 = *(int *)(param_1 + (long)local_c * 4) * l... |
689 | func0 | #include <stdio.h>
| void func0(int *numbers, int size, int *result) {
int sum = 0, product = 1;
for (int i = 0; i < size; i++) {
sum += numbers[i];
product *= numbers[i];
}
result[0] = sum;
result[1] = product;
} | #include <assert.h>
int issame(const int *a, const int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[2];
// First test case
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 1}, 2));
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 119c <func0+0x33>
mov %rdi,%rax
lea -0x1(%rsi),%ecx
lea 0x4(%rdi,%rcx,4),%r8
mov $0x1,%esi
mov $0x0,%edi
mov (%rax),%ecx
add %ecx,%edi
imul %ecx,%esi
add $0x4,%rax
cmp %r8,%rax
jne 1186 <func0+0x1d>
mov %edi,(%rdx)
mov %esi,0x4(%rdx)
retq
mov ... | func0:
endbr64
test esi, esi
jle short loc_119B
mov rax, rdi
movsxd rsi, esi
lea r8, [rdi+rsi*4]
mov esi, 1
mov edi, 0
loc_1185:
mov ecx, [rax]
add edi, ecx
imul esi, ecx
add rax, 4
cmp rax, r8
jnz short loc_1185
loc_1195:
mov [rdx], edi
mov [rdx+4], esi
retn
loc_1... | void func0(_DWORD *a1, int a2, _DWORD *a3)
{
_DWORD *v3; // rax
_DWORD *v4; // r8
int v5; // esi
int v6; // edi
if ( a2 <= 0 )
{
v5 = 1;
v6 = 0;
}
else
{
v3 = a1;
v4 = &a1[a2];
v5 = 1;
v6 = 0;
do
{
v6 += *v3;
v5 *= *v3++;
}
while ( v3 != v4 );
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119b
MOV RAX,RDI
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
MOV EDI,0x0
LAB_00101185:
MOV ECX,dword ptr [RAX]
ADD EDI,ECX
IMUL ESI,ECX
ADD RAX,0x4
CMP RAX,R8
JNZ 0x00101185
LAB_00101195:
MOV dword ptr [RDX],EDI
MOV dword ptr [RDX + 0x4],ESI
RET
LAB_0010119b:
MOV ESI,0x1
MOV ... | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
if (param_2 < 1) {
iVar2 = 1;
iVar3 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar2 = 1;
iVar3 = 0;
do {
iVar3 = iVar3 + *param_1;
iVar2 = iVar2 * *param_1;
param_1 = param_1 ... |
690 | func0 | #include <stdio.h>
| void func0(int *numbers, int size, int *result) {
int sum = 0, product = 1;
for (int i = 0; i < size; i++) {
sum += numbers[i];
product *= numbers[i];
}
result[0] = sum;
result[1] = product;
} | #include <assert.h>
int issame(const int *a, const int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[2];
// First test case
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 1}, 2));
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
mov $0x1,%ecx
xor %esi,%esi
lea 0x4(%rdi,%rax,4),%r8
nopw 0x0(%rax,%rax,1)
mov (%rdi),%eax
add $0x4,%rdi
imul %eax,%ecx
add %eax,%esi
cmp %r8,%rdi
jne 1160 <func0+0x20>
mov %esi,(%rdx)
mov %ecx,0x4(%rdx)
re... | func0:
endbr64
test esi, esi
jle short loc_1180
movsxd rsi, esi
mov ecx, 1
lea r8, [rdi+rsi*4]
xor esi, esi
nop word ptr [rax+rax+00000000h]
loc_1160:
mov eax, [rdi]
add rdi, 4
imul ecx, eax
add esi, eax
cmp rdi, r8
jnz short loc_1160
mov [rdx], esi
mov [rdx+4], ec... | long long func0(unsigned int *a1, int a2, _DWORD *a3)
{
int v3; // ecx
unsigned int *v4; // r8
int v5; // esi
long long result; // rax
if ( a2 <= 0 )
{
*a3 = 0;
a3[1] = 1;
}
else
{
v3 = 1;
v4 = &a1[a2];
v5 = 0;
do
{
result = *a1++;
v3 *= (_DWORD)result;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101180
MOVSXD RSI,ESI
MOV ECX,0x1
LEA R8,[RDI + RSI*0x4]
XOR ESI,ESI
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101160:
MOV EAX,dword ptr [RDI]
ADD RDI,0x4
IMUL ECX,EAX
ADD ESI,EAX
CMP RDI,R8
JNZ 0x00101160
MOV dword ptr [RDX],ESI
MOV dword ptr [RDX + 0x4],ECX
RET
LAB_00101180:
MOV ECX,0x... | void func0(int *param_1,int param_2,int *param_3)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_2) {
iVar3 = 1;
piVar1 = param_1 + param_2;
iVar4 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 * iVar2;
iVar4 = iVar4 + iVar2;
} w... |
691 | func0 | #include <stdio.h>
| void func0(int *numbers, int size, int *result) {
int sum = 0, product = 1;
for (int i = 0; i < size; i++) {
sum += numbers[i];
product *= numbers[i];
}
result[0] = sum;
result[1] = product;
} | #include <assert.h>
int issame(const int *a, const int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int result[2];
// First test case
func0((const int[]){}, 0, result);
assert(issame(result, (const int[]){0, 1}, 2));
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1240 <func0+0x100>
lea -0x1(%rsi),%eax
cmp $0x16,%eax
jbe 124f <func0+0x10f>
mov %esi,%ecx
movdqa 0xeae(%rip),%xmm0
mov %rdi,%rax
pxor %xmm2,%xmm2
shr $0x2,%ecx
shl $0x4,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
movdqa %xmm0,%xmm3
psr... | func0:
endbr64
mov r9, rdi
mov r8d, esi
test esi, esi
jle loc_1240
lea eax, [rsi-1]
cmp eax, 15h
jbe loc_124D
mov ecx, esi
movdqa xmm0, cs:xmmword_2010
mov rax, rdi
pxor xmm1, xmm1
shr ecx, 2
shl rcx, 4
add rcx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu x... | long long func0(const __m128i *a1, int a2, _DWORD *a3)
{
__m128i si128; // xmm0
const __m128i *v6; // rax
__m128i v7; // xmm1
__m128i v8; // xmm2
long long v9; // rcx
__m128i v10; // xmm3
__m128i v11; // xmm3
int v12; // edi
__m128i v13; // xmm1
long long result; // rax
__int32 v15; // esi
if ... | func0:
ENDBR64
MOV R9,RDI
MOV R8D,ESI
TEST ESI,ESI
JLE 0x00101240
LEA EAX,[RSI + -0x1]
CMP EAX,0x15
JBE 0x0010124d
MOV ECX,ESI
MOVDQA XMM0,xmmword ptr [0x00102010]
MOV RAX,RDI
PXOR XMM1,XMM1
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM2,xmmword ptr [RAX]
MOVDQA XMM3,XMM0
PSRLQ XMM0,0... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(int (*param_1) [16],uint param_2,int *param_3)
{
long lVar1;
int auVar2 [16];
int (*pauVar3) [16];
uint uVar4;
long lVar5;
uint uVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
int auVar10 [16];
int iVar... |
692 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jg 11cc <func0+0x23>
mov $0x0,%eax
jmpq 125e <func0+0xb5>
mov -0x1c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
cmpq $... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jg short loc_11CC
mov eax, 0
jmp locret_125E
loc_11CC:
mov eax, [rbp+var_1C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
cmp ... | _DWORD * func0(int *a1, int a2)
{
int v3; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v5; // [rsp+18h] [rbp-8h]
if ( a2 <= 0 )
return 0LL;
v5 = malloc(4LL * a2);
if ( !v5 )
return 0LL;
v3 = *a1;
for ( i = 0; i < a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
v5[i] = v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JG 0x001011cc
MOV EAX,0x0
JMP 0x0010125e
LAB_001011cc:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
CMP qword pt... | void * func0(int *param_1,int param_2)
{
void *pvVar1;
int local_18;
int local_14;
if (param_2 < 1) {
pvVar1 = (void *)0x0;
}
else {
pvVar1 = malloc((long)param_2 << 2);
if (pvVar1 == (void *)0x0) {
pvVar1 = (void *)0x0;
}
else {
local_18 = *param_1;
for (local_14 =... |
693 | func0 | #include <stdio.h>
#include <stdlib.h>
| int *func0(int *numbers, int size) {
if (size <= 0) {
return NULL;
}
int *out = malloc(size * sizeof(int));
if (!out) {
return NULL;
}
int max = numbers[0];
for (int i = 0; i < size; i++) {
if (numbers[i] > max) max = numbers[i];
out[i] = max;
}
... | #include <assert.h>
#include <stdio.h>
#include <stdlib.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int *result;
// First test case
result = func0((const int[]){}, 0);
assert(result == NULL);
... | O1 | c | func0:
endbr64
mov $0x0,%eax
test %esi,%esi
jle 11fa <func0+0x51>
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %esi,%ebp
movslq %esi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %rax,%rax
je 11f3 <func0+0x4a>
mov (%rbx),%ecx
lea -0x1(%rbp),%edi
mov $0x0,%edx
mov (%rb... | func0:
endbr64
mov eax, 0
test esi, esi
jle short locret_11FB
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
movsxd rsi, esi
lea rbx, ds:0[rsi*4]
mov rdi, rbx; size
call _malloc
test rax, rax
jz short loc_11F4
mov ecx, [rbp+0]
mov edx, 0
loc_11DF:
mov esi, [rbp+rdx+0]... | char * func0(int *a1, int a2)
{
char *result; // rax
int v3; // ecx
long long i; // rdx
result = 0LL;
if ( a2 > 0 )
{
result = (char *)malloc(4LL * a2);
if ( result )
{
v3 = *a1;
for ( i = 0LL; i != a2; ++i )
{
if ( v3 < a1[i] )
v3 = a1[i];
*(_DWORD *... | func0:
ENDBR64
MOV EAX,0x0
TEST ESI,ESI
JLE 0x001011fb
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOVSXD RSI,ESI
LEA RBX,[RSI*0x4]
MOV RDI,RBX
CALL 0x001010b0
TEST RAX,RAX
JZ 0x001011f4
MOV ECX,dword ptr [RBP]
MOV EDX,0x0
LAB_001011df:
MOV ESI,dword ptr [RBP + RDX*0x1]
CMP ECX,ESI
CMOVL ECX,ESI
MOV dword ptr [RAX + RDX*... | void * func0(int *param_1,int param_2)
{
void *pvVar1;
int iVar2;
long lVar3;
if (0 < param_2) {
pvVar1 = malloc((long)param_2 * 4);
if (pvVar1 != (void *)0x0) {
iVar2 = *param_1;
lVar3 = 0;
do {
if (iVar2 < *(int *)((long)param_1 + lVar3)) {
iVar2 = *(int *)((lon... |
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.