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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
4,982 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int test_list[][3], int length, int *output) {
for (int i = 0; i < length; i++) {
output[i] = test_list[i][2];
}
return output;
}
| int main() {
int list1[][3] = {{1, 'R', 21}, {2, 'V', 20}, {3, 'K', 19}};
int list2[][3] = {{1, 'S', 36}, {2, 'A', 25}, {3, 'S', 45}};
int list3[][3] = {{1, 'S', 14}, {2, 'V', 36}, {3, 'D', 56}};
int length1 = sizeof(list1) / sizeof(list1[0]);
int length2 = sizeof(list2) / sizeof(list2[0]... | O2 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 11a2 <func0+0x32>
mov %rdx,%rcx
lea -0x1(%rsi),%edx
add $0x8,%rdi
lea 0x4(%rax,%rdx,4),%r8
nopw 0x0(%rax,%rax,1)
mov (%rdi),%esi
add $0x4,%rcx
add $0xc,%rdi
mov %esi,-0x4(%rcx)
cmp %r8,%rcx
jne 1190 <func0+0x20>
retq
nopw %cs:0x0(... | func0:
endbr64
mov rax, rdx
test esi, esi
jle short locret_11A2
mov rcx, rdx
lea edx, [rsi-1]
add rdi, 8
lea r8, [rax+rdx*4+4]
nop word ptr [rax+rax+00h]
loc_1190:
mov esi, [rdi]
add rcx, 4
add rdi, 0Ch
mov [rcx-4], esi
cmp rcx, r8
jnz short loc_1190
locret_11A2:
r... | long long func0(long long a1, int a2, long long a3)
{
long long result; // rax
long long v4; // rcx
int *v5; // rdi
long long v6; // r8
int v7; // esi
result = a3;
if ( a2 > 0 )
{
v4 = a3;
v5 = (int *)(a1 + 8);
v6 = a3 + 4LL * (unsigned int)(a2 - 1) + 4;
do
{
v7 = *v5;
... | func0:
ENDBR64
MOV RAX,RDX
TEST ESI,ESI
JLE 0x001011a2
MOV RCX,RDX
LEA EDX,[RSI + -0x1]
ADD RDI,0x8
LEA R8,[RAX + RDX*0x4 + 0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_00101190:
MOV ESI,dword ptr [RDI]
ADD RCX,0x4
ADD RDI,0xc
MOV dword ptr [RCX + -0x4],ESI
CMP RCX,R8
JNZ 0x00101190
LAB_001011a2:
RET | void func0(long param_1,int param_2,int4 *param_3)
{
int4 uVar1;
int4 *puVar2;
int4 *puVar3;
int4 *puVar4;
if (0 < param_2) {
puVar4 = (int4 *)(param_1 + 8);
puVar2 = param_3;
do {
uVar1 = *puVar4;
puVar3 = puVar2 + 1;
puVar4 = puVar4 + 3;
*puVar2 = uVar1;
puVar2 ... |
4,983 | func0 | #include <assert.h>
#include <stdio.h>
| int* func0(int test_list[][3], int length, int *output) {
for (int i = 0; i < length; i++) {
output[i] = test_list[i][2];
}
return output;
}
| int main() {
int list1[][3] = {{1, 'R', 21}, {2, 'V', 20}, {3, 'K', 19}};
int list2[][3] = {{1, 'S', 36}, {2, 'A', 25}, {3, 'S', 45}};
int list3[][3] = {{1, 'S', 14}, {2, 'V', 36}, {3, 'D', 56}};
int length1 = sizeof(list1) / sizeof(list1[0]);
int length2 = sizeof(list2) / sizeof(list2[0]... | O3 | c | func0:
endbr64
mov %rdx,%rax
test %esi,%esi
jle 1272 <func0+0x102>
movslq %esi,%rdx
lea 0x8(%rdi),%rcx
lea -0x1(%rsi),%r8d
lea (%rax,%rdx,4),%r9
lea (%rdx,%rdx,2),%rdx
cmp %r9,%rcx
lea (%rdi,%rdx,4),%rdx
setae %r9b
cmp %rdx,%rax
setae %dl
or %dl,%r9b
je 1250 <func0+0xe0>
cmp $0... | func0:
endbr64
mov ecx, esi
mov rsi, rdx
test ecx, ecx
jle short loc_11C2
lea r9d, [rcx-1]
movsxd r8, ecx
lea rax, [rdi+8]
cmp r9d, 3
jbe short loc_11A4
lea rdx, [r8+r8*2]
lea rdx, [rdi+rdx*4]
cmp rsi, rdx
jnb short loc_11D0
lea rdx, [rsi+r8*4]
cmp rax, rdx
jnb ... | unsigned long long func0(long long a1, int a2, unsigned long long a3)
{
unsigned long long v4; // rsi
unsigned int v5; // r9d
const __m128i *v6; // rax
unsigned long long v7; // rdi
__int32 v8; // ecx
__m128 v10; // xmm2
__m128 v11; // xmm1
__m128 v12; // xmm0
signed int v13; // r9d
long long v14; ... | func0:
ENDBR64
MOV ECX,ESI
MOV RSI,RDX
TEST ECX,ECX
JLE 0x001011c2
LEA R9D,[RCX + -0x1]
MOVSXD R8,ECX
LEA RAX,[RDI + 0x8]
CMP R9D,0x3
JBE 0x001011a4
LEA RDX,[R8 + R8*0x2]
LEA RDX,[RDI + RDX*0x4]
CMP RSI,RDX
JNC 0x001011d0
LEA RDX,[RSI + R8*0x4]
CMP RAX,RDX
JNC 0x001011d0
LAB_001011a4:
MOV RDX,RSI
LEA RDI,[RSI + R8*0x4]... | int4 * func0(long param_1,int param_2,int4 *param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 *puVar4;
int4 *puVar5;
int4 *puVar6;
long lVar7;
long lVar8;
uint uVar9;
if (0 < param_2) {
uVar9 = param_2 - 1;
lVar8 = (long)param_2;
puVar4 = (int4 *)(param_1 + 8);
if ((uVar9 < 4) ... |
4,984 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int* test_tup1, int* test_tup2, int n, int* res) {
for (int i = 0; i < n; i++) {
res[i] = test_tup1[i] - test_tup2[i];
}
return res;
}
| int main() {
int result1[3], result2[3], result3[3];
int tup1a[] = {10, 4, 5}, tup2a[] = {2, 5, 18};
int tup1b[] = {11, 2, 3}, tup2b[] = {24, 45, 16};
int tup1c[] = {7, 18, 9}, tup2c[] = {10, 11, 12};
int expected1[] = {8, -1, -13}, expected2[] = {-13, -43, -13}, expected3[] = {-3, 7, -3}... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f3 <func0+0x6a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
jmp short loc_11F2
loc_11A9:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
*(_DWORD *)(4LL * i + a4) = *(_DWORD *)(4LL * i + a1) - *(_DWORD *)(4LL * i + a2);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f2
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | long func0(long param_1,long param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) =
*(int *)(param_1 + (long)local_c * 4) - *(int *)(param_2 + (long)local_c * 4);
}
return param_4;
} |
4,985 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int* test_tup1, int* test_tup2, int n, int* res) {
for (int i = 0; i < n; i++) {
res[i] = test_tup1[i] - test_tup2[i];
}
return res;
}
| int main() {
int result1[3], result2[3], result3[3];
int tup1a[] = {10, 4, 5}, tup2a[] = {2, 5, 18};
int tup1b[] = {11, 2, 3}, tup2b[] = {24, 45, 16};
int tup1c[] = {7, 18, 9}, tup2c[] = {10, 11, 12};
int expected1[] = {8, -1, -13}, expected2[] = {-13, -43, -13}, expected3[] = {-3, 7, -3}... | O1 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 11b4 <func0+0x2b>
lea -0x1(%rdx),%ecx
mov $0x0,%edx
mov (%rdi,%rdx,4),%r8d
sub (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 119c <func0+0x13>
retq
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_11B1
mov edx, edx
mov r8d, 0
loc_119C:
mov r9d, [rdi+r8*4]
sub r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp r8, rdx
jnz short loc_119C
locret_11B1:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) - *(_DWORD *)(a2 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x001011b1
MOV EDX,EDX
MOV R8D,0x0
LAB_0010119c:
MOV R9D,dword ptr [RDI + R8*0x4]
SUB R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP R8,RDX
JNZ 0x0010119c
LAB_001011b1:
RET | void func0(long param_1,long param_2,uint param_3,long param_4)
{
ulong uVar1;
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) - *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return;
} |
4,986 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int* test_tup1, int* test_tup2, int n, int* res) {
for (int i = 0; i < n; i++) {
res[i] = test_tup1[i] - test_tup2[i];
}
return res;
}
| int main() {
int result1[3], result2[3], result3[3];
int tup1a[] = {10, 4, 5}, tup2a[] = {2, 5, 18};
int tup1b[] = {11, 2, 3}, tup2b[] = {24, 45, 16};
int tup1c[] = {7, 18, 9}, tup2c[] = {10, 11, 12};
int expected1[] = {8, -1, -13}, expected2[] = {-13, -43, -13}, expected3[] = {-3, 7, -3}... | O2 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 12f8 <func0+0x28>
lea -0x1(%rdx),%ecx
xor %edx,%edx
mov (%rdi,%rdx,4),%r8d
sub (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 12e0 <func0+0x10>
retq
nopl 0x0(%rax)
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_130D
movsxd rdx, edx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_12F8:
mov r9d, [rdi+r8*4]
sub r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp rdx, r8
jnz short loc_12F8
locret_130D:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) - *(_DWORD *)(a2 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x0010130d
MOVSXD RDX,EDX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_001012f8:
MOV R9D,dword ptr [RDI + R8*0x4]
SUB R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP RDX,R8
JNZ 0x001012f8
LAB_0010130d:
RET | void func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) - *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return;
} |
4,987 | func0 | #include <stdio.h>
#include <assert.h>
| int* func0(int* test_tup1, int* test_tup2, int n, int* res) {
for (int i = 0; i < n; i++) {
res[i] = test_tup1[i] - test_tup2[i];
}
return res;
}
| int main() {
int result1[3], result2[3], result3[3];
int tup1a[] = {10, 4, 5}, tup2a[] = {2, 5, 18};
int tup1b[] = {11, 2, 3}, tup2b[] = {24, 45, 16};
int tup1c[] = {7, 18, 9}, tup2c[] = {10, 11, 12};
int expected1[] = {8, -1, -13}, expected2[] = {-13, -43, -13}, expected3[] = {-3, 7, -3}... | O3 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1245 <func0+0xd5>
lea 0xf(%rcx),%rcx
lea -0x1(%rdx),%r8d
mov %rcx,%r9
sub %rdi,%r9
cmp $0x1e,%r9
seta %r10b
cmp $0x2,%r8d
seta %r9b
test %r9b,%r10b
je 1228 <func0+0xb8>
sub %rsi,%rcx
cmp $0x1e,%rcx
jbe 1228 <func0+0xb8>
mov ... | func0:
endbr64
movsxd rax, edx
mov r8, rsi
test eax, eax
jle loc_1231
cmp eax, 1
jz loc_1238
lea rsi, [rdi+4]
mov rdx, rcx
sub rdx, rsi
cmp rdx, 8
jbe loc_1238
lea rsi, [r8+4]
mov rdx, rcx
sub rdx, rsi
cmp rdx, 8
jbe loc_1238
lea edx, [rax-1]
mov r9d,... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int v6; // r9d
long long v7; // rdx
signed int v8; // edx
unsigned int v9; // esi
long long v11; // rax
if ( a3 <= 0 )
return a4;
if ( a3 != 1 && (unsigned long long)(a4 - (a1 + 4)) > 8 && (unsigned long long)(a4 - (a2 + 4)) > 8 )
... | func0:
ENDBR64
MOVSXD RAX,EDX
MOV R8,RSI
TEST EAX,EAX
JLE 0x00101231
CMP EAX,0x1
JZ 0x00101238
LEA RSI,[RDI + 0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x8
JBE 0x00101238
LEA RSI,[R8 + 0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x8
JBE 0x00101238
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010125f
MOV ESI,EAX
XOR EDX,EDX
... | long func0(long param_1,long param_2,uint param_3,long param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
ulong uVar12;
uint uVar13;
long lVar14;
if ((int)param_3 < 1) {
return param_4;
}
... |
4,988 | func0 |
#include <assert.h>
| int func0(int n) {
return (1 << (n - 1));
}
| int main() {
assert(func0(4) == 8);
assert(func0(6) == 32);
assert(func0(2) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
sub $0x1,%eax
mov $0x1,%edx
mov %eax,%ecx
shl %cl,%edx
mov %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
sub eax, 1
mov edx, 1
mov ecx, eax
shl edx, cl
mov eax, edx
pop rbp
retn | long long func0(char a1)
{
return (unsigned int)(1 << (a1 - 1));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,0x1
MOV EDX,0x1
MOV ECX,EAX
SHL EDX,CL
MOV EAX,EDX
POP RBP
RET | int func0(char param_1)
{
return 1 << (param_1 - 1U & 0x1f);
} |
4,989 | func0 |
#include <assert.h>
| int func0(int n) {
return (1 << (n - 1));
}
| int main() {
assert(func0(4) == 8);
assert(func0(6) == 32);
assert(func0(2) == 2);
return 0;
}
| O1 | c | func0:
endbr64
lea -0x1(%rdi),%ecx
mov $0x1,%eax
shl %cl,%eax
retq
| func0:
endbr64
lea ecx, [rdi-1]
mov eax, 1
shl eax, cl
retn | long long func0(char a1)
{
return (unsigned int)(1 << (a1 - 1));
} | func0:
ENDBR64
LEA ECX,[RDI + -0x1]
MOV EAX,0x1
SHL EAX,CL
RET | int func0(char param_1)
{
return 1 << (param_1 - 1U & 0x1f);
} |
4,990 | func0 |
#include <assert.h>
| int func0(int n) {
return (1 << (n - 1));
}
| int main() {
assert(func0(4) == 8);
assert(func0(6) == 32);
assert(func0(2) == 2);
return 0;
}
| O2 | c | func0:
endbr64
lea -0x1(%rdi),%ecx
mov $0x1,%eax
shl %cl,%eax
retq
| func0:
endbr64
lea ecx, [rdi-1]
mov eax, 1
shl eax, cl
retn | long long func0(char a1)
{
return (unsigned int)(1 << (a1 - 1));
} | func0:
ENDBR64
LEA ECX,[RDI + -0x1]
MOV EAX,0x1
SHL EAX,CL
RET | int func0(char param_1)
{
return 1 << (param_1 - 1U & 0x1f);
} |
4,991 | func0 |
#include <assert.h>
| int func0(int n) {
return (1 << (n - 1));
}
| int main() {
assert(func0(4) == 8);
assert(func0(6) == 32);
assert(func0(2) == 2);
return 0;
}
| O3 | c | func0:
endbr64
lea -0x1(%rdi),%ecx
mov $0x1,%eax
shl %cl,%eax
retq
| func0:
endbr64
lea ecx, [rdi-1]
mov eax, 1
shl eax, cl
retn | long long func0(char a1)
{
return (unsigned int)(1 << (a1 - 1));
} | func0:
ENDBR64
LEA ECX,[RDI + -0x1]
MOV EAX,0x1
SHL EAX,CL
RET | int func0(char param_1)
{
return 1 << (param_1 - 1U & 0x1f);
} |
4,992 | func0 | #include <assert.h>
| int func0(int a[], int n, int m) {
int i;
for (i = 0; i < n; i++) {
a[i] = (a[i] / m + (a[i] % m != 0));
}
int result = -1, maxx = -1;
for (i = n - 1; i >= 0; i--) {
if (maxx < a[i]) {
maxx = a[i];
result = i;
}
}
return result + 1;... | int main() {
int array1[3] = {2, 5, 4};
int array2[2] = {4, 3};
int array3[4] = {1, 2, 3, 4};
assert(func0(array1, 3, 2) == 2);
assert(func0(array2, 2, 2) == 2);
assert(func0(array3, 4, 1) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11e0 <func0+0x77>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
idivl -0x20(%rbp)
mov %eax,%esi
mo... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 0
jmp short loc_11E0
loc_1184:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cdq
idiv [rbp+var_20]
... | long long func0(long long a1, int a2, int a3)
{
int i; // [rsp+14h] [rbp-Ch]
int j; // [rsp+14h] [rbp-Ch]
int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
*(_DWORD *)(4LL * i + a1) = *(_DWORD *)(4LL * i + a1) / a3 + (*(_DWORD *)(4LL * i + a1) % a3 != 0);
v6 = -1;
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011e0
LAB_00101184:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CDQ
ID... | int func0(long param_1,int param_2,int param_3)
{
int4 local_14;
int4 local_10;
int4 local_c;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
*(uint *)(param_1 + (long)local_14 * 4) =
(uint)(*(int *)(param_1 + (long)local_14 * 4) % param_3 != 0) +
*(int *)(param_1 + (... |
4,993 | func0 | #include <assert.h>
| int func0(int a[], int n, int m) {
int i;
for (i = 0; i < n; i++) {
a[i] = (a[i] / m + (a[i] % m != 0));
}
int result = -1, maxx = -1;
for (i = n - 1; i >= 0; i--) {
if (maxx < a[i]) {
maxx = a[i];
result = i;
}
}
return result + 1;... | int main() {
int array1[3] = {2, 5, 4};
int array2[2] = {4, 3};
int array3[4] = {1, 2, 3, 4};
assert(func0(array1, 3, 2) == 2);
assert(func0(array2, 2, 2) == 2);
assert(func0(array3, 4, 1) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r8d
test %esi,%esi
jle 11c1 <func0+0x58>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov (%rcx),%eax
cltd
idiv %r8d
test %edx,%edx
setne %dl
movzbl %dl,%edx
add %edx,%eax
mov %eax,(%rcx)
add $0x4,%rcx
cmp %r9,%rcx
jne 117f <func0+0x16>
sub ... | func0:
endbr64
mov r8, rdi
mov edi, edx
test esi, esi
jle short loc_11BF
mov rcx, r8
lea eax, [rsi-1]
lea r9, [r8+rax*4+4]
loc_1181:
mov eax, [rcx]
cdq
idiv edi
cmp edx, 1
sbb eax, 0FFFFFFFFh
mov [rcx], eax
add rcx, 4
cmp rcx, r9
jnz short loc_1181
sub esi, ... | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rcx
long long v4; // rdx
int v5; // esi
int v6; // eax
if ( a2 <= 0 )
{
v6 = -1;
}
else
{
v3 = a1;
do
{
*v3 = *v3 / a3 - ((*v3 % a3 == 0) - 1);
++v3;
}
while ( v3 != &a1[a2 - 1 + 1] );
v4 = a2 - 1;
... | func0:
ENDBR64
MOV R8,RDI
MOV EDI,EDX
TEST ESI,ESI
JLE 0x001011bf
MOV RCX,R8
LEA EAX,[RSI + -0x1]
LEA R9,[R8 + RAX*0x4 + 0x4]
LAB_00101181:
MOV EAX,dword ptr [RCX]
CDQ
IDIV EDI
CMP EDX,0x1
SBB EAX,-0x1
MOV dword ptr [RCX],EAX
ADD RCX,0x4
CMP RCX,R9
JNZ 0x00101181
SUB ESI,0x1
MOVSXD RDX,ESI
MOV ESI,0xffffffff
MOV EAX,0x... | int func0(int *param_1,int param_2,int param_3)
{
int iVar1;
ulong uVar2;
int *piVar3;
ulong uVar4;
int iVar5;
if (param_2 < 1) {
iVar1 = -1;
}
else {
piVar3 = param_1;
do {
*piVar3 = (*piVar3 / param_3 + 1) - (uint)(*piVar3 % param_3 == 0);
piVar3 = piVar3 + 1;
} while (... |
4,994 | func0 | #include <assert.h>
| int func0(int a[], int n, int m) {
int i;
for (i = 0; i < n; i++) {
a[i] = (a[i] / m + (a[i] % m != 0));
}
int result = -1, maxx = -1;
for (i = n - 1; i >= 0; i--) {
if (maxx < a[i]) {
maxx = a[i];
result = i;
}
}
return result + 1;... | int main() {
int array1[3] = {2, 5, 4};
int array2[2] = {4, 3};
int array3[4] = {1, 2, 3, 4};
assert(func0(array1, 3, 2) == 2);
assert(func0(array2, 2, 2) == 2);
assert(func0(array3, 4, 1) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%r9d
lea -0x1(%rsi),%r8d
test %esi,%esi
jle 1300 <func0+0x70>
mov %r8d,%eax
mov %rdi,%rcx
lea 0x4(%rdi,%rax,4),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rcx),%eax
cltd
idiv %r9d
test %edx,%edx
setne %dl
add $0x4,%rcx
movzbl %dl,%edx
add %edx,%eax
mov %eax,-0x4(%rcx)... | func0:
endbr64
mov r9, rdi
mov r8d, edx
lea edi, [rsi-1]
test esi, esi
jle short loc_12F0
mov eax, edi
mov rcx, r9
lea rsi, [r9+rax*4+4]
nop dword ptr [rax+rax+00h]
loc_12B0:
mov eax, [rcx]
cdq
idiv r8d
cmp edx, 1
sbb eax, 0FFFFFFFFh
add rcx, 4
mov [rcx-4], eax
... | long long func0(_DWORD *a1, int a2, int a3)
{
int v4; // edi
_DWORD *v5; // rcx
int v6; // eax
long long v7; // rdx
int v8; // esi
int v9; // eax
v4 = a2 - 1;
if ( a2 <= 0 )
{
if ( v4 < 0 )
return 0LL;
}
else
{
v5 = a1;
do
{
v6 = *v5 / a3 - ((*v5 % a3 == 0) - 1);
... | func0:
ENDBR64
MOV R9,RDI
MOV R8D,EDX
LEA EDI,[RSI + -0x1]
TEST ESI,ESI
JLE 0x001012f0
MOV EAX,EDI
MOV RCX,R9
LEA RSI,[R9 + RAX*0x4 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001012b0:
MOV EAX,dword ptr [RCX]
CDQ
IDIV R8D
CMP EDX,0x1
SBB EAX,-0x1
ADD RCX,0x4
MOV dword ptr [RCX + -0x4],EAX
CMP RSI,RCX
JNZ 0x001012b0
LAB_0... | int func0(int *param_1,int param_2,int param_3)
{
ulong uVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
uint uVar6;
uVar6 = param_2 - 1;
if (param_2 < 1) {
if ((int)uVar6 < 0) {
return 0;
}
}
else {
piVar2 = param_1;
do {
piVar3 = piVar2 + 1;
*piVar2 = ... |
4,995 | func0 | #include <assert.h>
| int func0(int a[], int n, int m) {
int i;
for (i = 0; i < n; i++) {
a[i] = (a[i] / m + (a[i] % m != 0));
}
int result = -1, maxx = -1;
for (i = n - 1; i >= 0; i--) {
if (maxx < a[i]) {
maxx = a[i];
result = i;
}
}
return result + 1;... | int main() {
int array1[3] = {2, 5, 4};
int array2[2] = {4, 3};
int array3[4] = {1, 2, 3, 4};
assert(func0(array1, 3, 2) == 2);
assert(func0(array2, 2, 2) == 2);
assert(func0(array3, 4, 1) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%r9d
lea -0x1(%rsi),%r8d
test %esi,%esi
jle 12f0 <func0+0x70>
mov %r8d,%eax
mov %rdi,%rcx
lea 0x4(%rdi,%rax,4),%rsi
nopw 0x0(%rax,%rax,1)
mov (%rcx),%eax
cltd
idiv %r9d
test %edx,%edx
setne %dl
add $0x4,%rcx
movzbl %dl,%edx
add %edx,%eax
mov %eax,-0x4(%rcx)... | func0:
endbr64
mov r8, rdi
mov edi, edx
test esi, esi
jle short loc_12F0
movsxd rax, esi
mov rcx, r8
lea r9, [r8+rax*4]
nop word ptr [rax+rax+00000000h]
loc_12A0:
mov eax, [rcx]
cdq
idiv edi
cmp edx, 1
sbb eax, 0FFFFFFFFh
add rcx, 4
mov [rcx-4], eax
cmp rcx, r9
jnz... | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rcx
int v4; // eax
int v5; // ecx
int v6; // eax
long long v7; // rdx
if ( a2 <= 0 )
return 0LL;
v3 = a1;
do
{
v4 = *v3 / a3 - ((*v3 % a3 == 0) - 1);
*v3++ = v4;
}
while ( v3 != &a1[a2] );
v5 = -1;
v6 = -1;
v7 = a2 - ... | func0:
ENDBR64
MOV R8,RDI
MOV EDI,EDX
TEST ESI,ESI
JLE 0x001012f0
MOVSXD RAX,ESI
MOV RCX,R8
LEA R9,[R8 + RAX*0x4]
NOP word ptr [RAX + RAX*0x1]
LAB_001012a0:
MOV EAX,dword ptr [RCX]
CDQ
IDIV EDI
CMP EDX,0x1
SBB EAX,-0x1
ADD RCX,0x4
MOV dword ptr [RCX + -0x4],EAX
CMP RCX,R9
JNZ 0x001012a0
SUB ESI,0x1
MOV ECX,0xffffffff
M... | int func0(int *param_1,int param_2,int param_3)
{
ulong uVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
if (param_2 < 1) {
return 0;
}
piVar3 = param_1;
do {
piVar4 = piVar3 + 1;
*piVar3 = (*piVar3 / param_3 + 1) - (uint)(*piVar3 % param_3 == 0);
piVar3 = piVar4;
} while... |
4,996 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(double r, double h) {
double volume = 3.1415 * r * r * h;
return volume;
}
| int main() {
assert(func0(10, 5) == 1570.7500000000002);
assert(func0(4, 5) == 251.32000000000002);
assert(func0(4, 10) == 502.64000000000004);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
movsd %xmm0,-0x18(%rbp)
movsd %xmm1,-0x20(%rbp)
movsd -0x18(%rbp),%xmm1
movsd 0xf58(%rip),%xmm0
mulsd %xmm1,%xmm0
mulsd -0x18(%rbp),%xmm0
movsd -0x20(%rbp),%xmm1
mulsd %xmm1,%xmm0
movsd %xmm0,-0x8(%rbp)
movsd -0x8(%rbp),%xmm0
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
movsd [rbp+var_18], xmm0
movsd [rbp+var_20], xmm1
movsd xmm1, [rbp+var_18]
movsd xmm0, cs:qword_20A0
mulsd xmm0, xmm1
mulsd xmm0, [rbp+var_18]
movsd xmm1, [rbp+var_20]
mulsd xmm0, xmm1
movsd [rbp+var_8], xmm0
movsd xmm0, [rbp+var_8]
pop rbp
retn | double func0(double a1, double a2)
{
return 3.1415 * a1 * a1 * a2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOVSD qword ptr [RBP + -0x18],XMM0
MOVSD qword ptr [RBP + -0x20],XMM1
MOVSD XMM1,qword ptr [RBP + -0x18]
MOVSD XMM0,qword ptr [0x001020a0]
MULSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x18]
MOVSD XMM1,qword ptr [RBP + -0x20]
MULSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x8],XMM0
MOVSD XMM... | double func0(double param_1,double param_2)
{
return DAT_001020a0 * param_1 * param_1 * param_2;
} |
4,997 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(double r, double h) {
double volume = 3.1415 * r * r * h;
return volume;
}
| int main() {
assert(func0(10, 5) == 1570.7500000000002);
assert(func0(4, 5) == 251.32000000000002);
assert(func0(4, 10) == 502.64000000000004);
return 0;
}
| O1 | c | func0:
endbr64
movapd %xmm0,%xmm2
mulsd 0xecf(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm0
retq
| func0:
endbr64
movapd xmm2, xmm0
mulsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return a1 * 3.1415 * a1 * a2;
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MULSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
MULSD XMM0,XMM1
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
double func0(double param_1,double param_2)
{
return param_1 * _DAT_00102008 * param_1 * param_2;
} |
4,998 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(double r, double h) {
double volume = 3.1415 * r * r * h;
return volume;
}
| int main() {
assert(func0(10, 5) == 1570.7500000000002);
assert(func0(4, 5) == 251.32000000000002);
assert(func0(4, 10) == 502.64000000000004);
return 0;
}
| O2 | c | func0:
endbr64
movapd %xmm0,%xmm2
movsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
mulsd xmm0, xmm2
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return 3.1415 * a1 * a1 * a2;
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
MULSD XMM0,XMM2
MULSD XMM0,XMM1
RET | double func0(double param_1,double param_2)
{
return DAT_00102008 * param_1 * param_1 * param_2;
} |
4,999 | func0 |
#include <assert.h>
#include <stdio.h>
| double func0(double r, double h) {
double volume = 3.1415 * r * r * h;
return volume;
}
| int main() {
assert(func0(10, 5) == 1570.7500000000002);
assert(func0(4, 5) == 251.32000000000002);
assert(func0(4, 10) == 502.64000000000004);
return 0;
}
| O3 | c | func0:
endbr64
movapd %xmm0,%xmm2
movsd 0xeb8(%rip),%xmm0
mulsd %xmm2,%xmm0
mulsd %xmm2,%xmm0
mulsd %xmm1,%xmm0
retq
nopl (%rax)
| func0:
endbr64
movapd xmm2, xmm0
movsd xmm0, cs:qword_2008
mulsd xmm0, xmm2
mulsd xmm0, xmm2
mulsd xmm0, xmm1
retn | double func0(double a1, double a2)
{
return 3.1415 * a1 * a1 * a2;
} | func0:
ENDBR64
MOVAPD XMM2,XMM0
MOVSD XMM0,qword ptr [0x00102008]
MULSD XMM0,XMM2
MULSD XMM0,XMM2
MULSD XMM0,XMM1
RET | double func0(double param_1,double param_2)
{
return DAT_00102008 * param_1 * param_1 * param_2;
} |
5,000 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key[100];
int value;
} DictItem;
typedef struct {
DictItem* items;
int size;
} Dict;
| Dict func0(Dict input, int n) {
Dict result;
result.items = (DictItem*)malloc(input.size * sizeof(DictItem));
result.size = 0;
for (int i = 0; i < input.size; i++) {
if (input.items[i].value >= n) {
result.items[result.size] = input.items[i];
result.size++;
... | int main() {
Dict d1, d2, d3;
d1.size = 4;
d1.items = (DictItem*)malloc(d1.size * sizeof(DictItem));
strcpy(d1.items[0].key, "Cierra Vega"); d1.items[0].value = 175;
strcpy(d1.items[1].key, "Alden Cantrell"); d1.items[1].value = 180;
strcpy(d1.items[2].key, "Kierra Gentry"); d1.items[2].va... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,%rcx
mov %rsi,%rax
mov %rax,%rbx
mov %rcx,-0x40(%rbp)
mov %rbx,-0x38(%rbp)
mov %edx,-0x44(%rbp)
mov -0x38(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
add %rdx,%r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov rax, rdi
mov rcx, rax
mov rbx, rdx
mov rbx, rsi
mov [rbp+var_40], rcx
mov [rbp+var_38], rbx
mov [rbp+var_44], edx
mov eax, dword ptr [rbp+var_38]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, r... | char * func0(long long a1, int a2, int a3)
{
_QWORD *v3; // rdx
char *v4; // rax
long long v5; // rbx
long long v6; // rbx
long long v7; // rbx
long long v8; // rbx
long long v9; // rbx
long long v10; // rbx
int i; // [rsp+2Ch] [rbp-24h]
char *v14; // [rsp+30h] [rbp-20h]
int v15; // [rsp+38h] [rbp... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV RAX,RDI
MOV RCX,RAX
MOV RBX,RDX
MOV RBX,RSI
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RBP + -0x38],RBX
MOV dword ptr [RBP + -0x44],EDX
MOV EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
ADD RAX,RDX
SHL RAX,0x3... | int [16] func0(long param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 uVar2;
int auVar3 [16];
void *pvVar4;
int8 *puVar5;
int local_2c;
int local_20;
int4 uStack_1c;
pvVar4 = malloc((long)param_2 * 0x68);
local_20 = 0;
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
... |
5,001 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key[100];
int value;
} DictItem;
typedef struct {
DictItem* items;
int size;
} Dict;
| Dict func0(Dict input, int n) {
Dict result;
result.items = (DictItem*)malloc(input.size * sizeof(DictItem));
result.size = 0;
for (int i = 0; i < input.size; i++) {
if (input.items[i].value >= n) {
result.items[result.size] = input.items[i];
result.size++;
... | int main() {
Dict d1, d2, d3;
d1.size = 4;
d1.items = (DictItem*)malloc(d1.size * sizeof(DictItem));
strcpy(d1.items[0].key, "Cierra Vega"); d1.items[0].value = 175;
strcpy(d1.items[1].key, "Alden Cantrell"); d1.items[1].value = 180;
strcpy(d1.items[2].key, "Kierra Gentry"); d1.items[2].va... | O1 | c | func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbp
mov %edx,%ebx
movslq %esi,%rax
lea (%rax,%rax,2),%rdx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1090 <malloc@plt>
test %ebp,%ebp
jle 1229 <func0+0xa0>
mov %r12,%rcx
lea -0x1(%rbp),%edx
lea (%rdx,%rdx,2),%rsi... | func0:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov rbp, rsi
mov ebx, edx
movsxd rax, esi
lea rdx, [rax+rax*2]
lea rdi, [rax+rdx*4]
shl rdi, 3
call _malloc
mov r8, rax
test ebp, ebp
jle short loc_124C
mov rax, r12
lea edx, [rbp-1]
lea rcx, [rdx+rdx*2]
l... | long long func0(const __m128i *a1, int a2, __int32 a3)
{
long long v4; // r8
const __m128i *v5; // rax
long long v6; // rsi
int v7; // edx
__m128i *v8; // rcx
v4 = malloc(104LL * a2);
if ( a2 > 0 )
{
v5 = a1;
v6 = (long long)&a1[6].m128i_i64[13 * (unsigned int)(a2 - 1) + 1];
v7 = 0;
do... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV RBP,RSI
MOV EBX,EDX
MOVSXD RAX,ESI
LEA RDX,[RAX + RAX*0x2]
LEA RDI,[RAX + RDX*0x4]
SHL RDI,0x3
CALL 0x001010b0
MOV R8,RAX
TEST EBP,EBP
JLE 0x0010124c
MOV RAX,R12
LEA EDX,[RBP + -0x1]
LEA RCX,[RDX + RDX*0x2]
LEA RDX,[RDX + RCX*0x4]
LEA RSI,[R12 + RDX*0x8 + 0x68]
... | int1 [16] func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
int iVar4;
int1 auVar5 [16];
auVar5._0_8_ = malloc((long)param_2 * 0x68);
if (param_2 < 1) {
iVar4 = 0;
}
else {
puVar2 = param_1 + (ulong)(param_2 - 1) * 0xd + 0xd;
iVar4 = 0;
do {
... |
5,002 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key[100];
int value;
} DictItem;
typedef struct {
DictItem* items;
int size;
} Dict;
| Dict func0(Dict input, int n) {
Dict result;
result.items = (DictItem*)malloc(input.size * sizeof(DictItem));
result.size = 0;
for (int i = 0; i < input.size; i++) {
if (input.items[i].value >= n) {
result.items[result.size] = input.items[i];
result.size++;
... | int main() {
Dict d1, d2, d3;
d1.size = 4;
d1.items = (DictItem*)malloc(d1.size * sizeof(DictItem));
strcpy(d1.items[0].key, "Cierra Vega"); d1.items[0].value = 175;
strcpy(d1.items[1].key, "Alden Cantrell"); d1.items[1].value = 180;
strcpy(d1.items[2].key, "Kierra Gentry"); d1.items[2].va... | O2 | c | func0:
endbr64
movslq %esi,%rax
push %r12
mov %rsi,%r12
push %rbp
mov %edx,%ebp
lea (%rax,%rax,2),%rdx
push %rbx
mov %rdi,%rbx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1090 <malloc@plt>
test %r12d,%r12d
jle 1478 <func0+0xa8>
lea -0x1(%r12),%edx
mov %rbx,%rdi
xor %esi,%esi
lea ... | func0:
endbr64
movsxd rax, esi
push r12
mov r12, rsi
push rbp
mov ebp, edx
lea rdx, [rax+rax*2]
push rbx
mov rbx, rdi
lea rdi, [rax+rdx*4]
shl rdi, 3
call _malloc
mov r8, rax
test r12d, r12d
jle loc_14A0
lea edx, [r12-1]
mov rax, rbx
lea rcx, [rdx+rdx*2]
lea ... | long long func0(const __m128i *a1, int a2, __int32 a3)
{
long long result; // rax
long long v5; // r8
const __m128i *v6; // rax
long long v7; // rsi
int v8; // edx
long long v9; // rcx
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm2
__m128i v13; // xmm3
__m128i v14; // xmm4
__m12... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R12
MOV R12,RSI
PUSH RBP
MOV EBP,EDX
LEA RDX,[RAX + RAX*0x2]
PUSH RBX
MOV RBX,RDI
LEA RDI,[RAX + RDX*0x4]
SHL RDI,0x3
CALL 0x001010b0
MOV R8,RAX
TEST R12D,R12D
JLE 0x001014a0
LEA EDX,[R12 + -0x1]
MOV RAX,RBX
LEA RCX,[RDX + RDX*0x2]
LEA RDX,[RDX + RCX*0x4]
LEA RSI,[RBX + RDX*0x8 + 0x68... | int1 [16] func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int8 uVar10;
int8 uVar11;
int8 uVar12;
int8 uVar13;
int8 uVar14;
long lVar15;
int iVar16;
int1 auVar17 [16];
int1... |
5,003 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char key[100];
int value;
} DictItem;
typedef struct {
DictItem* items;
int size;
} Dict;
| Dict func0(Dict input, int n) {
Dict result;
result.items = (DictItem*)malloc(input.size * sizeof(DictItem));
result.size = 0;
for (int i = 0; i < input.size; i++) {
if (input.items[i].value >= n) {
result.items[result.size] = input.items[i];
result.size++;
... | int main() {
Dict d1, d2, d3;
d1.size = 4;
d1.items = (DictItem*)malloc(d1.size * sizeof(DictItem));
strcpy(d1.items[0].key, "Cierra Vega"); d1.items[0].value = 175;
strcpy(d1.items[1].key, "Alden Cantrell"); d1.items[1].value = 180;
strcpy(d1.items[2].key, "Kierra Gentry"); d1.items[2].va... | O3 | c | func0:
endbr64
movslq %esi,%rax
push %r12
mov %rsi,%r12
push %rbp
mov %edx,%ebp
lea (%rax,%rax,2),%rdx
push %rbx
mov %rdi,%rbx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1090 <malloc@plt>
test %r12d,%r12d
jle 1478 <func0+0xa8>
lea -0x1(%r12),%edx
mov %rbx,%rdi
xor %esi,%esi
lea ... | func0:
endbr64
movsxd rax, esi
push r13
mov r13, rsi
push r12
mov r12d, edx
lea rdx, [rax+rax*2]
push rbp
push rbx
mov rbx, rdi
lea rdi, [rax+rdx*4]
lea rbp, ds:0[rdi*8]
mov rdi, rbp; size
sub rsp, 8
call _malloc
test r13d, r13d
jle loc_1468
mov rcx, rbx
lea ... | char * func0(const __m128i *a1, int a2, __int32 a3)
{
size_t v4; // rbp
char *result; // rax
const __m128i *v6; // rcx
int v7; // edx
long long v8; // rsi
__m128i v9; // xmm0
__m128i v10; // xmm1
__m128i v11; // xmm2
__m128i v12; // xmm3
__m128i v13; // xmm4
__m128i *v14; // rsi
__m128i v15; // ... | func0:
ENDBR64
MOVSXD RAX,ESI
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12D,EDX
LEA RDX,[RAX + RAX*0x2]
PUSH RBP
PUSH RBX
MOV RBX,RDI
LEA RDI,[RAX + RDX*0x4]
LEA RBP,[RDI*0x8]
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010b0
TEST R13D,R13D
JLE 0x00101468
MOV RCX,RBX
LEA RDI,[RBP + RBX*0x1]
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001013f8:... | void func0(int8 *param_1,int param_2,int param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
int8 uVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int8 uVar10;
int8 uVar11;
int8 uVar12;
int8 uVar13;
int8 uVar14;
void *pvVar15;
int iVar16;
long lVar17;
pvVar15 = m... |
5,004 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const void* test_arr, int size) {
int count = 0;
for (int i = 0; i < size; i++) {
if (((const void **)test_arr)[i] != NULL) {
count++;
} else {
break;
}
}
return count;
}
| int main() {
const void* arr1[] = { (void*)1, (void*)5, (void*)7, NULL, (void*)10 };
const void* arr2[] = { (void*)2, (void*)9, NULL, (void*)11 };
const void* arr3[] = { (void*)11, (void*)15, (void*)5, (void*)8, NULL, (void*)8 };
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 2);
... | 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 11cc <func0+0x43>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
test %rax,%rax
je 11d6 <func0+0x4d>
ad... | 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_11CC
loc_11A8:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
test rax, rax
jz sho... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2 && *(_QWORD *)(8LL * i + a1); ++i )
++v3;
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cc
LAB_001011a8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
TEST RA... | int func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
local_c = 0;
while ((local_c < param_2 && (*(long *)(param_1 + (long)local_c * 8) != 0))) {
local_10 = local_10 + 1;
local_c = local_c + 1;
}
return local_10;
} |
5,005 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const void* test_arr, int size) {
int count = 0;
for (int i = 0; i < size; i++) {
if (((const void **)test_arr)[i] != NULL) {
count++;
} else {
break;
}
}
return count;
}
| int main() {
const void* arr1[] = { (void*)1, (void*)5, (void*)7, NULL, (void*)10 };
const void* arr2[] = { (void*)2, (void*)9, NULL, (void*)11 };
const void* arr3[] = { (void*)11, (void*)15, (void*)5, (void*)8, NULL, (void*)8 };
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 2);
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11b6 <func0+0x2d>
lea -0x1(%rsi),%esi
mov $0x0,%eax
jmp 119e <func0+0x15>
mov %rcx,%rax
mov %eax,%edx
cmpq $0x0,(%rdi,%rax,8)
je 11b3 <func0+0x2a>
lea 0x1(%rax),%edx
lea 0x1(%rax),%rcx
cmp %rsi,%rax
jne 119b <func0+0x12>
mov %edx,%eax
retq
mov ... | func0:
endbr64
test esi, esi
jle short loc_11AA
mov eax, 0
loc_1196:
cmp qword ptr [rdi], 0
jz short locret_11AF
add eax, 1
add rdi, 8
cmp esi, eax
jnz short loc_1196
mov eax, esi
retn
loc_11AA:
mov eax, 0
locret_11AF:
retn | long long func0(_QWORD *a1, int a2)
{
long long result; // rax
if ( a2 <= 0 )
return 0LL;
result = 0LL;
while ( *a1 )
{
result = (unsigned int)(result + 1);
++a1;
if ( a2 == (_DWORD)result )
return (unsigned int)a2;
}
return result;
} | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011aa
MOV EAX,0x0
LAB_00101196:
CMP qword ptr [RDI],0x0
JZ 0x001011af
ADD EAX,0x1
ADD RDI,0x8
CMP ESI,EAX
JNZ 0x00101196
MOV EAX,ESI
RET
LAB_001011aa:
MOV EAX,0x0
LAB_001011af:
RET | int func0(long *param_1,int param_2)
{
int iVar1;
if (param_2 < 1) {
iVar1 = 0;
}
else {
iVar1 = 0;
while (*param_1 != 0) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return param_2;
}
}
}
return iVar1;
} |
5,006 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const void* test_arr, int size) {
int count = 0;
for (int i = 0; i < size; i++) {
if (((const void **)test_arr)[i] != NULL) {
count++;
} else {
break;
}
}
return count;
}
| int main() {
const void* arr1[] = { (void*)1, (void*)5, (void*)7, NULL, (void*)10 };
const void* arr2[] = { (void*)2, (void*)9, NULL, (void*)11 };
const void* arr3[] = { (void*)11, (void*)15, (void*)5, (void*)8, NULL, (void*)8 };
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 2);
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 119e <func0+0x2e>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 1190 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 119a <func0+0x2a>
mov %rdx,%rax
cmpq $0x0,(%rdi,%rax,8)
mov %eax,%r8d
jne 1180 <func0+0x10>
mov %r8d,%eax
retq
xor ... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_12EB
jmp short locret_12F1
loc_12E0:
add eax, 1
add rdi, 8
cmp esi, eax
jz short locret_12F8
loc_12EB:
cmp qword ptr [rdi], 0
jnz short loc_12E0
locret_12F1:
retn
locret_12F8:
retn | long long func0(_QWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( !*a1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x001012eb
JMP 0x001012f1
LAB_001012e0:
ADD EAX,0x1
ADD RDI,0x8
CMP ESI,EAX
JZ 0x001012f8
LAB_001012eb:
CMP qword ptr [RDI],0x0
JNZ 0x001012e0
LAB_001012f1:
RET
LAB_001012f8:
RET | void func0(long *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (0 < param_2) {
while (*param_1 != 0) {
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
if (param_2 == iVar1) {
return;
}
}
}
return;
} |
5,007 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(const void* test_arr, int size) {
int count = 0;
for (int i = 0; i < size; i++) {
if (((const void **)test_arr)[i] != NULL) {
count++;
} else {
break;
}
}
return count;
}
| int main() {
const void* arr1[] = { (void*)1, (void*)5, (void*)7, NULL, (void*)10 };
const void* arr2[] = { (void*)2, (void*)9, NULL, (void*)11 };
const void* arr3[] = { (void*)11, (void*)15, (void*)5, (void*)8, NULL, (void*)8 };
assert(func0(arr1, 5) == 3);
assert(func0(arr2, 4) == 2);
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 12ce <func0+0x2e>
lea -0x1(%rsi),%ecx
xor %eax,%eax
jmp 12c0 <func0+0x20>
lea 0x1(%rax),%r8d
lea 0x1(%rax),%rdx
cmp %rcx,%rax
je 12ca <func0+0x2a>
mov %rdx,%rax
cmpq $0x0,(%rdi,%rax,8)
mov %eax,%r8d
jne 12b0 <func0+0x10>
mov %r8d,%eax
retq
xor ... | func0:
endbr64
xor eax, eax
test esi, esi
jg short loc_118B
retn
loc_1180:
add eax, 1
add rdi, 8
cmp esi, eax
jz short locret_1198
loc_118B:
cmp qword ptr [rdi], 0
jnz short loc_1180
retn
locret_1198:
retn | long long func0(_QWORD *a1, int a2)
{
long long result; // rax
result = 0LL;
if ( a2 > 0 )
{
do
{
if ( !*a1 )
break;
result = (unsigned int)(result + 1);
++a1;
}
while ( a2 != (_DWORD)result );
}
return result;
} | func0:
ENDBR64
XOR EAX,EAX
TEST ESI,ESI
JG 0x0010118b
RET
LAB_00101180:
ADD EAX,0x1
ADD RDI,0x8
CMP ESI,EAX
JZ 0x00101198
LAB_0010118b:
CMP qword ptr [RDI],0x0
JNZ 0x00101180
RET
LAB_00101198:
RET | void func0(long *param_1,int param_2)
{
int iVar1;
iVar1 = 0;
if (param_2 < 1) {
return;
}
do {
if (*param_1 == 0) {
return;
}
iVar1 = iVar1 + 1;
param_1 = param_1 + 1;
} while (param_2 != iVar1);
return;
} |
5,008 | func0 |
#include <assert.h>
| int func0(int n) {
return 4 * n * n - 3 * n;
}
| int main() {
assert(func0(3) == 27);
assert(func0(7) == 175);
assert(func0(10) == 370);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
imul %eax,%eax
lea 0x0(,%rax,4),%edx
mov -0x4(%rbp),%eax
mov %eax,%ecx
shl $0x2,%eax
sub %eax,%ecx
mov %ecx,%eax
add %edx,%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
imul eax, eax
lea ecx, ds:0[rax*4]
mov eax, [rbp+var_4]
mov edx, eax
shl eax, 2
sub edx, eax
lea eax, [rcx+rdx]
pop rbp
retn | long long func0(int a1)
{
return (unsigned int)(4 * a1 * a1 - 3 * a1);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
LEA ECX,[RAX*0x4]
MOV EAX,dword ptr [RBP + -0x4]
MOV EDX,EAX
SHL EAX,0x2
SUB EDX,EAX
LEA EAX,[RCX + RDX*0x1]
POP RBP
RET | int func0(int param_1)
{
return param_1 * param_1 * 4 + param_1 * -3;
} |
5,009 | func0 |
#include <assert.h>
| int func0(int n) {
return 4 * n * n - 3 * n;
}
| int main() {
assert(func0(3) == 27);
assert(func0(7) == 175);
assert(func0(10) == 370);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
imul %edi,%eax
lea 0x0(,%rdi,4),%edx
sub %edx,%edi
lea (%rdi,%rax,4),%eax
retq
| func0:
endbr64
mov eax, edi
imul eax, edi
lea edx, ds:0[rdi*4]
sub edi, edx
lea eax, [rdi+rax*4]
retn | long long func0(int a1)
{
return (unsigned int)(-3 * a1 + 4 * a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
IMUL EAX,EDI
LEA EDX,[RDI*0x4]
SUB EDI,EDX
LEA EAX,[RDI + RAX*0x4]
RET | int func0(int param_1)
{
return param_1 * -3 + param_1 * param_1 * 4;
} |
5,010 | func0 |
#include <assert.h>
| int func0(int n) {
return 4 * n * n - 3 * n;
}
| int main() {
assert(func0(3) == 27);
assert(func0(7) == 175);
assert(func0(10) == 370);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
lea 0x0(,%rdi,4),%edx
imul %edi,%eax
sub %edx,%edi
lea (%rdi,%rax,4),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
lea edx, ds:0[rdi*4]
imul eax, edi
sub edi, edx
lea eax, [rdi+rax*4]
retn | long long func0(int a1)
{
return (unsigned int)(-3 * a1 + 4 * a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDX,[RDI*0x4]
IMUL EAX,EDI
SUB EDI,EDX
LEA EAX,[RDI + RAX*0x4]
RET | int func0(int param_1)
{
return param_1 * -3 + param_1 * param_1 * 4;
} |
5,011 | func0 |
#include <assert.h>
| int func0(int n) {
return 4 * n * n - 3 * n;
}
| int main() {
assert(func0(3) == 27);
assert(func0(7) == 175);
assert(func0(10) == 370);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
lea 0x0(,%rdi,4),%edx
imul %edi,%eax
sub %edx,%edi
lea (%rdi,%rax,4),%eax
retq
nopw %cs:0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
lea edx, ds:0[rdi*4]
imul eax, edi
sub edi, edx
lea eax, [rdi+rax*4]
retn | long long func0(int a1)
{
return (unsigned int)(-3 * a1 + 4 * a1 * a1);
} | func0:
ENDBR64
MOV EAX,EDI
LEA EDX,[RDI*0x4]
IMUL EAX,EDI
SUB EDI,EDX
LEA EAX,[RDI + RAX*0x4]
RET | int func0(int param_1)
{
return param_1 * -3 + param_1 * param_1 * 4;
} |
5,012 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int dlist[], int size, int item, int *pos) {
*pos = 0;
bool found = false;
while (*pos < size && !found) {
if (dlist[*pos] == item) {
found = true;
} else {
(*pos)++;
}
}
return found;
}
| int main() {
int pos;
bool found;
int list1[] = {11, 23, 58, 31, 56, 77, 43, 12, 65, 19};
found = func0(list1, 10, 31, &pos);
assert(found == true && pos == 3);
int list2[] = {12, 32, 45, 62, 35, 47, 44, 61};
found = func0(list2, 8, 61, &pos);
assert(found == true && pos ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
mov -0x28(%rbp),%rax
movl $0x0,(%rax)
movb $0x0,-0x1(%rbp)
jmp 11c2 <func0+0x59>
mov -0x28(%rbp),%rax
mov (%rax),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
mov dword ptr [rax], 0
mov [rbp+var_1], 0
jmp short loc_11C2
loc_118F:
mov rax, [rbp+var_28]
mov eax, [rax]
cdqe
lea rdx, ... | long long func0(long long a1, int a2, int a3, int *a4)
{
unsigned __int8 v5; // [rsp+27h] [rbp-1h]
*a4 = 0;
v5 = 0;
while ( a2 > *a4 && v5 != 1 )
{
if ( a3 == *(_DWORD *)(4LL * *a4 + a1) )
v5 = 1;
else
++*a4;
}
return v5;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x0
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001011c2
LAB_0010118f:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,d... | char func0(long param_1,int param_2,int param_3,int *param_4)
{
int local_9;
*param_4 = 0;
local_9 = '\0';
while ((*param_4 < param_2 && (local_9 != '\x01'))) {
if (param_3 == *(int *)(param_1 + (long)*param_4 * 4)) {
local_9 = '\x01';
}
else {
*param_4 = *param_4 + 1;
}
}
re... |
5,013 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int dlist[], int size, int item, int *pos) {
*pos = 0;
bool found = false;
while (*pos < size && !found) {
if (dlist[*pos] == item) {
found = true;
} else {
(*pos)++;
}
}
return found;
}
| int main() {
int pos;
bool found;
int list1[] = {11, 23, 58, 31, 56, 77, 43, 12, 65, 19};
found = func0(list1, 10, 31, &pos);
assert(found == true && pos == 3);
int list2[] = {12, 32, 45, 62, 35, 47, 44, 61};
found = func0(list2, 8, 61, &pos);
assert(found == true && pos ... | O1 | c | func0:
endbr64
push %rbx
movl $0x0,(%rcx)
mov $0x0,%ebx
mov $0x1,%r11d
mov (%rcx),%eax
cmp %esi,%eax
setge %r9b
movslq %eax,%r8
lea (%rdi,%r8,4),%r10
mov %ebx,%r8d
test %r8b,%r8b
jne 11aa <func0+0x41>
test %r9b,%r9b
jne 11aa <func0+0x41>
mov %r11d,%r8d
cmp %edx,(%r10)
je 1191 ... | func0:
endbr64
push rbx
mov r11, rdi
mov eax, 0
mov ebx, 0
mov r10d, 1
jmp short loc_1186
loc_1183:
add eax, 1
loc_1186:
mov [rcx], eax
cmp eax, esi
setnl r8b
movsxd rdi, eax
lea r9, [r11+rdi*4]
mov edi, ebx
loc_1197:
test dil, dil
jnz short loc_11AB
test r8b, r8b... | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
int v5; // eax
unsigned int v6; // edi
v5 = 0;
LABEL_3:
*a4 = v5;
v6 = 0;
while ( !(_BYTE)v6 && v5 < a2 )
{
v6 = 1;
if ( *(_DWORD *)(a1 + 4LL * v5) != a3 )
{
++v5;
goto LABEL_3;
}
}
return v6;
} | func0:
ENDBR64
PUSH RBX
MOV R11,RDI
MOV EAX,0x0
MOV EBX,0x0
MOV R10D,0x1
JMP 0x00101186
LAB_00101183:
ADD EAX,0x1
LAB_00101186:
MOV dword ptr [RCX],EAX
CMP EAX,ESI
SETGE R8B
MOVSXD RDI,EAX
LEA R9,[R11 + RDI*0x4]
MOV EDI,EBX
LAB_00101197:
TEST DIL,DIL
JNZ 0x001011ab
TEST R8B,R8B
JNZ 0x001011ab
MOV EDI,R10D
CMP dword ptr... | char func0(long param_1,int param_2,int param_3,int *param_4)
{
int iVar1;
char cVar2;
iVar1 = 0;
do {
*param_4 = iVar1;
cVar2 = '\0';
do {
if ((cVar2 != '\0') || (param_2 <= iVar1)) {
return cVar2;
}
cVar2 = '\x01';
} while (*(int *)(param_1 + (long)iVar1 * 4) == p... |
5,014 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int dlist[], int size, int item, int *pos) {
*pos = 0;
bool found = false;
while (*pos < size && !found) {
if (dlist[*pos] == item) {
found = true;
} else {
(*pos)++;
}
}
return found;
}
| int main() {
int pos;
bool found;
int list1[] = {11, 23, 58, 31, 56, 77, 43, 12, 65, 19};
found = func0(list1, 10, 31, &pos);
assert(found == true && pos == 3);
int list2[] = {12, 32, 45, 62, 35, 47, 44, 61};
found = func0(list2, 8, 61, &pos);
assert(found == true && pos ... | O2 | c | func0:
endbr64
movl $0x0,(%rcx)
test %esi,%esi
jle 1381 <func0+0x31>
sub $0x1,%esi
mov $0x1,%eax
add $0x2,%rsi
nopw 0x0(%rax,%rax,1)
cmp %edx,-0x4(%rdi,%rax,4)
je 1388 <func0+0x38>
mov %eax,(%rcx)
add $0x1,%rax
cmp %rsi,%rax
jne 1370 <func0+0x20>
xor %eax,%eax
retq
nopl 0x0(%ra... | func0:
endbr64
mov dword ptr [rcx], 0
test esi, esi
jle short loc_1367
add esi, 1
mov eax, 1
loc_1356:
cmp [rdi+rax*4-4], edx
jz short loc_1370
mov [rcx], eax
add rax, 1
cmp rax, rsi
jnz short loc_1356
loc_1367:
xor eax, eax
retn
loc_1370:
mov eax, 1
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
long long v4; // rsi
long long v5; // rax
*a4 = 0;
if ( a2 <= 0 )
return 0LL;
v4 = (unsigned int)(a2 + 1);
v5 = 1LL;
while ( *(_DWORD *)(a1 + 4 * v5 - 4) != a3 )
{
*a4 = v5++;
if ( v5 == v4 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV dword ptr [RCX],0x0
TEST ESI,ESI
JLE 0x00101367
ADD ESI,0x1
MOV EAX,0x1
LAB_00101356:
CMP dword ptr [RDI + RAX*0x4 + -0x4],EDX
JZ 0x00101370
MOV dword ptr [RCX],EAX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101356
LAB_00101367:
XOR EAX,EAX
RET
LAB_00101370:
MOV EAX,0x1
RET | int8 func0(long param_1,int param_2,int param_3,int4 *param_4)
{
ulong uVar1;
*param_4 = 0;
if (0 < param_2) {
uVar1 = 1;
do {
if (*(int *)(param_1 + -4 + uVar1 * 4) == param_3) {
return 1;
}
*param_4 = (int)uVar1;
uVar1 = uVar1 + 1;
} while (uVar1 != param_2 + 1);
... |
5,015 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int dlist[], int size, int item, int *pos) {
*pos = 0;
bool found = false;
while (*pos < size && !found) {
if (dlist[*pos] == item) {
found = true;
} else {
(*pos)++;
}
}
return found;
}
| int main() {
int pos;
bool found;
int list1[] = {11, 23, 58, 31, 56, 77, 43, 12, 65, 19};
found = func0(list1, 10, 31, &pos);
assert(found == true && pos == 3);
int list2[] = {12, 32, 45, 62, 35, 47, 44, 61};
found = func0(list2, 8, 61, &pos);
assert(found == true && pos ... | O3 | c | func0:
endbr64
movl $0x0,(%rcx)
test %esi,%esi
jle 1301 <func0+0x31>
sub $0x1,%esi
mov $0x1,%eax
add $0x2,%rsi
nopw 0x0(%rax,%rax,1)
cmp %edx,-0x4(%rdi,%rax,4)
je 1308 <func0+0x38>
mov %eax,(%rcx)
add $0x1,%rax
cmp %rsi,%rax
jne 12f0 <func0+0x20>
xor %eax,%eax
retq
nopl 0x0(%ra... | func0:
endbr64
xor eax, eax
loc_1146:
mov [rcx], eax
cmp esi, eax
jle short loc_1160
add rax, 1
cmp edx, [rdi+rax*4-4]
jnz short loc_1146
mov eax, 1
retn
loc_1160:
xor eax, eax
retn | long long func0(long long a1, int a2, int a3, _DWORD *a4)
{
long long v4; // rax
v4 = 0LL;
while ( 1 )
{
*a4 = v4;
if ( a2 <= (int)v4 )
break;
++v4;
if ( a3 == *(_DWORD *)(a1 + 4 * v4 - 4) )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
XOR EAX,EAX
LAB_00101146:
MOV dword ptr [RCX],EAX
CMP ESI,EAX
JLE 0x00101160
ADD RAX,0x1
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x4]
JNZ 0x00101146
MOV EAX,0x1
RET
LAB_00101160:
XOR EAX,EAX
RET | int8 func0(long param_1,int param_2,int param_3,int *param_4)
{
long lVar1;
lVar1 = 0;
do {
*param_4 = (int)lVar1;
if (param_2 <= (int)lVar1) {
return 0;
}
lVar1 = lVar1 + 1;
} while (param_3 != *(int *)(param_1 + -4 + lVar1 * 4));
return 1;
} |
5,016 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
| bool func0(int *test_list, int length) {
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (test_list[i] == test_list[j]) {
return false;
}
}
}
return true;
}
| int main() {
int list1[] = {1, 2, 3};
int list2[] = {1, 2, 1, 2};
int list3[] = {1, 2, 3, 4, 5};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == true);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == false);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == t... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11c7 <func0+0x5e>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%ra... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
jmp short loc_11D3
loc_1181:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11C7
loc_118C:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [r... | long long func0(long long a1, int a2)
{
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * j + a1) )
return 0LL;
}
}
return 1LL;
} | 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
JMP 0x001011d3
LAB_00101181:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011c7
LAB_0010118c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV... | int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = 0;
do {
local_c = local_10;
if (param_2 + -1 <= local_10) {
return 1;
}
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_10 * 4) == *(int *)(param_1 + (long)local_c *... |
5,017 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
| bool func0(int *test_list, int length) {
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (test_list[i] == test_list[j]) {
return false;
}
}
}
return true;
}
| int main() {
int list1[] = {1, 2, 3};
int list2[] = {1, 2, 1, 2};
int list3[] = {1, 2, 3, 4, 5};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == true);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == false);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == t... | O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11a6 <func0+0x3d>
lea -0x2(%rsi),%r8d
add $0x2,%r8
mov $0x1,%ecx
cmp %ecx,%esi
jle 1197 <func0+0x2e>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
cmp (%rdi,%rax,4),%edx
je 11ac <func0+0x43>
add $0x1,%rax
cmp %eax,%esi
jg 118a <func0+0x21>
add $... | func0:
endbr64
cmp esi, 1
jle short loc_11A6
lea r8d, [rsi-2]
add r8, 2
mov ecx, 1
loc_117F:
cmp esi, ecx
jle short loc_1197
mov edx, [rdi+rcx*4-4]
mov rax, rcx
loc_118A:
cmp edx, [rdi+rax*4]
jz short loc_11AC
add rax, 1
cmp esi, eax
jg short loc_118A
loc_1197:
... | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( a2 <= (int)v2 )
{
LABEL_7:
if ( ++v2 == (unsigned int)(a2 - 2) + 2LL )
return 1LL;
}
v3 = v2;
while ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v3) ... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011a6
LEA R8D,[RSI + -0x2]
ADD R8,0x2
MOV ECX,0x1
LAB_0010117f:
CMP ESI,ECX
JLE 0x00101197
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
LAB_0010118a:
CMP EDX,dword ptr [RDI + RAX*0x4]
JZ 0x001011ac
ADD RAX,0x1
CMP ESI,EAX
JG 0x0010118a
LAB_00101197:
ADD RCX,0x1
CMP RCX,R8
JNZ... | int8 func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
if (param_2 < 2) {
return 1;
}
lVar2 = 1;
do {
if ((int)lVar2 < param_2) {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) == *(int *)(param_1 + lVar1 * 4)) {
return 0;
}
lVar1... |
5,018 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
| bool func0(int *test_list, int length) {
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (test_list[i] == test_list[j]) {
return false;
}
}
}
return true;
}
| int main() {
int list1[] = {1, 2, 3};
int list2[] = {1, 2, 1, 2};
int list3[] = {1, 2, 3, 4, 5};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == true);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == false);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == t... | O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 12c9 <func0+0x49>
lea -0x2(%rsi),%r8d
mov $0x1,%ecx
add $0x2,%r8
cmp %ecx,%esi
jle 12c0 <func0+0x40>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12b0 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 12c0 <func0+0x40>
cmp (%r... | func0:
endbr64
cmp esi, 1
jle short loc_12C9
lea r8d, [rsi-2]
mov ecx, 1
add r8, 2
loc_1296:
cmp esi, ecx
jle short loc_12C0
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_12B0
loc_12A8:
add rax, 1
cmp esi, eax
jle short loc_12C0
loc_12B0:
cmp edx, [rdi+rax*4]
... | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( a2 <= (int)v2 )
{
LABEL_8:
if ( ++v2 == (unsigned int)(a2 - 2) + 2LL )
return 1LL;
}
v3 = v2;
while ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v3) ... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012c9
LEA R8D,[RSI + -0x2]
MOV ECX,0x1
ADD R8,0x2
LAB_00101296:
CMP ESI,ECX
JLE 0x001012c0
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x001012b0
LAB_001012a8:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x001012c0
LAB_001012b0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x001012a8
XOR EAX,E... | int8 func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
if (1 < param_2) {
lVar2 = 1;
do {
if ((int)lVar2 < param_2) {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + -4 + lVar2 * 4) == *(int *)(param_1 + lVar1 * 4)) {
return 0;
}
lVar1... |
5,019 | func0 |
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
| bool func0(int *test_list, int length) {
for (int i = 0; i < length - 1; i++) {
for (int j = i + 1; j < length; j++) {
if (test_list[i] == test_list[j]) {
return false;
}
}
}
return true;
}
| int main() {
int list1[] = {1, 2, 3};
int list2[] = {1, 2, 1, 2};
int list3[] = {1, 2, 3, 4, 5};
assert(func0(list1, sizeof(list1) / sizeof(list1[0])) == true);
assert(func0(list2, sizeof(list2) / sizeof(list2[0])) == false);
assert(func0(list3, sizeof(list3) / sizeof(list3[0])) == t... | O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 12c9 <func0+0x49>
lea -0x2(%rsi),%r8d
mov $0x1,%ecx
add $0x2,%r8
cmp %ecx,%esi
jle 12c0 <func0+0x40>
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
jmp 12b0 <func0+0x30>
nopl 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %eax,%esi
jle 12c0 <func0+0x40>
cmp (%r... | func0:
endbr64
cmp esi, 1
jle short loc_1179
mov r8d, esi
mov ecx, 1
loc_1151:
cmp esi, ecx
jle short loc_1170
mov edx, [rdi+rcx*4-4]
mov rax, rcx
jmp short loc_1168
loc_1160:
add rax, 1
cmp esi, eax
jle short loc_1170
loc_1168:
cmp edx, [rdi+rax*4]
jnz short loc_... | long long func0(long long a1, int a2)
{
long long v2; // rcx
long long v3; // rax
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( a2 <= (int)v2 )
{
LABEL_8:
if ( ++v2 == a2 )
return 1LL;
}
v3 = v2;
while ( *(_DWORD *)(a1 + 4 * v2 - 4) != *(_DWORD *)(a1 + 4 * v3) )
{
if ( a2 <= (int)... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x00101179
MOV R8D,ESI
MOV ECX,0x1
LAB_00101151:
CMP ESI,ECX
JLE 0x00101170
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
JMP 0x00101168
LAB_00101160:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101170
LAB_00101168:
CMP EDX,dword ptr [RDI + RAX*0x4]
JNZ 0x00101160
XOR EAX,EAX
RET
LAB_00101170:... | int8 func0(long param_1,uint param_2)
{
ulong uVar1;
ulong uVar2;
if (1 < (int)param_2) {
uVar2 = 1;
do {
if ((int)uVar2 < (int)param_2) {
uVar1 = uVar2;
do {
if (*(int *)(param_1 + -4 + uVar2 * 4) == *(int *)(param_1 + uVar1 * 4)) {
return 0;
}
... |
5,020 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums1[], int nums2[], int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] - nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3}, nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2}, nums2b[] = {3, 4};
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
assert(func0(nums1a, nums2a, 3, result1)[0] == -3 && func0(nums1a, nums2a, 3, result1)[1] == -3 && func... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %rcx,-0x30(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11d3 <func0+0x6a>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%ecx
mov -0x4(%rbp),%... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_30], rcx
mov [rbp+var_4], 0
jmp short loc_11D2
loc_1189:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov ecx, [rax]... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a3; ++i )
*(_DWORD *)(4LL * i + a4) = *(_DWORD *)(4LL * i + a1) - *(_DWORD *)(4LL * i + a2);
return a4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV qword ptr [RBP + -0x30],RCX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d2
LAB_00101189:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RD... | long func0(long param_1,long param_2,int param_3,long param_4)
{
int4 local_c;
for (local_c = 0; local_c < param_3; local_c = local_c + 1) {
*(int *)(param_4 + (long)local_c * 4) =
*(int *)(param_1 + (long)local_c * 4) - *(int *)(param_2 + (long)local_c * 4);
}
return param_4;
} |
5,021 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums1[], int nums2[], int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] - nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3}, nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2}, nums2b[] = {3, 4};
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
assert(func0(nums1a, nums2a, 3, result1)[0] == -3 && func0(nums1a, nums2a, 3, result1)[1] == -3 && func... | O1 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1194 <func0+0x2b>
lea -0x1(%rdx),%ecx
mov $0x0,%edx
mov (%rdi,%rdx,4),%r8d
sub (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 117c <func0+0x13>
retq
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_1191
mov edx, edx
mov r8d, 0
loc_117C:
mov r9d, [rdi+r8*4]
sub r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp r8, rdx
jnz short loc_117C
locret_1191:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) - *(_DWORD *)(a2 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x00101191
MOV EDX,EDX
MOV R8D,0x0
LAB_0010117c:
MOV R9D,dword ptr [RDI + R8*0x4]
SUB R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP R8,RDX
JNZ 0x0010117c
LAB_00101191:
RET | void func0(long param_1,long param_2,uint param_3,long param_4)
{
ulong uVar1;
if (0 < (int)param_3) {
uVar1 = 0;
do {
*(int *)(param_4 + uVar1 * 4) = *(int *)(param_1 + uVar1 * 4) - *(int *)(param_2 + uVar1 * 4);
uVar1 = uVar1 + 1;
} while (uVar1 != param_3);
}
return;
} |
5,022 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums1[], int nums2[], int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] - nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3}, nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2}, nums2b[] = {3, 4};
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
assert(func0(nums1a, nums2a, 3, result1)[0] == -3 && func0(nums1a, nums2a, 3, result1)[1] == -3 && func... | O2 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1168 <func0+0x28>
lea -0x1(%rdx),%ecx
xor %edx,%edx
mov (%rdi,%rdx,4),%r8d
sub (%rsi,%rdx,4),%r8d
mov %r8d,(%rax,%rdx,4)
mov %rdx,%r8
add $0x1,%rdx
cmp %rcx,%r8
jne 1150 <func0+0x10>
retq
nopl 0x0(%rax)
| func0:
endbr64
mov rax, rcx
test edx, edx
jle short locret_116D
movsxd rdx, edx
xor r8d, r8d
nop dword ptr [rax+00000000h]
loc_1158:
mov r9d, [rdi+r8*4]
sub r9d, [rsi+r8*4]
mov [rax+r8*4], r9d
add r8, 1
cmp rdx, r8
jnz short loc_1158
locret_116D:
retn | long long func0(long long a1, long long a2, int a3, long long a4)
{
long long result; // rax
long long i; // r8
result = a4;
if ( a3 > 0 )
{
for ( i = 0LL; i != a3; ++i )
*(_DWORD *)(a4 + 4 * i) = *(_DWORD *)(a1 + 4 * i) - *(_DWORD *)(a2 + 4 * i);
}
return result;
} | func0:
ENDBR64
MOV RAX,RCX
TEST EDX,EDX
JLE 0x0010116d
MOVSXD RDX,EDX
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101158:
MOV R9D,dword ptr [RDI + R8*0x4]
SUB R9D,dword ptr [RSI + R8*0x4]
MOV dword ptr [RAX + R8*0x4],R9D
ADD R8,0x1
CMP RDX,R8
JNZ 0x00101158
LAB_0010116d:
RET | void func0(long param_1,long param_2,int param_3,long param_4)
{
long lVar1;
if (0 < param_3) {
lVar1 = 0;
do {
*(int *)(param_4 + lVar1 * 4) = *(int *)(param_1 + lVar1 * 4) - *(int *)(param_2 + lVar1 * 4);
lVar1 = lVar1 + 1;
} while (param_3 != lVar1);
}
return;
} |
5,023 | func0 |
#include <stdio.h>
#include <assert.h>
| int* func0(int nums1[], int nums2[], int size, int result[]) {
for (int i = 0; i < size; i++) {
result[i] = nums1[i] - nums2[i];
}
return result;
}
| int main() {
int result1[3], result2[2], result3[2];
int nums1a[] = {1, 2, 3}, nums2a[] = {4, 5, 6};
int nums1b[] = {1, 2}, nums2b[] = {3, 4};
int nums1c[] = {90, 120}, nums2c[] = {50, 70};
assert(func0(nums1a, nums2a, 3, result1)[0] == -3 && func0(nums1a, nums2a, 3, result1)[1] == -3 && func... | O3 | c | func0:
endbr64
mov %rcx,%rax
test %edx,%edx
jle 1215 <func0+0xd5>
lea 0xf(%rcx),%rcx
lea -0x1(%rdx),%r8d
mov %rcx,%r9
sub %rdi,%r9
cmp $0x1e,%r9
seta %r10b
cmp $0x2,%r8d
seta %r9b
test %r9b,%r10b
je 11f8 <func0+0xb8>
sub %rsi,%rcx
cmp $0x1e,%rcx
jbe 11f8 <func0+0xb8>
mov ... | func0:
endbr64
movsxd rax, edx
mov r8, rsi
test eax, eax
jle loc_1201
cmp eax, 1
jz loc_1208
lea rsi, [rdi+4]
mov rdx, rcx
sub rdx, rsi
cmp rdx, 8
jbe loc_1208
lea rsi, [r8+4]
mov rdx, rcx
sub rdx, rsi
cmp rdx, 8
jbe loc_1208
lea edx, [rax-1]
mov r9d,... | long long func0(long long a1, long long a2, int a3, long long a4)
{
int v6; // r9d
long long v7; // rdx
signed int v8; // edx
unsigned int v9; // esi
long long v11; // rax
if ( a3 <= 0 )
return a4;
if ( a3 != 1 && (unsigned long long)(a4 - (a1 + 4)) > 8 && (unsigned long long)(a4 - (a2 + 4)) > 8 )
... | func0:
ENDBR64
MOVSXD RAX,EDX
MOV R8,RSI
TEST EAX,EAX
JLE 0x00101201
CMP EAX,0x1
JZ 0x00101208
LEA RSI,[RDI + 0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x8
JBE 0x00101208
LEA RSI,[R8 + 0x4]
MOV RDX,RCX
SUB RDX,RSI
CMP RDX,0x8
JBE 0x00101208
LEA EDX,[RAX + -0x1]
MOV R9D,EAX
CMP EDX,0x2
JBE 0x0010122f
MOV ESI,EAX
XOR EDX,EDX
... | long func0(long param_1,long param_2,uint param_3,long param_4)
{
int *piVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
ulong uVar12;
uint uVar13;
long lVar14;
if ((int)param_3 < 1) {
return param_4;
}
... |
5,024 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i, temp, count;
for (i = 0; i < 10; i++) {
temp = n;
count = 0;
while (temp > 0) {
if (temp % 10 == i) {
count++;
}
if (count > i) {
return false;
}
temp /= 10;... | int main() {
assert(func0(1234) == true);
assert(func0(51241) == false);
assert(func0(321) == true);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
jmp 11d6 <func0+0x8d>
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cc <func0+0x83>
mov -0x8(%rbp),%ecx
movslq %ecx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%edx
sar ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
jmp short loc_11D6
loc_115D:
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
mov [rbp+var_4], 0
jmp short loc_11CC
loc_116C:
mov ecx, [rbp+var_8]
movsxd rax, ecx
imul rax, 66666667h
shr rax, 20h
mov ... | long long func0(int a1)
{
int i; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
int v4; // [rsp+10h] [rbp-4h]
for ( i = 0; i <= 9; ++i )
{
v3 = a1;
v4 = 0;
while ( v3 > 0 )
{
if ( i == v3 % 10 )
++v4;
if ( v4 > i )
return 0LL;
v3 /= 10;
}
}
return... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001011d6
LAB_0010115d:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cc
LAB_0010116c:
MOV ECX,dword ptr [RBP + -0x8]
MOVSXD RAX,ECX
IMUL RAX,RAX,0x66666667... | int8 func0(int param_1)
{
int local_14;
int local_10;
int local_c;
local_14 = 0;
do {
if (9 < local_14) {
return 1;
}
local_c = 0;
for (local_10 = param_1; 0 < local_10; local_10 = local_10 / 10) {
if (local_14 == local_10 % 10) {
local_c = local_c + 1;
}
if... |
5,025 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i, temp, count;
for (i = 0; i < 10; i++) {
temp = n;
count = 0;
while (temp > 0) {
if (temp % 10 == i) {
count++;
}
if (count > i) {
return false;
}
temp /= 10;... | int main() {
assert(func0(1234) == true);
assert(func0(51241) == false);
assert(func0(321) == true);
return 0;
}
| O1 | c | func0:
endbr64
mov $0x0,%esi
mov %edi,%r8d
mov %r8d,%edx
mov $0x0,%ecx
test %edi,%edi
jg 1165 <func0+0x1c>
jmp 11b4 <func0+0x6b>
mov %eax,%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edx,%r9d
sar $0x1f,%r9d
sub %r9d,%eax
lea (%rax,%rax,4),%eax
add %eax... | func0:
endbr64
mov esi, 0
loc_1152:
mov edx, edi
mov ecx, 0
test edi, edi
jg short loc_1161
jmp short loc_11B0
loc_115F:
mov edx, eax
loc_1161:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov r8d, edx
sar r8d, 1Fh
sub eax, r8d
lea eax, [rax+rax*4]
add eax, ea... | long long func0(int a1)
{
int v1; // esi
int v2; // edx
int v3; // ecx
v1 = 0;
while ( 1 )
{
v2 = a1;
v3 = 0;
if ( a1 > 0 )
break;
LABEL_7:
if ( ++v1 == 10 )
return 1LL;
}
while ( 1 )
{
v3 += v2 % 10 == v1;
if ( v3 > v1 )
return 0LL;
if ( v2 <= 9 )
... | func0:
ENDBR64
MOV ESI,0x0
LAB_00101152:
MOV EDX,EDI
MOV ECX,0x0
TEST EDI,EDI
JG 0x00101161
JMP 0x001011b0
LAB_0010115f:
MOV EDX,EAX
LAB_00101161:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV R8D,EDX
SAR R8D,0x1f
SUB EAX,R8D
LEA EAX,[RAX + RAX*0x4]
ADD EAX,EAX
MOV R8D,EDX
SUB R8D,EAX
CMP R8D,ESI
SETZ AL
MOVZ... | int8 func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = 0;
do {
iVar2 = 0;
iVar3 = param_1;
if (0 < param_1) {
do {
iVar2 = iVar2 + (uint)(iVar3 % 10 == iVar4);
if (iVar4 < iVar2) {
return 0;
}
bVar1 = 9 < iVar3;
... |
5,026 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i, temp, count;
for (i = 0; i < 10; i++) {
temp = n;
count = 0;
while (temp > 0) {
if (temp % 10 == i) {
count++;
}
if (count > i) {
return false;
}
temp /= 10;... | int main() {
assert(func0(1234) == true);
assert(func0(51241) == false);
assert(func0(321) == true);
return 0;
}
| O2 | c | func0:
endbr64
xor %r8d,%r8d
mov $0xcccccccd,%r9d
mov %edi,%ecx
xor %esi,%esi
test %edi,%edi
jg 12f7 <func0+0x27>
jmp 1320 <func0+0x50>
nopw 0x0(%rax,%rax,1)
cmp $0x9,%ecx
jle 1320 <func0+0x50>
mov %eax,%ecx
mov %ecx,%eax
mov %ecx,%r10d
imul %r9,%rax
shr $0x23,%rax
lea (%ra... | func0:
endbr64
xor r8d, r8d
mov r10d, 0CCCCCCCDh
loc_11FD:
mov ecx, edi
xor esi, esi
test edi, edi
jg short loc_1217
jmp short loc_1240
loc_1210:
cmp ecx, 9
jle short loc_1240
mov ecx, eax
loc_1217:
mov eax, ecx
mov r9d, ecx
imul rax, r10
shr rax, 23h
lea edx, ... | long long func0(int a1)
{
int v1; // r8d
int v2; // ecx
int v3; // esi
v1 = 0;
while ( 1 )
{
v2 = a1;
v3 = 0;
if ( a1 > 0 )
break;
LABEL_8:
if ( ++v1 == 10 )
return 1LL;
}
while ( 1 )
{
v3 += v2 % 0xAu == v1;
if ( v3 > v1 )
return 0LL;
if ( v2 <= 9 )
... | func0:
ENDBR64
XOR R8D,R8D
MOV R10D,0xcccccccd
LAB_001011fd:
MOV ECX,EDI
XOR ESI,ESI
TEST EDI,EDI
JG 0x00101217
JMP 0x00101240
LAB_00101210:
CMP ECX,0x9
JLE 0x00101240
MOV ECX,EAX
LAB_00101217:
MOV EAX,ECX
MOV R9D,ECX
IMUL RAX,R10
SHR RAX,0x23
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
SUB R9D,EDX
XOR EDX,EDX
CMP R9D,R8D
SETZ... | int8 func0(uint param_1)
{
bool bVar1;
uint uVar2;
int iVar3;
uint uVar4;
uVar4 = 0;
do {
iVar3 = 0;
uVar2 = param_1;
if (0 < (int)param_1) {
do {
iVar3 = iVar3 + (uint)(uVar2 % 10 == uVar4);
if ((int)uVar4 < iVar3) {
return 0;
}
bVar1 = 9 < (i... |
5,027 | func0 |
#include <stdbool.h>
#include <assert.h>
| bool func0(int n) {
int i, temp, count;
for (i = 0; i < 10; i++) {
temp = n;
count = 0;
while (temp > 0) {
if (temp % 10 == i) {
count++;
}
if (count > i) {
return false;
}
temp /= 10;... | int main() {
assert(func0(1234) == true);
assert(func0(51241) == false);
assert(func0(321) == true);
return 0;
}
| O3 | c | func0:
endbr64
xor %r8d,%r8d
mov $0xcccccccd,%r9d
mov %edi,%ecx
xor %esi,%esi
test %edi,%edi
jg 1207 <func0+0x27>
jmp 1230 <func0+0x50>
nopw 0x0(%rax,%rax,1)
cmp $0x9,%ecx
jle 1230 <func0+0x50>
mov %eax,%ecx
mov %ecx,%eax
mov %ecx,%r10d
imul %r9,%rax
shr $0x23,%rax
lea (%ra... | func0:
endbr64
xor r8d, r8d
loc_11C7:
test edi, edi
jle short loc_1220
mov r10d, 0CCCCCCCDh
loc_11D1:
mov ecx, edi
xor esi, esi
jmp short loc_11E7
loc_11E0:
cmp ecx, 9
jle short loc_1210
mov ecx, eax
loc_11E7:
mov eax, ecx
mov r9d, ecx
imul rax, r10
shr rax, 23h
lea... | long long func0(int a1)
{
int v1; // r8d
int v2; // ecx
int v3; // esi
v1 = 0;
while ( a1 <= 0 )
{
if ( ++v1 == 10 )
return 1LL;
}
do
{
v2 = a1;
v3 = 0;
while ( 1 )
{
v3 += v2 % 0xAu == v1;
if ( v1 < v3 )
return 0LL;
if ( v2 <= 9 )
break;
... | func0:
ENDBR64
XOR R8D,R8D
LAB_001011c7:
TEST EDI,EDI
JLE 0x00101220
MOV R10D,0xcccccccd
LAB_001011d1:
MOV ECX,EDI
XOR ESI,ESI
JMP 0x001011e7
LAB_001011e0:
CMP ECX,0x9
JLE 0x00101210
MOV ECX,EAX
LAB_001011e7:
MOV EAX,ECX
MOV R9D,ECX
IMUL RAX,R10
SHR RAX,0x23
LEA EDX,[RAX + RAX*0x4]
ADD EDX,EDX
SUB R9D,EDX
XOR EDX,EDX
C... | int8 func0(uint param_1)
{
bool bVar1;
uint uVar2;
int iVar3;
uint uVar4;
uVar4 = 0;
do {
if (0 < (int)param_1) {
do {
iVar3 = 0;
uVar2 = param_1;
do {
iVar3 = iVar3 + (uint)(uVar2 % 10 == uVar4);
if ((int)uVar4 < iVar3) {
return 0;
... |
5,028 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int int_val;
const char* str_val;
} value;
} Element;
| bool func0(Element list[], int size, Element element) {
for(int i = 0; i < size; i++) {
if(list[i].type != element.type){
return false;
}
if(element.type == INT_TYPE){
if(list[i].value.int_val != element.value.int_val){
return false;
... | int main() {
Element list1[] = {
{STRING_TYPE, .value.str_val = "green"},
{STRING_TYPE, .value.str_val = "orange"},
{STRING_TYPE, .value.str_val = "black"},
{STRING_TYPE, .value.str_val = "white"}
};
Element element1 = {STRING_TYPE, .value.str_val = "blue"};
asser... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,%eax
mov %rcx,%rdx
mov %rax,-0x30(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x0,-0x4(%rbp)
jmpq 1240 <func0+0xb7>
mov -0x4(%rbp),%eax
cltq
shl $0x4,%rax
mov %rax,%rdx
mov -0x18(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov eax, edx
mov rdx, rcx
mov [rbp+var_30], rax
mov [rbp+s2], rdx
mov [rbp+var_4], 0
jmp loc_1240
loc_11B5:
mov eax, [rbp+var_4]
cdqe
shl rax, 4
mov rdx, rax
mov rax, ... | long long func0(long long a1, int a2, int a3, const char *a4)
{
int i; // [rsp+2Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(16LL * i + a1) != a3 )
return 0LL;
if ( a3 )
{
if ( a3 == 1 && strcmp(*(const char **)(16LL * i + a1 + 8), a4) )
return 0LL;
}
else i... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV EAX,EDX
MOV RDX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101240
LAB_001011b5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x4
MOV RDX,RAX... | int8 func0(long param_1,int param_2,int param_3,char *param_4)
{
int iVar1;
int local_30;
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 0x10) != param_3) break;
if (param_3 == 0) {
local_30 = (int)param_4;... |
5,029 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int int_val;
const char* str_val;
} value;
} Element;
| bool func0(Element list[], int size, Element element) {
for(int i = 0; i < size; i++) {
if(list[i].type != element.type){
return false;
}
if(element.type == INT_TYPE){
if(list[i].value.int_val != element.value.int_val){
return false;
... | int main() {
Element list1[] = {
{STRING_TYPE, .value.str_val = "green"},
{STRING_TYPE, .value.str_val = "orange"},
{STRING_TYPE, .value.str_val = "black"},
{STRING_TYPE, .value.str_val = "white"}
};
Element element1 = {STRING_TYPE, .value.str_val = "blue"};
asser... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11f3 <func0+0x6a>
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rcx,%r13
mov %edx,%ebp
mov %rcx,%r14
lea 0x8(%rdi),%rbx
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x18(%rdi,%rax,1),%r12
jmp 11c1 <func0+0x38>
cmp $0x1,%ebp
je 11d6 <func0... | func0:
endbr64
test esi, esi
jle short loc_11F3
push r14
push r13
push r12
push rbp
push rbx
mov r14, rcx
mov ebp, edx
mov r13d, ecx
lea rbx, [rdi+8]
lea eax, [rsi-1]
shl rax, 4
lea r12, [rdi+rax+18h]
jmp short loc_11C1
loc_11B3:
cmp ebp, 1
jz short loc_11D... | long long func0(long long a1, int a2, int a3, long long a4)
{
int v6; // r13d
_QWORD *v7; // rbx
if ( a2 <= 0 )
return 1LL;
v6 = a4;
v7 = (_QWORD *)(a1 + 8);
while ( *((_DWORD *)v7 - 2) == a3 )
{
if ( a3 )
{
if ( a3 == 1 && (unsigned int)strcmp(*v7, a4) )
return 0LL;
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011f3
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RCX
MOV EBP,EDX
MOV R13D,ECX
LEA RBX,[RDI + 0x8]
LEA EAX,[RSI + -0x1]
SHL RAX,0x4
LEA R12,[RDI + RAX*0x1 + 0x18]
JMP 0x001011c1
LAB_001011b3:
CMP EBP,0x1
JZ 0x001011d6
LAB_001011b8:
ADD RBX,0x10
CMP RBX,R12
JZ 0x001011ec
LAB... | int8 func0(long param_1,int param_2,int param_3,char *param_4)
{
int iVar1;
int *piVar2;
if (param_2 < 1) {
return 1;
}
piVar2 = (int *)(param_1 + 8);
do {
if (piVar2[-2] != param_3) {
return 0;
}
if (param_3 == 0) {
if (*piVar2 != (int)param_4) {
return 0;
}
... |
5,030 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int int_val;
const char* str_val;
} value;
} Element;
| bool func0(Element list[], int size, Element element) {
for(int i = 0; i < size; i++) {
if(list[i].type != element.type){
return false;
}
if(element.type == INT_TYPE){
if(list[i].value.int_val != element.value.int_val){
return false;
... | int main() {
Element list1[] = {
{STRING_TYPE, .value.str_val = "green"},
{STRING_TYPE, .value.str_val = "orange"},
{STRING_TYPE, .value.str_val = "black"},
{STRING_TYPE, .value.str_val = "white"}
};
Element element1 = {STRING_TYPE, .value.str_val = "blue"};
asser... | O2 | c | func0:
endbr64
test %esi,%esi
jle 13ee <func0+0x7e>
lea -0x1(%rsi),%eax
push %r14
mov %rcx,%r14
shl $0x4,%rax
push %r13
mov %ecx,%r13d
push %r12
lea 0x18(%rdi,%rax,1),%r12
push %rbp
mov %edx,%ebp
push %rbx
lea 0x8(%rdi),%rbx
jmp 13ae <func0+0x3e>
nopw 0x0(%rax,%rax,1)
cmp %r1... | func0:
endbr64
test esi, esi
jle short loc_13EE
lea eax, [rsi-1]
push r14
mov r14, rcx
shl rax, 4
push r13
mov r13d, ecx
push r12
lea r12, [rdi+rax+18h]
push rbp
mov ebp, edx
push rbx
lea rbx, [rdi+8]
jmp short loc_13AE
loc_13A0:
cmp [rbx], r13d
jnz short lo... | long long func0(long long a1, int a2, int a3, long long a4)
{
int v5; // r13d
_QWORD *v7; // rbx
if ( a2 <= 0 )
return 1LL;
v5 = a4;
v7 = (_QWORD *)(a1 + 8);
do
{
if ( *((_DWORD *)v7 - 2) != a3 )
return 0LL;
if ( a3 )
{
if ( a3 == 1 && (unsigned int)strcmp(*v7, a4) )
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013ee
LEA EAX,[RSI + -0x1]
PUSH R14
MOV R14,RCX
SHL RAX,0x4
PUSH R13
MOV R13D,ECX
PUSH R12
LEA R12,[RDI + RAX*0x1 + 0x18]
PUSH RBP
MOV EBP,EDX
PUSH RBX
LEA RBX,[RDI + 0x8]
JMP 0x001013ae
LAB_001013a0:
CMP dword ptr [RBX],R13D
JNZ 0x001013cb
LAB_001013a5:
ADD RBX,0x10
CMP RBX,R12
JZ ... | int8 func0(long param_1,int param_2,int param_3,char *param_4)
{
int iVar1;
int *piVar2;
if (param_2 < 1) {
return 1;
}
piVar2 = (int *)(param_1 + 8);
do {
if (piVar2[-2] != param_3) {
return 0;
}
if (param_3 == 0) {
if (*piVar2 != (int)param_4) {
return 0;
}
... |
5,031 | func0 |
#include <assert.h>
#include <stdbool.h>
#include <string.h>
typedef enum { INT_TYPE, STRING_TYPE } ElementType;
typedef struct {
ElementType type;
union {
int int_val;
const char* str_val;
} value;
} Element;
| bool func0(Element list[], int size, Element element) {
for(int i = 0; i < size; i++) {
if(list[i].type != element.type){
return false;
}
if(element.type == INT_TYPE){
if(list[i].value.int_val != element.value.int_val){
return false;
... | int main() {
Element list1[] = {
{STRING_TYPE, .value.str_val = "green"},
{STRING_TYPE, .value.str_val = "orange"},
{STRING_TYPE, .value.str_val = "black"},
{STRING_TYPE, .value.str_val = "white"}
};
Element element1 = {STRING_TYPE, .value.str_val = "blue"};
asser... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1418 <func0+0xa8>
push %r12
push %rbp
mov %rcx,%rbp
push %rbx
cmp $0x1,%edx
je 13e0 <func0+0x70>
lea -0x1(%rsi),%eax
shl $0x4,%rax
lea 0x10(%rdi,%rax,1),%rax
test %edx,%edx
je 13c6 <func0+0x56>
cmp (%rdi),%edx
jne 13ad <func0+0x3d>
nopl 0x0(%... | func0:
endbr64
test esi, esi
jle loc_1410
push r12
mov r12, rcx
push rbp
push rbx
test edx, edx
jz short loc_13A8
cmp edx, 1
jz short loc_13E0
movsxd rsi, esi
mov ecx, edx
shl rsi, 4
lea rax, [rdi+rsi]
jmp short loc_1399
loc_1390:
add rdi, 10h
cmp rdi, rax
j... | long long func0(const char **a1, int a2, int a3, const char *a4)
{
const char **v5; // rax
const char **v7; // rax
const char **v8; // rbx
if ( a2 <= 0 )
return 1LL;
if ( a3 )
{
if ( a3 == 1 )
{
v8 = a1;
while ( *(_DWORD *)v8 == 1 && !strcmp(v8[1], a4) )
{
v8 += 2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101410
PUSH R12
MOV R12,RCX
PUSH RBP
PUSH RBX
TEST EDX,EDX
JZ 0x001013a8
CMP EDX,0x1
JZ 0x001013e0
MOVSXD RSI,ESI
MOV ECX,EDX
SHL RSI,0x4
LEA RAX,[RDI + RSI*0x1]
JMP 0x00101399
LAB_00101390:
ADD RDI,0x10
CMP RDI,RAX
JZ 0x001013d0
LAB_00101399:
CMP ECX,dword ptr [RDI]
JZ 0x00101390
LA... | int8 func0(int *param_1,int param_2,int param_3,char *param_4)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
return 1;
}
if (param_3 == 0) {
piVar1 = param_1 + (long)param_2 * 4;
do {
if (*param_1 != 0) {
return 0;
}
if (param_1[2] != (int)param_4) {
return 0;
... |
5,032 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char *text) {
regex_t regex;
int result;
char* match_result;
char* pattern = "ab{2,3}";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
if (result == 0) {
match_result = "Found a match!";
} else {
match... | int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0xe19(%rip),%rax
mov %rax,-0x58(%rbp)
mov -0x58(%rbp),%rcx
lea -0x50(%rbp),%rax
mov $0x1,%edx
mov %rcx,%rsi
mov %rax,%rdi
callq 10c0 ... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+string], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, aAb23; "ab{2,3}"
mov [rbp+pattern], rax
mov rcx, [rbp+pattern]
lea rax, [rbp+preg]
mov edx, 1; cflags
mov rsi, rcx; pattern... | const char * func0(const char *a1)
{
const char *v2; // [rsp+20h] [rbp-60h]
regex_t preg; // [rsp+30h] [rbp-50h] BYREF
unsigned long long v4; // [rsp+78h] [rbp-8h]
v4 = __readfsqword(0x28u);
regcomp(&preg, "ab{2,3}", 1);
if ( regexec(&preg, a1, 0LL, 0LL, 0) )
v2 = "Not matched!";
else
v2 = "Found... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x58],RAX
MOV RCX,qword ptr [RBP + -0x58]
LEA RAX,[RBP + -0x50]
MOV EDX,0x1
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010c0
MOV RSI,qw... | char * func0(char *param_1)
{
int iVar1;
long in_FS_OFFSET;
char *local_68;
regex_t local_58;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&local_58,"ab{2,3}",1);
iVar1 = regexec(&local_58,param_1,0,(regmatch_t *)0x0,0);
if (iVar1 == 0) {
local_68 = "Found a match!";
}
... |
5,033 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char *text) {
regex_t regex;
int result;
char* match_result;
char* pattern = "ab{2,3}";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
if (result == 0) {
match_result = "Found a match!";
} else {
match... | int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
push %rbx
sub $0x58,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov $0x1,%edx
lea 0xe2b(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x0,%edx
mov %rbx,%rsi
mov %rbp,%rdi... | func0:
endbr64
push rbp
push rbx
sub rsp, 58h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov edx, 1
lea rsi, aAb23; "ab{2,3}"
mov rdi, rbp
call _regcomp
mov r8d, 0
mov ecx, 0
mov edx, 0
mov rsi, rbx
mov rdi, rbp
call ... | const char * func0(long long a1)
{
const char *v1; // rbx
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "ab{2,3}", 1LL);
v1 = "Not matched!";
if ( !(unsigned int)regexec(_0, a1, 0LL, 0LL, 0LL) )
v1 = "Found a match!";
regfree(_0);
return v1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV EDX,0x1
LEA RSI,[0x102020]
MOV RDI,RBP
CALL 0x001010c0
MOV R8D,0x0
MOV ECX,0x0
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RBP
CALL 0x001010d0
TEST EAX,EAX
LEA RAX,[0x102004]
LEA RDX,[0x1... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"ab{2,3}",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Not matched!";
if (iVar1 == 0) {
pcVar2... |
5,034 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char *text) {
regex_t regex;
int result;
char* match_result;
char* pattern = "ab{2,3}";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
if (result == 0) {
match_result = "Found a match!";
} else {
match... | int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
return 0;
}
| O2 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd8b(%rip),%rsi
push %rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi... | func0:
endbr64
push r12
mov edx, 1
mov r12, rdi
lea rsi, aAb23; "ab{2,3}"
push rbp
sub rsp, 58h
mov rax, fs:28h
mov [rsp+var_s48], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
xor edx, edx
xor r8d, r8d
xor ecx, ecx
mov rsi, r12
mov rdi, rbp
ca... | const char * func0(long long a1)
{
int v1; // eax
const char *v2; // rdx
const char *v3; // r12
_QWORD _0[13]; // [rsp+0h] [rbp+0h] BYREF
_0[9] = __readfsqword(0x28u);
regcomp(_0, "ab{2,3}", 1LL);
v1 = regexec(_0, a1, 0LL, 0LL, 0LL);
v2 = "Not matched!";
if ( !v1 )
v2 = "Found a match!";
v3 = v... | func0:
ENDBR64
PUSH R12
MOV EDX,0x1
MOV R12,RDI
LEA RSI,[0x102020]
PUSH RBP
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010c0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,R12
MOV RDI,RBP
CALL 0x001010d0
LEA RDX,[0x102013]
MOV RDI,RBP
TEST EAX,EAX
... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"ab{2,3}",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Not matched!";
if (iVar1 == 0) {
pcVar2... |
5,035 | func0 |
#include <stdio.h>
#include <regex.h>
#include <assert.h>
| char* func0(const char *text) {
regex_t regex;
int result;
char* match_result;
char* pattern = "ab{2,3}";
regcomp(®ex, pattern, REG_EXTENDED);
result = regexec(®ex, text, 0, NULL, 0);
if (result == 0) {
match_result = "Found a match!";
} else {
match... | int main() {
assert(func0("ac") == "Not matched!");
assert(func0("dc") == "Not matched!");
assert(func0("abbbba") == "Found a match!");
return 0;
}
| O3 | c | func0:
endbr64
push %r12
mov $0x1,%edx
mov %rdi,%r12
lea 0xd8b(%rip),%rsi
push %rbp
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
mov %rsp,%rbp
mov %rbp,%rdi
callq 10c0 <regcomp@plt>
xor %r8d,%r8d
xor %ecx,%ecx
xor %edx,%edx
mov %r12,%rsi
mov %rbp,%rdi... | func0:
endbr64
push rbp
mov edx, 1; cflags
mov rbp, rdi
lea rsi, pattern; "ab{2,3}"
push rbx
sub rsp, 58h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov rbx, rsp
mov rdi, rbx; preg
call _regcomp
xor edx, edx; nmatch
xor r8d, r8d; eflags
xor ecx, ecx; ... | const char * func0(char *string)
{
int v1; // eax
const char *v2; // rdx
const char *v3; // rbp
regex_t v5; // [rsp+0h] [rbp-68h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-20h]
v6 = __readfsqword(0x28u);
regcomp(&v5, "ab{2,3}", 1);
v1 = regexec(&v5, string, 0LL, 0LL, 0);
v2 = "Found a match!";
... | func0:
ENDBR64
PUSH RBP
MOV EDX,0x1
MOV RBP,RDI
LEA RSI,[0x102020]
PUSH RBX
SUB RSP,0x58
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBX,RSP
MOV RDI,RBX
CALL 0x001010c0
XOR EDX,EDX
XOR R8D,R8D
XOR ECX,ECX
MOV RSI,RBP
MOV RDI,RBX
CALL 0x001010d0
LEA RDX,[0x102004]
MOV RDI,RBX
TEST EAX,EAX
... | char * func0(char *param_1)
{
int iVar1;
char *pcVar2;
long in_FS_OFFSET;
regex_t rStack_68;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
regcomp(&rStack_68,"ab{2,3}",1);
iVar1 = regexec(&rStack_68,param_1,0,(regmatch_t *)0x0,0);
pcVar2 = "Found a match!";
if (iVar1 != 0) {
pcVa... |
5,036 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int k) {
int max_so_far = -2147483648;
int max_ending_here = 0;
for (int i = 0; i < n * k; ++i) {
max_ending_here = max_ending_here + a[i % n];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
if (max_ending_her... | int main() {
int arr1[] = {10, 20, -30, -1};
assert(func0(arr1, 4, 3) == 30);
int arr2[] = {-1, 10, 20};
assert(func0(arr2, 3, 2) == 59);
int arr3[] = {-1, -2, -3};
assert(func0(arr3, 3, 3) == -1);
printf("All tests passed successfully.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x80000000,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11f0 <func0+0x67>
mov -0x4(%rbp),%eax
cltd
idivl -0x1c(%rbp)
mov %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_C], 80000000h
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11F0
loc_11B2:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_1C]
mov eax, edx
cdqe
lea rdx, ds:... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+14h] [rbp-Ch]
int v5; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0x80000000;
v5 = 0;
for ( i = 0; i < a3 * a2; ++i )
{
v5 += *(_DWORD *)(4LL * (i % a2) + a1);
if ( (int)v4 < v5 )
v4 = v5;
if ( v5 < 0 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0xc],0x80000000
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011f0
LAB_001011b2:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0... | int func0(long param_1,int param_2,int param_3)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = -0x80000000;
local_10 = 0;
for (local_c = 0; local_c < param_2 * param_3; local_c = local_c + 1) {
local_10 = local_10 + *(int *)(param_1 + (long)(local_c % param_2) * 4);
if (local_14 < loca... |
5,037 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int k) {
int max_so_far = -2147483648;
int max_ending_here = 0;
for (int i = 0; i < n * k; ++i) {
max_ending_here = max_ending_here + a[i % n];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
if (max_ending_her... | int main() {
int arr1[] = {10, 20, -30, -1};
assert(func0(arr1, 4, 3) == 30);
int arr2[] = {-1, 10, 20};
assert(func0(arr2, 3, 2) == 59);
int arr3[] = {-1, -2, -3};
assert(func0(arr3, 3, 3) == -1);
printf("All tests passed successfully.\n");
return 0;
}
| O1 | c | func0:
endbr64
imul %esi,%edx
mov %edx,%r10d
test %edx,%edx
jle 11d8 <func0+0x4f>
mov $0x0,%r8d
mov $0x0,%ecx
mov $0x80000000,%r9d
mov $0x0,%r11d
mov %r8d,%eax
cltd
idiv %esi
movslq %edx,%rdx
mov %ecx,%eax
add (%rdi,%rdx,4),%eax
cmp %eax,%r9d
cmovl %eax,%r9d
test %eax,%eax
cmovs ... | func0:
endbr64
mov r10, rdi
imul edx, esi
mov r9d, edx
test edx, edx
jle short loc_11D7
mov edi, 0
mov ecx, 0
mov r8d, 80000000h
loc_11AA:
mov eax, edi
cdq
idiv esi
movsxd rdx, edx
mov eax, ecx
add eax, [r10+rdx*4]
cmp r8d, eax
cmovl r8d, eax
test eax, eax
mov ... | long long func0(long long a1, int a2, int a3)
{
int v4; // edi
int v5; // ecx
unsigned int v6; // r8d
int v7; // eax
if ( a2 * a3 <= 0 )
{
return 0x80000000;
}
else
{
v4 = 0;
v5 = 0;
v6 = 0x80000000;
do
{
v7 = *(_DWORD *)(a1 + 4LL * (v4 % a2)) + v5;
if ( (int)v6 <... | func0:
ENDBR64
MOV R10,RDI
IMUL EDX,ESI
MOV R9D,EDX
TEST EDX,EDX
JLE 0x001011d7
MOV EDI,0x0
MOV ECX,0x0
MOV R8D,0x80000000
LAB_001011aa:
MOV EAX,EDI
CDQ
IDIV ESI
MOVSXD RDX,EDX
MOV EAX,ECX
ADD EAX,dword ptr [R10 + RDX*0x4]
CMP R8D,EAX
CMOVL R8D,EAX
TEST EAX,EAX
MOV EDX,0x0
MOV ECX,EDX
CMOVNS ECX,EAX
ADD EDI,0x1
CMP EDI... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (param_3 * param_2 < 1) {
iVar4 = -0x80000000;
}
else {
iVar3 = 0;
iVar2 = 0;
iVar4 = -0x80000000;
do {
iVar1 = iVar2 + *(int *)(param_1 + (long)(iVar3 % param_2) * 4);
if (... |
5,038 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int k) {
int max_so_far = -2147483648;
int max_ending_here = 0;
for (int i = 0; i < n * k; ++i) {
max_ending_here = max_ending_here + a[i % n];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
if (max_ending_her... | int main() {
int arr1[] = {10, 20, -30, -1};
assert(func0(arr1, 4, 3) == 30);
int arr2[] = {-1, 10, 20};
assert(func0(arr2, 3, 2) == 59);
int arr3[] = {-1, -2, -3};
assert(func0(arr3, 3, 3) == -1);
printf("All tests passed successfully.\n");
return 0;
}
| O2 | c | func0:
endbr64
imul %esi,%edx
mov %edx,%r10d
test %edx,%edx
jle 13b0 <func0+0x50>
xor %r8d,%r8d
xor %ecx,%ecx
mov $0x80000000,%r9d
xor %r11d,%r11d
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %esi
movslq %edx,%rdx
mov (%rdi,%rdx,4),%eax
add %ecx,%eax
cmp %eax,%r9d
cmovl %eax,%r9d
test ... | func0:
endbr64
imul edx, esi
mov r10, rdi
mov r9d, edx
test edx, edx
jle short loc_13A0
xor edi, edi
xor ecx, ecx
mov r8d, 80000000h
nop dword ptr [rax+rax+00h]
loc_1370:
mov eax, edi
cdq
idiv esi
movsxd rdx, edx
mov eax, [r10+rdx*4]
add eax, ecx
cmp r8d, eax
cmovl ... | long long func0(long long a1, int a2, int a3)
{
int v4; // edi
int v5; // ecx
unsigned int v6; // r8d
int v7; // eax
if ( a2 * a3 <= 0 )
return 0x80000000LL;
v4 = 0;
v5 = 0;
v6 = 0x80000000;
do
{
v7 = v5 + *(_DWORD *)(a1 + 4LL * (v4 % a2));
if ( (int)v6 < v7 )
v6 = v5 + *(_DWORD ... | func0:
ENDBR64
IMUL EDX,ESI
MOV R10,RDI
MOV R9D,EDX
TEST EDX,EDX
JLE 0x001013a0
XOR EDI,EDI
XOR ECX,ECX
MOV R8D,0x80000000
NOP dword ptr [RAX + RAX*0x1]
LAB_00101370:
MOV EAX,EDI
CDQ
IDIV ESI
MOVSXD RDX,EDX
MOV EAX,dword ptr [R10 + RDX*0x4]
ADD EAX,ECX
CMP R8D,EAX
CMOVL R8D,EAX
XOR EDX,EDX
TEST EAX,EAX
MOV ECX,EDX
CMOV... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_3 * param_2) {
iVar3 = 0;
iVar2 = 0;
iVar4 = -0x80000000;
do {
iVar1 = *(int *)(param_1 + (long)(iVar3 % param_2) * 4) + iVar2;
if (iVar4 < iVar1) {
iVar4 = iVar1... |
5,039 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int k) {
int max_so_far = -2147483648;
int max_ending_here = 0;
for (int i = 0; i < n * k; ++i) {
max_ending_here = max_ending_here + a[i % n];
if (max_so_far < max_ending_here) {
max_so_far = max_ending_here;
}
if (max_ending_her... | int main() {
int arr1[] = {10, 20, -30, -1};
assert(func0(arr1, 4, 3) == 30);
int arr2[] = {-1, 10, 20};
assert(func0(arr2, 3, 2) == 59);
int arr3[] = {-1, -2, -3};
assert(func0(arr3, 3, 3) == -1);
printf("All tests passed successfully.\n");
return 0;
}
| O3 | c | func0:
endbr64
imul %esi,%edx
mov %edx,%r10d
test %edx,%edx
jle 1300 <func0+0x50>
xor %r8d,%r8d
xor %ecx,%ecx
mov $0x80000000,%r9d
xor %r11d,%r11d
nopl 0x0(%rax)
mov %r8d,%eax
cltd
idiv %esi
movslq %edx,%rdx
mov (%rdi,%rdx,4),%eax
add %ecx,%eax
cmp %eax,%r9d
cmovl %eax,%r9d
test ... | func0:
endbr64
imul edx, esi
mov r10, rdi
mov r9d, edx
test edx, edx
jle short loc_11C0
xor edi, edi
xor ecx, ecx
mov r8d, 80000000h
nop dword ptr [rax+rax+00h]
loc_1190:
mov eax, edi
cdq
idiv esi
movsxd rdx, edx
mov eax, [r10+rdx*4]
add eax, ecx
cmp r8d, eax
cmovl ... | long long func0(long long a1, int a2, int a3)
{
int v4; // edi
int v5; // ecx
unsigned int v6; // r8d
int v7; // eax
if ( a2 * a3 <= 0 )
return 0x80000000LL;
v4 = 0;
v5 = 0;
v6 = 0x80000000;
do
{
v7 = v5 + *(_DWORD *)(a1 + 4LL * (v4 % a2));
if ( (int)v6 < v7 )
v6 = v5 + *(_DWORD ... | func0:
ENDBR64
IMUL EDX,ESI
MOV R10,RDI
MOV R9D,EDX
TEST EDX,EDX
JLE 0x001011c0
XOR EDI,EDI
XOR ECX,ECX
MOV R8D,0x80000000
NOP dword ptr [RAX + RAX*0x1]
LAB_00101190:
MOV EAX,EDI
CDQ
IDIV ESI
MOVSXD RDX,EDX
MOV EAX,dword ptr [R10 + RDX*0x4]
ADD EAX,ECX
CMP R8D,EAX
CMOVL R8D,EAX
XOR EDX,EDX
TEST EAX,EAX
MOV ECX,EDX
CMOV... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_3 * param_2) {
iVar3 = 0;
iVar2 = 0;
iVar4 = -0x80000000;
do {
iVar1 = *(int *)(param_1 + (long)(iVar3 % param_2) * 4) + iVar2;
if (iVar4 < iVar1) {
iVar4 = iVar1... |
5,040 | func0 |
#include <assert.h>
| int func0(int n) {
return 2 * n * (n + 1) * (2 * n + 1) / 3;
}
| int main() {
assert(func0(2) == 20);
assert(func0(3) == 56);
assert(func0(4) == 120);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
add $0x1,%eax
imul -0x4(%rbp),%eax
mov -0x4(%rbp),%edx
add %edx,%edx
add $0x1,%edx
imul %edx,%eax
add %eax,%eax
movslq %eax,%rdx
imul $0x55555556,%rdx,%rdx
shr $0x20,%rdx
sar $0x1f,%eax
mov %edx,%ecx
... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, 1
imul eax, [rbp+var_4]
mov edx, [rbp+var_4]
add edx, edx
add edx, 1
imul eax, edx
add eax, eax
movsxd rdx, eax
imul rdx, 55555556h
shr rdx, 20h
sar eax, 1Fh
sub edx, eax
mov ... | long long func0(int a1)
{
return (unsigned int)(2 * (2 * a1 + 1) * a1 * (a1 + 1) / 3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
IMUL EAX,dword ptr [RBP + -0x4]
MOV EDX,dword ptr [RBP + -0x4]
ADD EDX,EDX
ADD EDX,0x1
IMUL EAX,EDX
ADD EAX,EAX
MOVSXD RDX,EAX
IMUL RDX,RDX,0x55555556
SHR RDX,0x20
SAR EAX,0x1f
SUB EDX,EAX
MOV EAX,EDX
POP RBP
R... | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1) * 2) / 3;
} |
5,041 | func0 |
#include <assert.h>
| int func0(int n) {
return 2 * n * (n + 1) * (2 * n + 1) / 3;
}
| int main() {
assert(func0(2) == 20);
assert(func0(3) == 56);
assert(func0(4) == 120);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%edx
imul %edi,%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %eax,%edx
add %edx,%edx
movslq %edx,%rax
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sar $0x1f,%edx
sub %edx,%eax
retq
| func0:
endbr64
lea edx, [rdi+1]
imul edx, edi
lea eax, [rdi+rdi+1]
imul edx, eax
add edx, edx
movsxd rax, edx
imul rax, 55555556h
shr rax, 20h
sar edx, 1Fh
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(2 * (2 * a1 + 1) * a1 * (a1 + 1) / 3);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
IMUL EDX,EDI
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EAX
ADD EDX,EDX
MOVSXD RAX,EDX
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SAR EDX,0x1f
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1) * 2) / 3;
} |
5,042 | func0 |
#include <assert.h>
| int func0(int n) {
return 2 * n * (n + 1) * (2 * n + 1) / 3;
}
| int main() {
assert(func0(2) == 20);
assert(func0(3) == 56);
assert(func0(4) == 120);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
add %edx,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
add edx, edx
movsxd rax, edx
sar edx, 1Fh
imul rax, 55555556h
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(2 * (2 * a1 + 1) * a1 * (a1 + 1) / 3);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
ADD EDX,EDX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1) * 2) / 3;
} |
5,043 | func0 |
#include <assert.h>
| int func0(int n) {
return 2 * n * (n + 1) * (2 * n + 1) / 3;
}
| int main() {
assert(func0(2) == 20);
assert(func0(3) == 56);
assert(func0(4) == 120);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%edx
lea 0x1(%rdi,%rdi,1),%eax
imul %edi,%edx
imul %eax,%edx
add %edx,%edx
movslq %edx,%rax
sar $0x1f,%edx
imul $0x55555556,%rax,%rax
shr $0x20,%rax
sub %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
lea eax, [rdi+rdi+1]
imul edx, edi
imul edx, eax
add edx, edx
movsxd rax, edx
sar edx, 1Fh
imul rax, 55555556h
shr rax, 20h
sub eax, edx
retn | long long func0(int a1)
{
return (unsigned int)(2 * (2 * a1 + 1) * a1 * (a1 + 1) / 3);
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
LEA EAX,[RDI + RDI*0x1 + 0x1]
IMUL EDX,EDI
IMUL EDX,EAX
ADD EDX,EDX
MOVSXD RAX,EDX
SAR EDX,0x1f
IMUL RAX,RAX,0x55555556
SHR RAX,0x20
SUB EAX,EDX
RET | int func0(int param_1)
{
return ((param_1 + 1) * param_1 * (param_1 * 2 + 1) * 2) / 3;
} |
5,044 | func0 | #include <assert.h>
/* Function to calculate number of elements in array `arr` of length `N`
that are modular inverses under modulo `P` */
| int func0(int arr[], int N, int P) {
int current_element = 0;
for (int i = 0; i < N; i++) {
if ((arr[i] * arr[i]) % P == 1) {
current_element += 1;
}
}
return current_element;
}
| int main() {
int arr1[] = {1, 6, 4, 5};
int arr2[] = {1, 3, 8, 12, 12};
int arr3[] = {2, 3, 4, 5};
assert(func0(arr1, 4, 7) == 2);
assert(func0(arr2, 5, 13) == 3);
assert(func0(arr3, 4, 6) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cd <func0+0x64>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%e... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11CD
loc_118B:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mo... | long long func0(long long a1, int a2, int a3)
{
unsigned int v4; // [rsp+18h] [rbp-8h]
int i; // [rsp+1Ch] [rbp-4h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) * *(_DWORD *)(4LL * i + a1) % a3 == 1 )
++v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011cd
LAB_0010118b:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX... | int func0(long param_1,int param_2,int param_3)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((*(int *)(param_1 + (long)local_c * 4) * *(int *)(param_1 + (long)local_c * 4)) % param_3 ==
1) {
local_10 = local_10 + 1;
}
... |
5,045 | func0 | #include <assert.h>
/* Function to calculate number of elements in array `arr` of length `N`
that are modular inverses under modulo `P` */
| int func0(int arr[], int N, int P) {
int current_element = 0;
for (int i = 0; i < N; i++) {
if ((arr[i] * arr[i]) % P == 1) {
current_element += 1;
}
}
return current_element;
}
| int main() {
int arr1[] = {1, 6, 4, 5};
int arr2[] = {1, 3, 8, 12, 12};
int arr3[] = {2, 3, 4, 5};
assert(func0(arr1, 4, 7) == 2);
assert(func0(arr2, 5, 13) == 3);
assert(func0(arr3, 4, 6) == 1);
return 0;
}
| O1 | c | func0:
endbr64
mov %edx,%r8d
test %esi,%esi
jle 11a4 <func0+0x3b>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%esi
mov (%rcx),%eax
imul %eax,%eax
cltd
idiv %r8d
cmp $0x1,%edx
sete %al
movzbl %al,%eax
add %eax,%esi
add $0x4,%rcx
cmp %rdi,%rcx
jne 1184 ... | func0:
endbr64
mov r8d, edx
test esi, esi
jle short loc_11A4
mov rcx, rdi
lea eax, [rsi-1]
lea rdi, [rdi+rax*4+4]
mov esi, 0
loc_1184:
mov eax, [rcx]
imul eax, eax
cdq
idiv r8d
cmp edx, 1
setz al
movzx eax, al
add esi, eax
add rcx, 4
cmp rcx, rdi
jnz short l... | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // rcx
long long v4; // rdi
unsigned int v5; // esi
if ( a2 <= 0 )
{
return 0;
}
else
{
v3 = a1;
v4 = (long long)&a1[a2 - 1 + 1];
v5 = 0;
do
{
v5 += *v3 * *v3 % a3 == 1;
++v3;
}
while ( v3 != (_DWORD ... | func0:
ENDBR64
MOV R8D,EDX
TEST ESI,ESI
JLE 0x001011a4
MOV RCX,RDI
LEA EAX,[RSI + -0x1]
LEA RDI,[RDI + RAX*0x4 + 0x4]
MOV ESI,0x0
LAB_00101184:
MOV EAX,dword ptr [RCX]
IMUL EAX,EAX
CDQ
IDIV R8D
CMP EDX,0x1
SETZ AL
MOVZX EAX,AL
ADD ESI,EAX
ADD RCX,0x4
CMP RCX,RDI
JNZ 0x00101184
LAB_001011a1:
MOV EAX,ESI
RET
LAB_001011a4... | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*param_1 * *param_1) % param_3 == 1);
param_1 = param_1 + 1;
} while (param_... |
5,046 | func0 | #include <assert.h>
/* Function to calculate number of elements in array `arr` of length `N`
that are modular inverses under modulo `P` */
| int func0(int arr[], int N, int P) {
int current_element = 0;
for (int i = 0; i < N; i++) {
if ((arr[i] * arr[i]) % P == 1) {
current_element += 1;
}
}
return current_element;
}
| int main() {
int arr1[] = {1, 6, 4, 5};
int arr2[] = {1, 3, 8, 12, 12};
int arr3[] = {2, 3, 4, 5};
assert(func0(arr1, 4, 7) == 2);
assert(func0(arr2, 5, 13) == 3);
assert(func0(arr3, 4, 6) == 1);
return 0;
}
| O2 | c | func0:
endbr64
mov %edx,%ecx
test %esi,%esi
jle 12f0 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rsi
nopl (%rax)
mov (%rdi),%eax
imul %eax,%eax
cltd
idiv %ecx
xor %eax,%eax
cmp $0x1,%edx
sete %al
add $0x4,%rdi
add %eax,%r8d
cmp %rsi,%rdi
jne 12c8 <f... | func0:
endbr64
mov ecx, edx
test esi, esi
jle short loc_1350
lea eax, [rsi-1]
xor r8d, r8d
lea rsi, [rdi+rax*4+4]
nop dword ptr [rax]
loc_1328:
mov eax, [rdi]
imul eax, eax
cdq
idiv ecx
xor eax, eax
cmp edx, 1
setz al
add rdi, 4
add r8d, eax
cmp rdi, rsi
jnz ... | long long func0(_DWORD *a1, int a2, int a3)
{
unsigned int v3; // r8d
long long v4; // rsi
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v3 = 0;
v4 = (long long)&a1[a2 - 1 + 1];
do
{
v5 = *a1 * *a1 % a3 == 1;
++a1;
v3 += v5;
}
while ( a1 != (_DWORD *)v4 );
return v3;
} | func0:
ENDBR64
MOV ECX,EDX
TEST ESI,ESI
JLE 0x00101350
LEA EAX,[RSI + -0x1]
XOR R8D,R8D
LEA RSI,[RDI + RAX*0x4 + 0x4]
NOP dword ptr [RAX]
LAB_00101328:
MOV EAX,dword ptr [RDI]
IMUL EAX,EAX
CDQ
IDIV ECX
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
ADD RDI,0x4
ADD R8D,EAX
CMP RDI,RSI
JNZ 0x00101328
MOV EAX,R8D
RET
LAB_00101350:
XOR R... | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
iVar3 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)((iVar2 * iVar2) % param_3 == 1);
} while (par... |
5,047 | func0 | #include <assert.h>
/* Function to calculate number of elements in array `arr` of length `N`
that are modular inverses under modulo `P` */
| int func0(int arr[], int N, int P) {
int current_element = 0;
for (int i = 0; i < N; i++) {
if ((arr[i] * arr[i]) % P == 1) {
current_element += 1;
}
}
return current_element;
}
| int main() {
int arr1[] = {1, 6, 4, 5};
int arr2[] = {1, 3, 8, 12, 12};
int arr3[] = {2, 3, 4, 5};
assert(func0(arr1, 4, 7) == 2);
assert(func0(arr2, 5, 13) == 3);
assert(func0(arr3, 4, 6) == 1);
return 0;
}
| O3 | c | func0:
endbr64
mov %edx,%ecx
test %esi,%esi
jle 1270 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rsi
nopl (%rax)
mov (%rdi),%eax
imul %eax,%eax
cltd
idiv %ecx
xor %eax,%eax
cmp $0x1,%edx
sete %al
add $0x4,%rdi
add %eax,%r8d
cmp %rdi,%rsi
jne 1248 <f... | func0:
endbr64
mov ecx, edx
test esi, esi
jle short loc_1180
movsxd rsi, esi
lea r8, [rdi+rsi*4]
xor esi, esi
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, [rdi]
imul eax, eax
cdq
idiv ecx
xor eax, eax
cmp edx, 1
setz al
add rdi, 4
add esi, eax
cmp r8, rdi
jnz ... | long long func0(_DWORD *a1, int a2, int a3)
{
_DWORD *v3; // r8
unsigned int v4; // esi
int v5; // eax
if ( a2 <= 0 )
return 0LL;
v3 = &a1[a2];
v4 = 0;
do
{
v5 = *a1 * *a1 % a3 == 1;
++a1;
v4 += v5;
}
while ( v3 != a1 );
return v4;
} | func0:
ENDBR64
MOV ECX,EDX
TEST ESI,ESI
JLE 0x00101180
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
XOR ESI,ESI
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,dword ptr [RDI]
IMUL EAX,EAX
CDQ
IDIV ECX
XOR EAX,EAX
CMP EDX,0x1
SETZ AL
ADD RDI,0x4
ADD ESI,EAX
CMP R8,RDI
JNZ 0x00101158
MOV EAX,ESI
RET
LAB_00101180:
XOR ESI,E... | int func0(int *param_1,int param_2,int param_3)
{
int *piVar1;
int iVar2;
int iVar3;
if (0 < param_2) {
piVar1 = param_1 + param_2;
iVar3 = 0;
do {
iVar2 = *param_1;
param_1 = param_1 + 1;
iVar3 = iVar3 + (uint)((iVar2 * iVar2) % param_3 == 1);
} while (piVar1 != param_1);
... |
5,048 | func0 |
#include <assert.h>
| int func0(int N) {
int hund1 = N / 100;
int hund4 = N / 400;
int leap = N >> 2;
int ordd = N - leap;
if (hund1) {
ordd += hund1;
leap -= hund1;
}
if (hund4) {
ordd -= hund4;
leap += hund4;
}
int days = ordd + leap * 2;
int odd = days ... | int main() {
assert(func0(100) == 5);
assert(func0(50) == 6);
assert(func0(75) == 2);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
imul $0x51eb851f,%rdx,%rdx
shr $0x20,%rdx
sar $0x5,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x10(%rbp)
mov -0x24(%rbp),%eax
movslq %eax,%rdx
imul $0x51eb851f,%rdx,%rdx
s... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
mov eax, [rbp+var_24]
movsxd rdx, eax
imul rdx, 51EB851Fh
shr rdx, 20h
mov ecx, edx
sar ecx, 5
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_10], eax
mov eax, [rbp+var_24]
movsxd rdx, eax
imul rdx, 51EB851Fh
shr ... | long long func0(int a1)
{
int v2; // [rsp+Ch] [rbp-18h]
int v3; // [rsp+10h] [rbp-14h]
int v4; // [rsp+14h] [rbp-10h]
int v5; // [rsp+18h] [rbp-Ch]
v4 = a1 / 100;
v5 = a1 / 400;
v2 = a1 >> 2;
v3 = a1 - (a1 >> 2);
if ( a1 / 100 )
{
v3 += v4;
v2 -= v4;
}
if ( v5 )
{
v3 -= v5;
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x5
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x51eb851f
SHR RDX,0x20
... | int func0(int param_1)
{
int iVar1;
int iVar2;
int4 local_20;
int4 local_1c;
iVar1 = param_1 / 100;
iVar2 = param_1 / 400;
local_20 = param_1 >> 2;
local_1c = param_1 - local_20;
if (iVar1 != 0) {
local_1c = local_1c + iVar1;
local_20 = local_20 - iVar1;
}
if (iVar2 != 0) {
local_1... |
5,049 | func0 |
#include <assert.h>
| int func0(int N) {
int hund1 = N / 100;
int hund4 = N / 400;
int leap = N >> 2;
int ordd = N - leap;
if (hund1) {
ordd += hund1;
leap -= hund1;
}
if (hund4) {
ordd -= hund4;
leap += hund4;
}
int days = ordd + leap * 2;
int odd = days ... | int main() {
assert(func0(100) == 5);
assert(func0(50) == 6);
assert(func0(75) == 2);
return 0;
}
| O1 | c | func0:
endbr64
movslq %edi,%rax
imul $0x51eb851f,%rax,%rax
mov %rax,%rsi
sar $0x25,%rsi
mov %rsi,%rcx
mov %edi,%esi
sar $0x1f,%esi
sar $0x27,%rax
sub %esi,%eax
mov %edi,%edx
sar $0x2,%edx
sub %edx,%edi
sub %esi,%ecx
je 115b <func0+0x32>
add %ecx,%edi
sub %ecx,%edx
test %ea... | func0:
endbr64
movsxd rax, edi
imul rax, 51EB851Fh
mov rsi, rax
sar rsi, 25h
mov rcx, rsi
mov esi, edi
sar esi, 1Fh
sar rax, 27h
sub eax, esi
mov edx, edi
sar edx, 2
sub edi, edx
sub ecx, esi
jz short loc_115B
add edi, ecx
sub edx, ecx
loc_115B:
test eax, ... | long long func0(int a1)
{
int v2; // eax
int v3; // edx
int v4; // edi
int v5; // ecx
v2 = a1 / 400;
v3 = a1 >> 2;
v4 = a1 - (a1 >> 2);
v5 = a1 / 100;
if ( a1 / 100 )
{
v4 += v5;
v3 -= v5;
}
if ( v2 )
{
v4 -= v2;
v3 += v2;
}
return (unsigned int)((v4 + 2 * v3) % 7);
} | func0:
ENDBR64
MOVSXD RAX,EDI
IMUL RAX,RAX,0x51eb851f
MOV RSI,RAX
SAR RSI,0x25
MOV RCX,RSI
MOV ESI,EDI
SAR ESI,0x1f
SAR RAX,0x27
SUB EAX,ESI
MOV EDX,EDI
SAR EDX,0x2
SUB EDI,EDX
SUB ECX,ESI
JZ 0x0010115b
ADD EDI,ECX
SUB EDX,ECX
LAB_0010115b:
TEST EAX,EAX
JZ 0x00101163
SUB EDI,EAX
ADD EDX,EAX
LAB_00101163:
LEA EDX,[RDI +... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar2 = param_1 / 100;
iVar1 = param_1 / 400;
iVar3 = param_1 >> 2;
param_1 = param_1 - iVar3;
if (iVar2 != 0) {
param_1 = param_1 + iVar2;
iVar3 = iVar3 - iVar2;
}
if (iVar1 != 0) {
param_1 = param_1 - iVar1;
iVar3 = iVar... |
5,050 | func0 |
#include <assert.h>
| int func0(int N) {
int hund1 = N / 100;
int hund4 = N / 400;
int leap = N >> 2;
int ordd = N - leap;
if (hund1) {
ordd += hund1;
leap -= hund1;
}
if (hund4) {
ordd -= hund4;
leap += hund4;
}
int days = ordd + leap * 2;
int odd = days ... | int main() {
assert(func0(100) == 5);
assert(func0(50) == 6);
assert(func0(75) == 2);
return 0;
}
| O2 | c | func0:
endbr64
movslq %edi,%rax
mov %edi,%edx
imul $0x51eb851f,%rax,%rax
sar $0x2,%edx
mov %rax,%rsi
sar $0x27,%rax
sar $0x25,%rsi
mov %rsi,%rcx
mov %edi,%esi
sub %edx,%edi
sar $0x1f,%esi
sub %esi,%eax
sub %esi,%ecx
je 1172 <func0+0x32>
add %ecx,%edi
sub %ecx,%edx
test %ea... | func0:
endbr64
movsxd rax, edi
mov edx, edi
imul rax, 51EB851Fh
sar edx, 2
mov rsi, rax
sar rax, 27h
sar rsi, 25h
mov rcx, rsi
mov esi, edi
sub edi, edx
sar esi, 1Fh
sub eax, esi
sub ecx, esi
jz short loc_1172
add edi, ecx
sub edx, ecx
loc_1172:
test eax, ... | long long func0(int a1)
{
int v1; // edx
long long v2; // rax
int v5; // edi
int v6; // eax
int v7; // ecx
v1 = a1 >> 2;
v2 = (1374389535LL * a1) >> 39;
v5 = a1 - (a1 >> 2);
v6 = v2 - (a1 >> 31);
v7 = a1 / 100;
if ( a1 / 100 )
{
v5 += v7;
v1 -= v7;
}
if ( v6 )
{
v5 -= v6;
... | func0:
ENDBR64
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x51eb851f
SAR EDX,0x2
MOV RSI,RAX
SAR RAX,0x27
SAR RSI,0x25
MOV RCX,RSI
MOV ESI,EDI
SUB EDI,EDX
SAR ESI,0x1f
SUB EAX,ESI
SUB ECX,ESI
JZ 0x00101172
ADD EDI,ECX
SUB EDX,ECX
LAB_00101172:
TEST EAX,EAX
JZ 0x0010117a
SUB EDI,EAX
ADD EDX,EAX
LAB_0010117a:
LEA EDX,[RDI +... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1 >> 2;
iVar1 = param_1 / 400;
iVar2 = param_1 / 100;
param_1 = param_1 - iVar3;
if (iVar2 != 0) {
param_1 = param_1 + iVar2;
iVar3 = iVar3 - iVar2;
}
if (iVar1 != 0) {
param_1 = param_1 - iVar1;
iVar3 = iVar... |
5,051 | func0 |
#include <assert.h>
| int func0(int N) {
int hund1 = N / 100;
int hund4 = N / 400;
int leap = N >> 2;
int ordd = N - leap;
if (hund1) {
ordd += hund1;
leap -= hund1;
}
if (hund4) {
ordd -= hund4;
leap += hund4;
}
int days = ordd + leap * 2;
int odd = days ... | int main() {
assert(func0(100) == 5);
assert(func0(50) == 6);
assert(func0(75) == 2);
return 0;
}
| O3 | c | func0:
endbr64
movslq %edi,%rax
mov %edi,%edx
imul $0x51eb851f,%rax,%rax
sar $0x2,%edx
mov %rax,%rsi
sar $0x27,%rax
sar $0x25,%rsi
mov %rsi,%rcx
mov %edi,%esi
sub %edx,%edi
sar $0x1f,%esi
sub %esi,%eax
sub %esi,%ecx
je 1172 <func0+0x32>
add %ecx,%edi
sub %ecx,%edx
test %ea... | func0:
endbr64
movsxd rax, edi
mov edx, edi
imul rax, 51EB851Fh
sar edx, 2
mov rsi, rax
sar rax, 27h
sar rsi, 25h
mov rcx, rsi
mov esi, edi
sub edi, edx
sar esi, 1Fh
sub eax, esi
sub ecx, esi
jz short loc_1172
add edi, ecx
sub edx, ecx
loc_1172:
test eax, ... | long long func0(int a1)
{
int v1; // edx
long long v2; // rax
int v5; // edi
int v6; // eax
int v7; // ecx
v1 = a1 >> 2;
v2 = (1374389535LL * a1) >> 39;
v5 = a1 - (a1 >> 2);
v6 = v2 - (a1 >> 31);
v7 = a1 / 100;
if ( a1 / 100 )
{
v5 += v7;
v1 -= v7;
}
if ( v6 )
{
v5 -= v6;
... | func0:
ENDBR64
MOVSXD RAX,EDI
MOV EDX,EDI
IMUL RAX,RAX,0x51eb851f
SAR EDX,0x2
MOV RSI,RAX
SAR RAX,0x27
SAR RSI,0x25
MOV RCX,RSI
MOV ESI,EDI
SUB EDI,EDX
SAR ESI,0x1f
SUB EAX,ESI
SUB ECX,ESI
JZ 0x00101172
ADD EDI,ECX
SUB EDX,ECX
LAB_00101172:
TEST EAX,EAX
JZ 0x0010117a
SUB EDI,EAX
ADD EDX,EAX
LAB_0010117a:
LEA EDX,[RDI +... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
iVar3 = param_1 >> 2;
iVar1 = param_1 / 400;
iVar2 = param_1 / 100;
param_1 = param_1 - iVar3;
if (iVar2 != 0) {
param_1 = param_1 + iVar2;
iVar3 = iVar3 - iVar2;
}
if (iVar1 != 0) {
param_1 = param_1 - iVar1;
iVar3 = iVar... |
5,052 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int length;
int *array;
} Result;
void compareArrays(int *array1, int *array2, int size) {
for (int i = 0; i < size; i++) {
assert(array1[i] == array2[i]);
}
}
| Result func0(int **list, int size, int *sizes) {
Result result;
int maxLength = 0;
int *maxList = NULL;
for (int i = 0; i < size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
maxList = list[i];
}
}
result.length = maxLength;
... | int main() {
int arr1[] = {0};
int arr2[] = {1, 3};
int arr3[] = {5, 7};
int arr4[] = {9, 11};
int arr5[] = {13, 15, 17};
int *list1[] = {arr1, arr2, arr3, arr4, arr5};
int sizes1[] = {1, 2, 2, 2, 3};
Result res1 = func0(list1, 5, sizes1);
assert(res1.length == 3);
co... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
mov %rdi,-0x30(%rbp)
mov %esi,-0x34(%rbp)
mov %rdx,-0x40(%rbp)
movl $0x0,-0x28(%rbp)
movq $0x0,-0x20(%rbp)
movl $0x0,-0x24(%rbp)
jmp 1287 <func0+0x7f>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x40(%rbp),%rax
add %rdx,%rax
... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_48], rdx
mov [rbp+var_30], 0
mov [rbp+var_28], 0
mov [rbp+var_2C], 0
jmp short loc_1290
loc_123D:
mov eax, [rbp+var_2C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_48]... | long long func0(long long a1, int a2, long long a3)
{
unsigned int v4; // [rsp+18h] [rbp-30h]
int i; // [rsp+1Ch] [rbp-2Ch]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (signed int)v4 < *(_DWORD *)(4LL * i + a3) )
v4 = *(_DWORD *)(4LL * i + a3);
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV qword ptr [RBP + -0x48],RDX
MOV dword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x00101290
LAB_0010123d:
MOV EAX,dword ptr [RBP + -0x2c]
CDQE
LEA RDX,[RAX*0x4]... | int [16] func0(long param_1,int param_2,long param_3)
{
int auVar1 [16];
int4 local_38;
int4 local_34;
int8 local_30;
local_38 = 0;
local_30 = 0;
for (local_34 = 0; local_34 < param_2; local_34 = local_34 + 1) {
if ((int)local_38 < *(int *)(param_3 + (long)local_34 * 4)) {
local_38 = *(uint... |
5,053 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int length;
int *array;
} Result;
void compareArrays(int *array1, int *array2, int size) {
for (int i = 0; i < size; i++) {
assert(array1[i] == array2[i]);
}
}
| Result func0(int **list, int size, int *sizes) {
Result result;
int maxLength = 0;
int *maxList = NULL;
for (int i = 0; i < size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
maxList = list[i];
}
}
result.length = maxLength;
... | int main() {
int arr1[] = {0};
int arr2[] = {1, 3};
int arr3[] = {5, 7};
int arr4[] = {9, 11};
int arr5[] = {13, 15, 17};
int *list1[] = {arr1, arr2, arr3, arr4, arr5};
int sizes1[] = {1, 2, 2, 2, 3};
Result res1 = func0(list1, 5, sizes1);
assert(res1.length == 3);
co... | O1 | c | func0:
endbr64
test %esi,%esi
jle 120c <func0+0x39>
lea -0x1(%rsi),%r8d
mov $0x0,%ecx
mov $0x0,%r9d
mov $0x0,%eax
jmp 11fd <func0+0x2a>
lea 0x1(%rcx),%rsi
cmp %r8,%rcx
je 1217 <func0+0x44>
mov %rsi,%rcx
mov (%rdx,%rcx,4),%esi
cmp %eax,%esi
jle 11f1 <func0+0x1e>
mov (%rdi,%rc... | func0:
endbr64
test esi, esi
jle short loc_1204
mov esi, esi
mov ecx, 0
mov r9d, 0
mov eax, 0
jmp short loc_11F2
loc_11E9:
add rcx, 1
cmp rcx, rsi
jz short loc_120F
loc_11F2:
mov r8d, [rdx+rcx*4]
cmp r8d, eax
jle short loc_11E9
mov r9, [rdi+rcx*8]
mov eax, r8d... | long long func0(long long a1, int a2, long long a3)
{
long long v3; // rcx
long long result; // rax
int v5; // r8d
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
result = 0LL;
do
{
v5 = *(_DWORD *)(a3 + 4 * v3);
if ( v5 > (int)result )
result = (unsigned int)v5;
++v3;
}
while ( v3 != a... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101204
MOV ESI,ESI
MOV ECX,0x0
MOV R9D,0x0
MOV EAX,0x0
JMP 0x001011f2
LAB_001011e9:
ADD RCX,0x1
CMP RCX,RSI
JZ 0x0010120f
LAB_001011f2:
MOV R8D,dword ptr [RDX + RCX*0x4]
CMP R8D,EAX
JLE 0x001011e9
MOV R9,qword ptr [RDI + RCX*0x8]
MOV EAX,R8D
JMP 0x001011e9
LAB_00101204:
MOV R9D,0x0
M... | int1 [16] func0(long param_1,uint param_2,long param_3)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
int8 uVar4;
int1 auVar5 [16];
if ((int)param_2 < 1) {
uVar4 = 0;
uVar2 = 0;
}
else {
uVar3 = 0;
uVar4 = 0;
uVar2 = 0;
do {
uVar1 = *(uint *)(param_3 + uVar3 * 4);
if (... |
5,054 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int length;
int *array;
} Result;
void compareArrays(int *array1, int *array2, int size) {
for (int i = 0; i < size; i++) {
assert(array1[i] == array2[i]);
}
}
| Result func0(int **list, int size, int *sizes) {
Result result;
int maxLength = 0;
int *maxList = NULL;
for (int i = 0; i < size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
maxList = list[i];
}
}
result.length = maxLength;
... | int main() {
int arr1[] = {0};
int arr2[] = {1, 3};
int arr3[] = {5, 7};
int arr4[] = {9, 11};
int arr5[] = {13, 15, 17};
int *list1[] = {arr1, arr2, arr3, arr4, arr5};
int sizes1[] = {1, 2, 2, 2, 3};
Result res1 = func0(list1, 5, sizes1);
assert(res1.length == 3);
co... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1228 <func0+0x38>
lea -0x1(%rsi),%r8d
xor %ecx,%ecx
xor %r9d,%r9d
xor %eax,%eax
jmp 120b <func0+0x1b>
nopl (%rax)
mov %rsi,%rcx
mov (%rdx,%rcx,4),%esi
cmp %eax,%esi
jle 1218 <func0+0x28>
mov (%rdi,%rcx,8),%r9
mov %esi,%eax
lea 0x1(%rcx),%rsi
c... | func0:
endbr64
test esi, esi
jle short loc_14A8
movsxd rsi, esi
xor ecx, ecx
xor r9d, r9d
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1488:
mov r8d, [rdx+rcx*4]
cmp r8d, eax
jle short loc_1498
mov r9, [rdi+rcx*8]
mov eax, r8d
loc_1498:
add rcx, 1
cmp rcx, rsi
jnz ... | long long func0(long long a1, int a2, long long a3)
{
long long v3; // rcx
long long result; // rax
int v5; // r8d
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
result = 0LL;
do
{
v5 = *(_DWORD *)(a3 + 4 * v3);
if ( v5 > (int)result )
result = (unsigned int)v5;
++v3;
}
while ( v3 != a... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014a8
MOVSXD RSI,ESI
XOR ECX,ECX
XOR R9D,R9D
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101488:
MOV R8D,dword ptr [RDX + RCX*0x4]
CMP R8D,EAX
JLE 0x00101498
MOV R9,qword ptr [RDI + RCX*0x8]
MOV EAX,R8D
LAB_00101498:
ADD RCX,0x1
CMP RCX,RSI
JNZ 0x00101488
MOV RDX,R9
RET
LAB_00101... | int1 [16] func0(long param_1,int param_2,long param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
int1 auVar5 [16];
if (0 < param_2) {
lVar3 = 0;
uVar4 = 0;
uVar2 = 0;
do {
uVar1 = *(uint *)(param_3 + lVar3 * 4);
if ((int)uVar2 < (int)uVar1) {
uVar4 = *(int8 ... |
5,055 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef struct {
int length;
int *array;
} Result;
void compareArrays(int *array1, int *array2, int size) {
for (int i = 0; i < size; i++) {
assert(array1[i] == array2[i]);
}
}
| Result func0(int **list, int size, int *sizes) {
Result result;
int maxLength = 0;
int *maxList = NULL;
for (int i = 0; i < size; i++) {
if (sizes[i] > maxLength) {
maxLength = sizes[i];
maxList = list[i];
}
}
result.length = maxLength;
... | int main() {
int arr1[] = {0};
int arr2[] = {1, 3};
int arr3[] = {5, 7};
int arr4[] = {9, 11};
int arr5[] = {13, 15, 17};
int *list1[] = {arr1, arr2, arr3, arr4, arr5};
int sizes1[] = {1, 2, 2, 2, 3};
Result res1 = func0(list1, 5, sizes1);
assert(res1.length == 3);
co... | O3 | c | func0:
endbr64
test %esi,%esi
jle 13b8 <func0+0x38>
lea -0x1(%rsi),%r8d
xor %ecx,%ecx
xor %r9d,%r9d
xor %eax,%eax
jmp 139b <func0+0x1b>
nopl (%rax)
mov %rsi,%rcx
mov (%rdx,%rcx,4),%esi
cmp %eax,%esi
jle 13a8 <func0+0x28>
mov (%rdi,%rcx,8),%r9
mov %esi,%eax
lea 0x1(%rcx),%rsi
c... | func0:
endbr64
test esi, esi
jle short loc_1248
movsxd rsi, esi
xor ecx, ecx
xor r9d, r9d
xor eax, eax
nop word ptr [rax+rax+00h]
loc_1228:
mov r8d, [rdx+rcx*4]
cmp r8d, eax
jle short loc_1238
mov r9, [rdi+rcx*8]
mov eax, r8d
loc_1238:
add rcx, 1
cmp rsi, rcx
jnz ... | long long func0(long long a1, int a2, long long a3)
{
long long v3; // rcx
long long result; // rax
int v5; // r8d
if ( a2 <= 0 )
return 0LL;
v3 = 0LL;
result = 0LL;
do
{
v5 = *(_DWORD *)(a3 + 4 * v3);
if ( v5 > (int)result )
result = (unsigned int)v5;
++v3;
}
while ( a2 != v... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101248
MOVSXD RSI,ESI
XOR ECX,ECX
XOR R9D,R9D
XOR EAX,EAX
NOP word ptr [RAX + RAX*0x1]
LAB_00101228:
MOV R8D,dword ptr [RDX + RCX*0x4]
CMP R8D,EAX
JLE 0x00101238
MOV R9,qword ptr [RDI + RCX*0x8]
MOV EAX,R8D
LAB_00101238:
ADD RCX,0x1
CMP RSI,RCX
JNZ 0x00101228
MOV RDX,R9
RET
LAB_00101... | int [16] func0(long param_1,int param_2,long param_3)
{
uint uVar1;
ulong uVar2;
long lVar3;
int8 uVar4;
int auVar5 [16];
if (0 < param_2) {
lVar3 = 0;
uVar4 = 0;
uVar2 = 0;
do {
uVar1 = *(uint *)(param_3 + lVar3 * 4);
if ((int)uVar2 < (int)uVar1) {
uVar4 = *(int8 *)... |
5,056 | func0 |
#include <assert.h>
#include <stdio.h>
#define MOD 1000000007
| int func0(int n, int k) {
int dp[n + 1];
dp[0] = 0;
dp[1] = k;
dp[2] = k * k;
for (int i = 3; i <= n; i++) {
dp[i] = ((k - 1) * (dp[i - 1] + dp[i - 2])) % MOD;
}
return dp[n];
}
| int main() {
assert(func0(2, 4) == 16);
assert(func0(3, 2) == 6);
assert(func0(4, 4) == 228);
printf("All test cases passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %edi,-0x34(%rbp)
mov %esi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rdi
mov -0x34(%rbp),%eax
add $0x1,%eax
movslq %eax,%rdx
sub $0x1,%rdx
mov %rdx,-0x28(%rbp)
mov... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_24], edi
mov [rbp+var_28], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, rsp
mov rdi, rax
mov eax, [rbp+var_24]
add eax, 1
movsxd rdx, eax
sub rdx, 1
mov [rbp+var_18], rdx
cdqe
lea ... | long long func0(int a1, int a2)
{
unsigned long long v2; // rax
void *v3; // rsp
_DWORD v5[2]; // [rsp+8h] [rbp-30h] BYREF
int v6; // [rsp+10h] [rbp-28h]
int v7; // [rsp+14h] [rbp-24h]
int i; // [rsp+1Ch] [rbp-1Ch]
long long v9; // [rsp+20h] [rbp-18h]
_DWORD *v10; // [rsp+28h] [rbp-10h]
unsigned long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x24],EDI
MOV dword ptr [RBP + -0x28],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RDI,RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOVSXD RDX,EAX
SUB RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
CDQE
LEA ... | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *puVar3;
long in_FS_OFFSET;
int auStack_38 [8];
int local_30;
int local_2c;
int local_24;
long local_20;
int *local_18;
long local_10;
local_2c = param_1;
local_30 = param_2;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
l... |
5,057 | func0 |
#include <assert.h>
#include <stdio.h>
#define MOD 1000000007
| int func0(int n, int k) {
int dp[n + 1];
dp[0] = 0;
dp[1] = k;
dp[2] = k * k;
for (int i = 3; i <= n; i++) {
dp[i] = ((k - 1) * (dp[i - 1] + dp[i - 2])) % MOD;
}
return dp[n];
}
| int main() {
assert(func0(2, 4) == 16);
assert(func0(3, 2) == 6);
assert(func0(4, 4) == 228);
printf("All test cases passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffffff0,%rdx
and $0xfffffffffffff000,%rax
mov %rsp,%rcx
sub %rax,%rcx
mov %rcx,%rax
cmp %rax,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov r8d, edi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [rdi+1]
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rcx, 0FFFFFFFFFFFFFFF0h
and rax, 0FFFFFFFFFFFFF000h
mov rdx, rsp
sub rdx, rax
loc_11C7:
cm... | long long func0(int a1, int a2)
{
signed long long v3; // rax
void *v4; // rsp
unsigned long long v5; // rax
char *v6; // rcx
char *v7; // rdi
int v8; // esi
_BYTE v11[3]; // [rsp+8h] [rbp-10h] BYREF
char v12; // [rsp+Bh] [rbp-Dh] BYREF
int v13; // [rsp+Ch] [rbp-Ch] BYREF
unsigned long long v14; //... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV R8D,EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[RDI + 0x1]
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,-0x10
AND RAX,-0x1000
MOV RDX,RSP
SUB RDX,RAX
LAB_001011c7:
CMP RSP,RDX
JZ 0x001011de
SUB RSP,0x1000
OR qword ptr [RSP ... | int4 func0(int param_1,int param_2)
{
long lVar1;
ulong uVar2;
int *piVar3;
int1 *puVar4;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = (long)(param_1 + 1) * 4 + 0xf;
for (puVar4 = auStack_18; puVar4 != auStack_18 + -(uVar2 & 0xffffffff... |
5,058 | func0 |
#include <assert.h>
#include <stdio.h>
#define MOD 1000000007
| int func0(int n, int k) {
int dp[n + 1];
dp[0] = 0;
dp[1] = k;
dp[2] = k * k;
for (int i = 3; i <= n; i++) {
dp[i] = ((k - 1) * (dp[i - 1] + dp[i - 2])) % MOD;
}
return dp[n];
}
| int main() {
assert(func0(2, 4) == 16);
assert(func0(3, 2) == 6);
assert(func0(4, 4) == 228);
printf("All test cases passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%... | func0:
endbr64
push rbp
movsxd r9, edi
mov edx, esi
mov rbp, rsp
sub rsp, 10h
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea eax, [r9+1]
mov rsi, rsp
cdqe
lea rax, ds:0Fh[rax*4]
mov rcx, rax
and rax, 0FFFFFFFFFFFFF000h
sub rsi, rax
and rcx, 0FFFFFFFFFFFFFFF... | long long func0(int a1, int a2)
{
long long v3; // rcx
_BYTE *v4; // rsi
__int16 v5; // cx
signed long long v6; // rcx
void *v7; // rsp
int v8; // eax
unsigned long long v9; // rcx
int v10; // r8d
int *i; // rcx
_BYTE v14[3]; // [rsp+8h] [rbp-1010h] BYREF
char v15; // [rsp+Bh] [rbp-100Dh] BYREF
... | func0:
ENDBR64
PUSH RBP
MOVSXD R9,EDI
MOV EDX,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA EAX,[R9 + 0x1]
MOV RSI,RSP
CDQE
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RAX,-0x1000
SUB RSI,RAX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x001012ab
LAB_00101296:
SUB RSP,0x1000
OR qw... | int4 func0(int param_1,int param_2)
{
int iVar1;
long lVar2;
int1 *puVar3;
int iVar4;
ulong uVar5;
int *piVar6;
int1 *puVar7;
long in_FS_OFFSET;
int1 auStack_18 [8];
long local_10;
int1 *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(param_1 + 1) *... |
5,059 | func0 |
#include <assert.h>
#include <stdio.h>
#define MOD 1000000007
| int func0(int n, int k) {
int dp[n + 1];
dp[0] = 0;
dp[1] = k;
dp[2] = k * k;
for (int i = 3; i <= n; i++) {
dp[i] = ((k - 1) * (dp[i - 1] + dp[i - 2])) % MOD;
}
return dp[n];
}
| int main() {
assert(func0(2, 4) == 16);
assert(func0(3, 2) == 6);
assert(func0(4, 4) == 228);
printf("All test cases passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea 0x1(%rdi),%eax
mov %rsp,%rcx
cltq
lea 0xf(,%rax,4),%rax
mov %rax,%rdx
and $0xfffffffffffff000,%rax
sub %rax,%rcx
and $0xfffffffffffffff0,%rdx
mov %rcx,%rax
cmp %rax,%... | func0:
endbr64
push rbp
mov eax, esi
mov rbp, rsp
sub rsp, 10h
mov rdx, fs:28h
mov [rbp+var_8], rdx
xor edx, edx
lea edx, [rdi+1]
mov rsi, rsp
movsxd rdx, edx
lea rdx, ds:0Fh[rdx*4]
mov rcx, rdx
and rdx, 0FFFFFFFFFFFFF000h
sub rsi, rdx
and rcx, 0FFFFFFFFFFFFFFF0h
... | long long func0(int a1, int a2)
{
long long v3; // rcx
_BYTE *v4; // rsi
__int16 v5; // cx
signed long long v6; // rcx
void *v7; // rsp
int v8; // edx
unsigned long long v9; // rcx
int v10; // r8d
long long v11; // r9
long long v12; // rcx
_BYTE v15[3]; // [rsp+8h] [rbp-1010h] BYREF
char v16; /... | func0:
ENDBR64
PUSH RBP
MOV EAX,ESI
MOV RBP,RSP
SUB RSP,0x10
MOV RDX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RDX
XOR EDX,EDX
LEA EDX,[RDI + 0x1]
MOV RSI,RSP
MOVSXD RDX,EDX
LEA RDX,[0xf + RDX*0x4]
MOV RCX,RDX
AND RDX,-0x1000
SUB RSI,RDX
AND RCX,-0x10
CMP RSP,RSI
JZ 0x001012a9
LAB_00101294:
SUB RSP,0x1000
OR qword... | int4 func0(int param_1,int param_2)
{
int iVar1;
long lVar2;
int *puVar3;
int iVar4;
ulong uVar5;
int iVar6;
int *puVar7;
long lVar9;
long in_FS_OFFSET;
int auStack_18 [8];
long local_10;
int *puVar8;
puVar7 = auStack_18;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
uVar5 = (long)(param_... |
5,060 | func0 | #include <assert.h>
| int func0(int n, int m) {
int q = n / m;
return q;
}
| int main() {
assert(func0(10, 3) == 3);
assert(func0(4, 2) == 2);
assert(func0(20, 5) == 4);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
cltd
idivl -0x18(%rbp)
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_18]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
pop rbp
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 / a2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET | int func0(int param_1,int param_2)
{
return param_1 / param_2;
} |
5,061 | func0 | #include <assert.h>
| int func0(int n, int m) {
int q = n / m;
return q;
}
| int main() {
assert(func0(10, 3) == 3);
assert(func0(4, 2) == 2);
assert(func0(20, 5) == 4);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
retq
| func0:
endbr64
mov eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 / a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2)
{
int1 auVar1 [16];
auVar1._0_8_ = (long)param_1 / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)param_1 % (long)param_2 & 0xffffffff;
return auVar1;
} |
5,062 | func0 | #include <assert.h>
| int func0(int n, int m) {
int q = n / m;
return q;
}
| int main() {
assert(func0(10, 3) == 3);
assert(func0(4, 2) == 2);
assert(func0(20, 5) == 4);
return 0;
}
| O2 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 / a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
RET | int1 [16] func0(int param_1,int param_2)
{
int1 auVar1 [16];
auVar1._0_8_ = (long)param_1 / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)param_1 % (long)param_2 & 0xffffffff;
return auVar1;
} |
5,063 | func0 | #include <assert.h>
| int func0(int n, int m) {
int q = n / m;
return q;
}
| int main() {
assert(func0(10, 3) == 3);
assert(func0(4, 2) == 2);
assert(func0(20, 5) == 4);
return 0;
}
| O3 | c | func0:
endbr64
mov %edi,%eax
cltd
idiv %esi
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
mov eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2)
{
return (unsigned int)(a1 / a2);
} | func0:
ENDBR64
MOV EAX,EDI
CDQ
IDIV ESI
RET | int [16] func0(int param_1,int param_2)
{
int auVar1 [16];
auVar1._0_8_ = (long)param_1 / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)param_1 % (long)param_2 & 0xffffffff;
return auVar1;
} |
5,064 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int w, int h) {
double s = sqrt((w * w) + (h * h));
return s;
}
| int main() {
assert(func0(7, 8) == 10.63014581273465);
assert(func0(3, 4) == 5);
assert(func0(7, 15) == 16.55294535724685);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov -0x14(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x18(%rbp),%eax
imul %eax,%eax
add %edx,%eax
cvtsi2sd %eax,%xmm0
callq 1070 <sqrt@plt>
movq %xmm0,%rax
mov %rax,-0x8(%rbp)
movsd -0x... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov eax, [rbp+var_14]
imul eax, eax
mov edx, eax
mov eax, [rbp+var_18]
imul eax, eax
add eax, edx
pxor xmm1, xmm1
cvtsi2sd xmm1, eax
movq rax, xmm1
movq xmm0, rax; x
call _s... | long long func0(int a1, int a2)
{
return sqrt((double)(a1 * a1 + a2 * a2));
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV EAX,dword ptr [RBP + -0x14]
IMUL EAX,EAX
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x18]
IMUL EAX,EAX
ADD EAX,EDX
PXOR XMM1,XMM1
CVTSI2SD XMM1,EAX
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101070
MOVQ RAX,XMM0
MO... | double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = sqrt((double)(param_2 * param_2 + param_1 * param_1));
return dVar1;
} |
5,065 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int w, int h) {
double s = sqrt((w * w) + (h * h));
return s;
}
| int main() {
assert(func0(7, 8) == 10.63014581273465);
assert(func0(3, 4) == 5);
assert(func0(7, 15) == 16.55294535724685);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x18,%rsp
imul %edi,%edi
imul %esi,%esi
add %esi,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
movapd %xmm0,%xmm2
sqrtsd %xmm2,%xmm2
movsd %xmm2,0x8(%rsp)
pxor %xmm1,%xmm1
ucomisd %xmm0,%xmm1
ja 1184 <func0+0x3b>
movsd 0x8(%rsp),%xmm0
add $0x18,%rsp
retq
callq 1050 <sqrt@plt>
jmp... | func0:
endbr64
imul edi, edi
imul esi, esi
add edi, esi
pxor xmm0, xmm0
cvtsi2sd xmm0, edi
pxor xmm1, xmm1
ucomisd xmm1, xmm0
ja short loc_116C
sqrtsd xmm0, xmm0
retn
loc_116C:
sub rsp, 8
call _sqrt
add rsp, 8
retn | double func0(int a1, int a2)
{
double v2; // xmm0_8
v2 = (double)(a2 * a2 + a1 * a1);
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
IMUL EDI,EDI
IMUL ESI,ESI
ADD EDI,ESI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDI
PXOR XMM1,XMM1
UCOMISD XMM1,XMM0
JA 0x0010116c
SQRTSD XMM0,XMM0
RET
LAB_0010116c:
SUB RSP,0x8
CALL 0x00101050
ADD RSP,0x8
RET | double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = (double)(param_1 * param_1 + param_2 * param_2);
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
5,066 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int w, int h) {
double s = sqrt((w * w) + (h * h));
return s;
}
| int main() {
assert(func0(7, 8) == 10.63014581273465);
assert(func0(3, 4) == 5);
assert(func0(7, 15) == 16.55294535724685);
return 0;
}
| O2 | c | func0:
endbr64
imul %edi,%edi
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
imul %esi,%esi
add %esi,%edi
cvtsi2sd %edi,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 118b <func0+0x2b>
movapd %xmm1,%xmm0
retq
sub $0x18,%rsp
movsd %xmm1,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
ad... | func0:
endbr64
imul edi, edi
pxor xmm0, xmm0
pxor xmm1, xmm1
imul esi, esi
add edi, esi
cvtsi2sd xmm0, edi
ucomisd xmm1, xmm0
ja short loc_1183
sqrtsd xmm0, xmm0
retn
loc_1183:
jmp _sqrt | double func0(int a1, int a2)
{
double v2; // xmm0_8
v2 = (double)(a2 * a2 + a1 * a1);
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
IMUL EDI,EDI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
IMUL ESI,ESI
ADD EDI,ESI
CVTSI2SD XMM0,EDI
UCOMISD XMM1,XMM0
JA 0x00101183
SQRTSD XMM0,XMM0
RET
LAB_00101183:
JMP 0x00101050 | double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = (double)(param_1 * param_1 + param_2 * param_2);
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
5,067 | func0 |
#include <math.h>
#include <assert.h>
| double func0(int w, int h) {
double s = sqrt((w * w) + (h * h));
return s;
}
| int main() {
assert(func0(7, 8) == 10.63014581273465);
assert(func0(3, 4) == 5);
assert(func0(7, 15) == 16.55294535724685);
return 0;
}
| O3 | c | func0:
endbr64
imul %edi,%edi
pxor %xmm0,%xmm0
pxor %xmm2,%xmm2
imul %esi,%esi
add %esi,%edi
cvtsi2sd %edi,%xmm0
ucomisd %xmm0,%xmm2
movapd %xmm0,%xmm1
sqrtsd %xmm1,%xmm1
ja 118b <func0+0x2b>
movapd %xmm1,%xmm0
retq
sub $0x18,%rsp
movsd %xmm1,0x8(%rsp)
callq 1050 <sqrt@plt>
movsd 0x8(%rsp),%xmm1
ad... | func0:
endbr64
imul edi, edi
pxor xmm0, xmm0
pxor xmm1, xmm1
imul esi, esi
add edi, esi
cvtsi2sd xmm0, edi; x
ucomisd xmm1, xmm0
ja short loc_1183
sqrtsd xmm0, xmm0
retn
loc_1183:
jmp _sqrt | double func0(int a1, int a2)
{
double v2; // xmm0_8
v2 = (double)(a2 * a2 + a1 * a1);
if ( v2 < 0.0 )
return sqrt(v2);
else
return sqrt(v2);
} | func0:
ENDBR64
IMUL EDI,EDI
PXOR XMM0,XMM0
PXOR XMM1,XMM1
IMUL ESI,ESI
ADD EDI,ESI
CVTSI2SD XMM0,EDI
UCOMISD XMM1,XMM0
JA 0x00101183
SQRTSD XMM0,XMM0
RET
LAB_00101183:
JMP 0x00101050 | double func0(int param_1,int param_2)
{
double dVar1;
dVar1 = (double)(param_1 * param_1 + param_2 * param_2);
if (0.0 <= dVar1) {
return SQRT(dVar1);
}
dVar1 = sqrt(dVar1);
return dVar1;
} |
5,068 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int listval[], int size){
int max_val = INT_MIN;
for(int i = 0; i < size; i++){
if(listval[i] > max_val){
max_val = listval[i];
}
}
return max_val;
}
| int main() {
int array1[] = {3, 2, 4, 5};
int size1 = sizeof(array1)/sizeof(array1[0]);
int array2[] = {15, 20, 25};
int size2 = sizeof(array2)/sizeof(array2[0]);
int array3[] = {30, 20, 40, 50};
int size3 = sizeof(array3)/sizeof(array3[0]);
assert(func0(array1, size1) == 5);
... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x80000000,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11c0 <func0+0x57>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jge 11bc <f... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 80000000h
mov [rbp+var_4], 0
jmp short loc_11C0
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]
cmp [rbp+var_8],... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x80000000;
for ( i = 0; i < a2; ++i )
{
if ( (signed int)v3 < *(_DWORD *)(4LL * i + a1) )
v3 = *(_DWORD *)(4LL * i + a1);
}
return v3;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x80000000
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011c0
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]
... | int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = -0x80000000;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if (local_10 < *(int *)(param_1 + (long)local_c * 4)) {
local_10 = *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
} |
5,069 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int listval[], int size){
int max_val = INT_MIN;
for(int i = 0; i < size; i++){
if(listval[i] > max_val){
max_val = listval[i];
}
}
return max_val;
}
| int main() {
int array1[] = {3, 2, 4, 5};
int size1 = sizeof(array1)/sizeof(array1[0]);
int array2[] = {15, 20, 25};
int size2 = sizeof(array2)/sizeof(array2[0]);
int array3[] = {30, 20, 40, 50};
int size3 = sizeof(array3)/sizeof(array3[0]);
assert(func0(array1, size1) == 5);
... | O1 | c | func0:
endbr64
test %esi,%esi
jle 1194 <func0+0x2b>
mov %rdi,%rax
lea -0x1(%rsi),%edx
lea 0x4(%rdi,%rdx,4),%rsi
mov $0x80000000,%edx
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1181 <func0+0x18>
mov %edx,%eax
retq
mov $0x80000000,%edx
jmp 1191 ... | func0:
endbr64
test esi, esi
jle short loc_1194
mov rax, rdi
lea edx, [rsi-1]
lea rsi, [rdi+rdx*4+4]
mov edx, 80000000h
loc_1181:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
add rax, 4
cmp rax, rsi
jnz short loc_1181
loc_1191:
mov eax, edx
retn
loc_1194:
mov edx, 8000... | long long func0(unsigned int *a1, int a2)
{
unsigned int *v2; // rax
long long v3; // rsi
unsigned int v4; // edx
if ( a2 <= 0 )
{
return 0x80000000;
}
else
{
v2 = a1;
v3 = (long long)&a1[a2 - 1 + 1];
v4 = 0x80000000;
do
{
if ( (int)v4 < (int)*v2 )
v4 = *v2;
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101194
MOV RAX,RDI
LEA EDX,[RSI + -0x1]
LEA RSI,[RDI + RDX*0x4 + 0x4]
MOV EDX,0x80000000
LAB_00101181:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101181
LAB_00101191:
MOV EAX,EDX
RET
LAB_00101194:
MOV EDX,0x80000000
JMP 0x00101191 | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = -0x80000000;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = -0x80000000;
do {
if (iVar2 < *param_1) {
iVar2 = *param_1;
}
param_1 = param_1 + 1;
} while (pa... |
5,070 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int listval[], int size){
int max_val = INT_MIN;
for(int i = 0; i < size; i++){
if(listval[i] > max_val){
max_val = listval[i];
}
}
return max_val;
}
| int main() {
int array1[] = {3, 2, 4, 5};
int size1 = sizeof(array1)/sizeof(array1[0]);
int array2[] = {15, 20, 25};
int size2 = sizeof(array2)/sizeof(array2[0]);
int array3[] = {30, 20, 40, 50};
int size3 = sizeof(array3)/sizeof(array3[0]);
assert(func0(array1, size1) == 5);
... | O2 | c | func0:
endbr64
test %esi,%esi
jle 1170 <func0+0x30>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rcx
mov $0x80000000,%eax
nopl (%rax)
mov (%rdi),%edx
cmp %edx,%eax
cmovl %edx,%eax
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
retq
nopl 0x0(%rax)
mov $0x80000000,%eax
retq
nopw %cs... | func0:
endbr64
test esi, esi
jle short loc_1170
lea eax, [rsi-1]
lea rcx, [rdi+rax*4+4]
mov eax, 80000000h
nop dword ptr [rax]
loc_1158:
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
add rdi, 4
cmp rdi, rcx
jnz short loc_1158
retn
loc_1170:
mov eax, 80000000h
retn | long long func0(_DWORD *a1, int a2)
{
long long v2; // rcx
long long result; // rax
if ( a2 <= 0 )
return 0x80000000LL;
v2 = (long long)&a1[a2 - 1 + 1];
result = 0x80000000LL;
do
{
if ( (int)result < *a1 )
result = (unsigned int)*a1;
++a1;
}
while ( a1 != (_DWORD *)v2 );
return r... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101170
LEA EAX,[RSI + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x80000000
NOP dword ptr [RAX]
LAB_00101158:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
ADD RDI,0x4
CMP RDI,RCX
JNZ 0x00101158
RET
LAB_00101170:
MOV EAX,0x80000000
RET | int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 1) + 1;
iVar2 = -0x80000000;
do {
if (iVar2 < *param_1) {
iVar2 = *param_1;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
return iVar2;
... |
5,071 | func0 |
#include <assert.h>
#include <limits.h>
| int func0(int listval[], int size){
int max_val = INT_MIN;
for(int i = 0; i < size; i++){
if(listval[i] > max_val){
max_val = listval[i];
}
}
return max_val;
}
| int main() {
int array1[] = {3, 2, 4, 5};
int size1 = sizeof(array1)/sizeof(array1[0]);
int array2[] = {15, 20, 25};
int size2 = sizeof(array2)/sizeof(array2[0]);
int array3[] = {30, 20, 40, 50};
int size3 = sizeof(array3)/sizeof(array3[0]);
assert(func0(array1, size1) == 5);
... | O3 | c | func0:
endbr64
test %esi,%esi
jle 1210 <func0+0xd0>
lea -0x1(%rsi),%eax
cmp $0x2,%eax
jbe 1221 <func0+0xe1>
mov %esi,%edx
movdqa 0xeae(%rip),%xmm2
mov %rdi,%rax
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
movdqu (%rax),%xmm0
add $0x10,%rax
movdqa %xmm0,%xmm1
pcmpgtd %xmm2,%xmm1
pand %xmm... | func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1220
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1231
mov edx, esi
movdqa xmm2, cs:xmmword_2010
mov rax, rdi
shr edx, 2
shl rdx, 4
add rdx, rdi
nop dword ptr [rax+00000000h]
loc_1178:
movdqu xmm0, xmmword ptr [rax]
add rax, 1... | long long func0(const __m128i *a1, int a2)
{
__m128i si128; // xmm2
const __m128i *v4; // rax
__m128i v5; // xmm0
__m128i v6; // xmm1
__m128i v7; // xmm0
signed int v8; // edx
__m128i v9; // xmm1
__m128i v10; // xmm1
__m128i v11; // xmm2
__m128i v12; // xmm0
long long result; // rax
long long v... | func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101220
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101231
MOV EDX,ESI
MOVDQA XMM2,xmmword ptr [0x00102010]
MOV RAX,RDI
SHR EDX,0x2
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101178:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM2
PAND XMM... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint *puVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13... |
5,072 | func0 |
#include <assert.h>
| int func0(int number) {
int sum = 1;
for (int i = 2; i < number; i++) {
if (number % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(8) == 7);
assert(func0(12) == 16);
assert(func0(7) == 1);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x2,-0x4(%rbp)
jmp 117b <func0+0x32>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 1177 <func0+0x2e>
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 1
mov [rbp+var_4], 2
jmp short loc_117B
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_1177:
add ... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 1;
for ( i = 2; i < a1; ++i )
{
if ( !(a1 % i) )
v2 += i;
}
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0010117b
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8]... | int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 1;
for (local_c = 2; local_c < param_1; local_c = local_c + 1) {
if (param_1 % local_c == 0) {
local_10 = local_10 + local_c;
}
}
return local_10;
} |
5,073 | func0 |
#include <assert.h>
| int func0(int number) {
int sum = 1;
for (int i = 2; i < number; i++) {
if (number % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(8) == 7);
assert(func0(12) == 16);
assert(func0(7) == 1);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x2,%edi
jle 1173 <func0+0x2a>
mov $0x2,%ecx
mov $0x1,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 115c <func0+0x13>
mov %esi,%eax
retq
mov $0x1,%esi
jmp 1170 <func0+0x27>
| func0:
endbr64
cmp edi, 2
jle short loc_1173
mov ecx, 2
mov esi, 1
loc_115C:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_115C
loc_1170:
mov eax, esi
retn
loc_1173:
mov esi, 1
jmp short loc_1170 | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 2 )
{
return 1;
}
else
{
v1 = 2;
v2 = 1;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
}
return v2;
} | func0:
ENDBR64
CMP EDI,0x2
JLE 0x00101173
MOV ECX,0x2
MOV ESI,0x1
LAB_0010115c:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010115c
LAB_00101170:
MOV EAX,ESI
RET
LAB_00101173:
MOV ESI,0x1
JMP 0x00101170 | int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 3) {
iVar2 = 1;
}
else {
iVar1 = 2;
iVar2 = 1;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return iVar2;
} |
5,074 | func0 |
#include <assert.h>
| int func0(int number) {
int sum = 1;
for (int i = 2; i < number; i++) {
if (number % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(8) == 7);
assert(func0(12) == 16);
assert(func0(7) == 1);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%edi
jle 1238 <func0+0x38>
mov $0x2,%ecx
mov $0x1,%r8d
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%ecx
cmp %ecx,%edi
jne 1218 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%r... | func0:
endbr64
cmp edi, 2
jle short loc_1238
mov ecx, 2
mov r8d, 1
nop dword ptr [rax+00h]
loc_1218:
mov eax, edi
cdq
idiv ecx
lea eax, [r8+rcx]
test edx, edx
cmovz r8d, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1218
mov eax, r8d
retn
loc_1238:
mov r8d, 1
mov ... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // r8d
if ( a1 <= 2 )
return 1LL;
v1 = 2;
v2 = 1;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return v2;
} | func0:
ENDBR64
CMP EDI,0x2
JLE 0x00101238
MOV ECX,0x2
MOV R8D,0x1
NOP dword ptr [RAX]
LAB_00101218:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[R8 + RCX*0x1]
TEST EDX,EDX
CMOVZ R8D,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101218
MOV EAX,R8D
RET
LAB_00101238:
MOV R8D,0x1
MOV EAX,R8D
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (2 < param_1) {
iVar1 = 2;
iVar2 = 1;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return iVar2;
}
return 1;
} |
5,075 | func0 |
#include <assert.h>
| int func0(int number) {
int sum = 1;
for (int i = 2; i < number; i++) {
if (number % i == 0) {
sum += i;
}
}
return sum;
}
| int main() {
assert(func0(8) == 7);
assert(func0(12) == 16);
assert(func0(7) == 1);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%edi
jle 1178 <func0+0x38>
mov $0x2,%ecx
mov $0x1,%r8d
nopl 0x0(%rax)
mov %edi,%eax
cltd
idiv %ecx
lea (%r8,%rcx,1),%eax
test %edx,%edx
cmove %eax,%r8d
add $0x1,%ecx
cmp %ecx,%edi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
mov $0x1,%r... | func0:
endbr64
cmp edi, 2
jle short loc_1170
mov ecx, 2
mov esi, 1
nop dword ptr [rax+rax+00h]
loc_1158:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1158
mov eax, esi
retn
loc_1170:
mov esi, 1
mov... | long long func0(int a1)
{
int v1; // ecx
unsigned int v2; // esi
if ( a1 <= 2 )
return 1LL;
v1 = 2;
v2 = 1;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return v2;
} | func0:
ENDBR64
CMP EDI,0x2
JLE 0x00101170
MOV ECX,0x2
MOV ESI,0x1
NOP dword ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101158
MOV EAX,ESI
RET
LAB_00101170:
MOV ESI,0x1
MOV EAX,ESI
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
if (2 < param_1) {
iVar1 = 2;
iVar2 = 1;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return iVar2;
}
return 1;
} |
5,076 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count += 1;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
int arr2[] = {1, 2, 1};
int arr3[] = {1, 2, 5, 6, 1};
assert(func0(arr1, 5) == 5);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 3);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d7 <func0+0x6e>
mov -0x8(%rbp),%eax
add $0x1,%eax
mov %eax,-0x4(%rbp)
jmp 11cb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rb... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1188:
mov eax, [rbp+var_8]
add eax, 1
mov [rbp+var_4], eax
jmp short loc_11CB
loc_1193:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0... | long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+10h] [rbp-Ch]
int i; // [rsp+14h] [rbp-8h]
int j; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
for ( j = i + 1; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * i + a1) > *(_DWORD *)(4LL * j + a1) )
++v3;
}
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,0x1
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001011cb
LAB_00101193:
MOV EAX,dword ptr [RBP + -... | int func0(long param_1,int param_2)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
for (local_10 = 0; local_c = local_10, local_10 < param_2; local_10 = local_10 + 1) {
while (local_c = local_c + 1, local_c < param_2) {
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + ... |
5,077 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count += 1;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
int arr2[] = {1, 2, 1};
int arr3[] = {1, 2, 5, 6, 1};
assert(func0(arr1, 5) == 5);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 3);
return 0;
}
| O1 | c | func0:
endbr64
test %esi,%esi
jle 11ab <func0+0x42>
lea -0x1(%rsi),%r9d
add $0x1,%r9
mov $0x1,%r8d
mov $0x0,%ecx
jmp 119c <func0+0x33>
add $0x1,%rax
cmp %eax,%esi
jle 1198 <func0+0x2f>
cmp (%rdi,%rax,4),%edx
jle 1186 <func0+0x1d>
add $0x1,%ecx
jmp 1186 <func0+0x1d>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_11A6
mov r9d, esi
mov r8d, 1
mov ecx, 0
jmp short loc_1197
loc_1181:
add rax, 1
cmp esi, eax
jle short loc_1193
loc_1189:
cmp edx, [rdi+rax*4]
jle short loc_1181
add ecx, 1
jmp short loc_1181
loc_1193:
add r8, 1
loc_1197:
... | long long func0(long long a1, int a2)
{
long long v2; // r8
unsigned int v3; // ecx
long long v4; // rax
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = 1LL;
v3 = 0;
while ( v2 != a2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) > *(_DWORD *)(a1 + 4 * v4) )... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a6
MOV R9D,ESI
MOV R8D,0x1
MOV ECX,0x0
JMP 0x00101197
LAB_00101181:
ADD RAX,0x1
CMP ESI,EAX
JLE 0x00101193
LAB_00101189:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x00101181
ADD ECX,0x1
JMP 0x00101181
LAB_00101193:
ADD R8,0x1
LAB_00101197:
CMP R8,R9
JZ 0x001011ab
MOV EDX,dword ptr [R... | int func0(long param_1,uint param_2)
{
ulong uVar1;
int iVar2;
ulong uVar3;
if ((int)param_2 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
for (uVar3 = 1; uVar3 != param_2; uVar3 = uVar3 + 1) {
uVar1 = uVar3;
do {
if (*(int *)(param_1 + uVar1 * 4) < *(int *)(param_1 + -4 + uVar3 ... |
5,078 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count += 1;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
int arr2[] = {1, 2, 1};
int arr3[] = {1, 2, 5, 6, 1};
assert(func0(arr1, 5) == 5);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 3);
return 0;
}
| O2 | c | func0:
endbr64
test %esi,%esi
jle 137e <func0+0x4e>
lea -0x1(%rsi),%r9d
mov $0x1,%ecx
xor %r8d,%r8d
add $0x1,%r9
cmp %r9,%rcx
je 137a <func0+0x4a>
nopl (%rax)
mov -0x4(%rdi,%rcx,4),%edx
mov %rcx,%rax
nopw 0x0(%rax,%rax,1)
cmp (%rdi,%rax,4),%edx
jle 1369 <func0+0x39>
add $0x1,%... | func0:
endbr64
test esi, esi
jle short loc_12EE
movsxd r9, esi
mov ecx, 1
xor r8d, r8d
cmp rcx, r9
jz short loc_12EA
nop dword ptr [rax+rax+00000000h]
loc_12C0:
mov edx, [rdi+rcx*4-4]
mov rax, rcx
nop word ptr [rax+rax+00000000h]
loc_12D0:
cmp edx, [rdi+rax*4]
jle short ... | long long func0(long long a1, int a2)
{
long long v2; // rcx
unsigned int i; // r8d
long long v4; // rax
if ( a2 <= 0 )
return 0LL;
v2 = 1LL;
for ( i = 0; v2 != a2; ++v2 )
{
v4 = v2;
do
{
if ( *(_DWORD *)(a1 + 4 * v2 - 4) > *(_DWORD *)(a1 + 4 * v4) )
++i;
++v4;
}
... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x001012ee
MOVSXD R9,ESI
MOV ECX,0x1
XOR R8D,R8D
CMP RCX,R9
JZ 0x001012ea
NOP dword ptr [RAX + RAX*0x1]
LAB_001012c0:
MOV EDX,dword ptr [RDI + RCX*0x4 + -0x4]
MOV RAX,RCX
NOP word ptr [RAX + RAX*0x1]
LAB_001012d0:
CMP EDX,dword ptr [RDI + RAX*0x4]
JLE 0x001012d9
ADD R8D,0x1
LAB_001012d9:... | int func0(long param_1,int param_2)
{
long lVar1;
long lVar2;
int iVar3;
if (param_2 < 1) {
return 0;
}
lVar2 = 1;
iVar3 = 0;
if ((long)param_2 != 1) {
do {
lVar1 = lVar2;
do {
if (*(int *)(param_1 + lVar1 * 4) < *(int *)(param_1 + -4 + lVar2 * 4)) {
iVar3 = iVa... |
5,079 | func0 |
#include <assert.h>
| int func0(int arr[], int n) {
int inv_count = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (arr[i] > arr[j]) {
inv_count += 1;
}
}
}
return inv_count;
}
| int main() {
int arr1[] = {1, 20, 6, 4, 5};
int arr2[] = {1, 2, 1};
int arr3[] = {1, 2, 5, 6, 1};
assert(func0(arr1, 5) == 5);
assert(func0(arr2, 3) == 1);
assert(func0(arr3, 5) == 3);
return 0;
}
| O3 | c | func0:
endbr64
test %esi,%esi
jle 143d <func0+0x12d>
cmp $0x1,%esi
je 143d <func0+0x12d>
push %rbp
lea 0x4(%rdi),%r10
xor %r9d,%r9d
mov $0x1,%ecx
push %rbx
lea -0x1(%rsi),%ebp
mov $0x1,%ebx
nopl 0x0(%rax,%rax,1)
mov %esi,%r8d
mov %ebp,%eax
mov -0x4(%r10),%r11d
sub %ecx,%r8d
... | func0:
endbr64
test esi, esi
jle loc_1248
cmp esi, 1
jz loc_1248
push rbp
mov r11, rdi
lea r8, [rdi+4]
xor r9d, r9d
push rbx
mov ecx, 1
lea ebp, [rsi-1]
mov ebx, 1
xchg ax, ax
loc_1170:
mov edi, esi
mov eax, ebp
mov r10d, [r8-4]
sub edi, ecx
cmp esi, ... | long long func0(long long a1, int a2)
{
const __m128i *v3; // r8
unsigned int v4; // r9d
int v5; // ecx
signed int v6; // r10d
unsigned int v7; // edi
__m128i v8; // xmm0
const __m128i *v9; // rax
__m128i v10; // xmm2
__m128i v11; // xmm3
__m128i v12; // xmm0
int v13; // eax
long long v14; // r... | func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101248
CMP ESI,0x1
JZ 0x00101248
PUSH RBP
MOV R11,RDI
LEA R8,[RDI + 0x4]
XOR R9D,R9D
PUSH RBX
MOV ECX,0x1
LEA EBP,[RSI + -0x1]
MOV EBX,0x1
NOP
LAB_00101170:
MOV EDI,ESI
MOV EAX,EBP
MOV R10D,dword ptr [R8 + -0x4]
SUB EDI,ECX
CMP ESI,ECX
CMOVLE EDI,EBX
SUB EAX,ECX
CMP EAX,0x2
JBE 0x001... | int func0(long param_1,int param_2)
{
long lVar1;
int iVar2;
uint uVar3;
int iVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int iVar9;
int *piVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if ((param_2 < 1) || (param_2 == 1)) {
return 0;
}
piVa... |
5,080 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
// Define a dynamic array structure
typedef struct {
int *data;
size_t size;
size_t capacity;
} DynamicArray;
// Initialize dynamic array
void init_array(DynamicArray *arr) {
arr->capacity = 16;
arr->s... | DynamicArray func0(int **list, size_t list_size, size_t *out_size) {
DynamicArray result;
init_array(&result);
if (list_size == 0) {
*out_size = 0;
return result;
}
// Implementing a simple stack using dynamic arrays
typedef struct {
int **data;
size_t... | int main() {
// First test case
int list1_part1[] = {0, 10};
int list1_part2[] = {20, 30};
int list1_part3[] = {40, 50};
int list1_part4[] = {60, 70, 80};
int list1_part5[] = {90, 100, 110, 120};
// For simplicity, we flatten manually
int flattened1[] = {0, 10, 20, 30, 40, 50, 60... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x70,%rsp
mov %rdi,-0x58(%rbp)
mov %rsi,-0x60(%rbp)
mov %rdx,-0x68(%rbp)
mov %rcx,-0x70(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov %rax,%rdi
callq 1229 <init_array>
cmpq $0x0,-0x68(%rbp)
jne 1464... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_70], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+var_40]
mov rdi, rax
call init_array
cmp [rbp+var_68], 0
jnz ... | _QWORD * func0(_QWORD *a1, long long a2, unsigned long long a3, _QWORD *a4)
{
long long v4; // rdx
long long v5; // rax
long long v6; // rax
long long v7; // rdx
unsigned long long i; // [rsp+20h] [rbp-50h]
long long v12; // [rsp+28h] [rbp-48h]
long long v13; // [rsp+30h] [rbp-40h] BYREF
long long v14; ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV qword ptr [RBP + -0x70],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV RDI,RAX
CALL 0x00101229
CMP qword ptr [RBP + -... | int8 * func0(int8 *param_1,int8 param_2,ulong param_3,int8 *param_4)
{
long lVar1;
long in_FS_OFFSET;
ulong local_58;
int8 local_48;
int8 local_40;
int8 local_38;
void *local_28;
long local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
init_array(&local_48);
... |
5,081 | func0 |
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
// Define a dynamic array structure
typedef struct {
int *data;
size_t size;
size_t capacity;
} DynamicArray;
// Initialize dynamic array
void init_array(DynamicArray *arr) {
arr->capacity = 16;
arr->s... | DynamicArray func0(int **list, size_t list_size, size_t *out_size) {
DynamicArray result;
init_array(&result);
if (list_size == 0) {
*out_size = 0;
return result;
}
// Implementing a simple stack using dynamic arrays
typedef struct {
int **data;
size_t... | int main() {
// First test case
int list1_part1[] = {0, 10};
int list1_part2[] = {20, 30};
int list1_part3[] = {40, 50};
int list1_part4[] = {60, 70, 80};
int list1_part5[] = {90, 100, 110, 120};
// For simplicity, we flatten manually
int flattened1[] = {0, 10, 20, 30, 40, 50, 60... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
mov %rsi,%r12
mov %rdx,%r13
mov %rcx,%r14
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%rdi
callq 1209 <init_array>
test %r13,%r13
jne 1384 <func0+0x7a>
mo... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r13, rdi
mov r12, rsi
mov rbp, rdx
mov rbx, rcx
mov [rsp+68h+var_60], rcx
mov rax, fs:28h
mov [rsp+68h+var_40], rax
xor eax, eax
lea rdi, [rsp+68h+var_58]
call init_array
te... | __m128i * func0(__m128i *a1, long long a2, long long a3, _QWORD *a4)
{
_QWORD *v7; // rax
_QWORD *v8; // r14
long long v9; // rbx
__m128i v11; // [rsp+10h] [rbp-58h] BYREF
long long v12; // [rsp+20h] [rbp-48h]
unsigned long long v13; // [rsp+28h] [rbp-40h]
v13 = __readfsqword(0x28u);
init_array(&v11);
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R13,RDI
MOV R12,RSI
MOV RBP,RDX
MOV RBX,RCX
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x10]
CALL 0x00101209
TEST RBP,RBP
JNZ 0x00101387
MOV qword ptr [RBX],0x0
... | int8 * func0(int8 *param_1,long param_2,long param_3,int8 *param_4)
{
int8 *__ptr;
long lVar1;
long in_FS_OFFSET;
int8 local_58;
int8 uStack_50;
int8 local_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
init_array(&local_58);
if (param_3 == 0) {
*param_4 = 0;
}
else {
... |
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.