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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
5,082 | 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... | O2 | c | func0:
endbr64
push %r15
mov %rdx,%r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov %rsp,%r14
mov %r14,%rdi
callq 1270 <init_array>
test %r15,%r15
jne 13f... | func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
mov edi, 40h ; '@'
push rbp
mov rbp, rdx
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_48], rcx
call _malloc
test rax, rax
jz loc_156B
mov r15, rax
test rbp, rbp
jnz short loc_1430
mov ... | int ** func0(int **a1, long long a2, int *a3, unsigned long long *a4)
{
long long v6; // rax
int *v7; // r15
long long v8; // rcx
int **result; // rax
_QWORD *v10; // rax
_QWORD *v11; // r14
long long v12; // rcx
unsigned long long v13; // rbx
long long v14; // rax
long long v15; // rax
long long ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
MOV EDI,0x40
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RCX
CALL 0x001010e0
TEST RAX,RAX
JZ 0x0010156b
MOV R15,RAX
TEST RBP,RBP
JNZ 0x00101430
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,0x10
MOV qword ptr [RAX],0x0
LAB_001... | int8 * func0(int8 *param_1,int8 param_2,long param_3,ulong *param_4)
{
long lVar1;
ulong uVar2;
int4 uVar3;
ulong uVar4;
int4 *__ptr;
int8 *__ptr_00;
long lVar5;
int4 *puVar6;
int4 *puVar7;
ulong uVar8;
int4 *puVar9;
ulong uVar10;
ulong uVar11;
int local_3c;
__ptr = (int4 *)malloc(0x40... |
5,083 | 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... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
mov $0x40,%edi
push %rbp
mov %rdx,%rbp
push %rbx
mov %rsi,%rbx
sub $0x48,%rsp
movdqa 0xbc8(%rip),%xmm0
mov %rcx,0x10(%rsp)
mov %fs:0x28,%rax
mov %rax,0x38(%rsp)
xor %eax,%eax
movups %xmm0,0x28(%rsp)
callq 10e0 <... | func0:
endbr64
push r15
push r14
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
mov edi, 40h ; '@'; size
push rbx
mov rbx, rsi
sub rsp, 48h
movdqa xmm0, cs:xmmword_2080
mov [rsp+78h+var_60], rcx
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
movups x... | long long func0(long long a1, long long a2, long long a3, unsigned long long *a4)
{
__m128i si128; // xmm3
_QWORD *v8; // rax
_QWORD *v9; // r14
long long v10; // r12
unsigned long long v11; // rbx
long long v12; // rdx
__m128i *v13; // rdi
long long v14; // rax
long long v15; // rcx
long long v16;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
MOV EDI,0x40
PUSH RBX
MOV RBX,RSI
SUB RSP,0x48
MOVDQA XMM0,xmmword ptr [0x00102080]
MOV qword ptr [RSP + 0x18],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RSP + 0x28],XMM0
CALL 0x001010... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(int8 *param_1,int8 param_2,long param_3,ulong *param_4)
{
int8 uVar1;
int8 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
int4 uVar8;
int4 uVar9;
int8 *__ptr;
int4 *puVar10;
in... |
5,084 | func0 | #include <stdio.h>
#include <assert.h>
int contains(int arr[], int size, int num) {
for (int i = 0; i < size; i++) {
if (arr[i] == num) {
return 1; // Found the number
}
}
return 0; // Not found
}
| void func0(int l1[], int l1_size, int l2[][5], int l2_sizes[], int result[][5]) {
for (int i = 0; i < 3; i++) { // Assuming there are 3 sublists in l2
int idx = 0;
for (int j = 0; j < l2_sizes[i]; j++) {
if (contains(l1, l1_size, l2[i][j])) {
result[i][idx++] = l2[i... | int main() {
int l1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int l1_size = sizeof(l1) / sizeof(l1[0]);
int l2[3][5] = {
{12, 18, 23, 25, 45},
{7, 11, 19, 24, 28},
{1, 5, 8, 18, 15}
};
int l2_sizes[3] = {5, 5, 5}; // Sizes of each sublist in l2
in... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x38,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %rcx,-0x30(%rbp)
mov %r8,-0x38(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 130a <func0+0x131>
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmpq 12ab <func0+0xd2>
mov -0x10(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 38h
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_30], rcx
mov [rbp+var_38], r8
mov [rbp+var_10], 0
jmp loc_130A
loc_1204:
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp loc_12AB
loc_1217:
mov ... | void func0(long long a1, unsigned int a2, long long a3, long long a4, long long a5)
{
int v5; // eax
int i; // [rsp+28h] [rbp-10h]
int v10; // [rsp+2Ch] [rbp-Ch]
int j; // [rsp+30h] [rbp-8h]
int k; // [rsp+34h] [rbp-4h]
for ( i = 0; i <= 2; ++i )
{
v10 = 0;
for ( j = 0; j < *(_DWORD *)(4LL * i +... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x38
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV qword ptr [RBP + -0x30],RCX
MOV qword ptr [RBP + -0x38],R8
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010130a
LAB_00101204:
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP +... | void func0(int8 param_1,int4 param_2,long param_3,long param_4,long param_5)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
for (local_18 = 0; local_18 < 3; local_18 = local_18 + 1) {
local_14 = 0;
for (local_10 = 0; local_10 < *(int *)(param_4 + (long)local_18 * 4); loc... |
5,085 | func0 | #include <stdio.h>
#include <assert.h>
int contains(int arr[], int size, int num) {
for (int i = 0; i < size; i++) {
if (arr[i] == num) {
return 1; // Found the number
}
}
return 0; // Not found
}
| void func0(int l1[], int l1_size, int l2[][5], int l2_sizes[], int result[][5]) {
for (int i = 0; i < 3; i++) { // Assuming there are 3 sublists in l2
int idx = 0;
for (int j = 0; j < l2_sizes[i]; j++) {
if (contains(l1, l1_size, l2[i][j])) {
result[i][idx++] = l2[i... | int main() {
int l1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int l1_size = sizeof(l1) / sizeof(l1[0]);
int l2[3][5] = {
{12, 18, 23, 25, 45},
{7, 11, 19, 24, 28},
{1, 5, 8, 18, 15}
};
int l2_sizes[3] = {5, 5, 5}; // Sizes of each sublist in l2
in... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,0x30(%rsp)
mov %esi,0x4(%rsp)
mov %rcx,0x10(%rsp)
mov %r8,%r15
mov %rdx,0x18(%rsp)
lea 0x3c(%r8),%rax
mov %rax,0x28(%rsp)
jmp 1257 <func0+0x9c>
add $0x1,%rbp
cmp %ebp,0x0(%r13)... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_38], rdi
mov [rsp+68h+var_64], esi
mov [rsp+68h+var_58], rcx
mov r15, r8
mov [rsp+68h+var_50], rdx
lea rax, [r8+3Ch]
mov [rsp+68h+var_40], rax
jmp short loc_1257
loc_1... | long long func0(long long a1, unsigned int a2, long long a3, int *a4, long long a5)
{
long long v5; // r15
long long v6; // rbp
unsigned int v7; // r12d
long long result; // rax
long long v9; // rbx
long long v12; // [rsp+28h] [rbp-40h]
v5 = a5;
v12 = a5 + 60;
do
{
LODWORD(v9) = 0;
if ( *a... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x4],ESI
MOV qword ptr [RSP + 0x10],RCX
MOV R15,R8
MOV qword ptr [RSP + 0x18],RDX
LEA RAX,[R8 + 0x3c]
MOV qword ptr [RSP + 0x28],RAX
JMP 0x00101257
LAB_001011ee:
ADD RBP,0x1
CMP dword pt... | void func0(int8 param_1,int4 param_2,long param_3,int *param_4,long param_5)
{
long lVar1;
int4 uVar2;
int iVar3;
int iVar4;
long lVar5;
int *local_58;
long local_50;
lVar1 = param_5 + 0x3c;
local_58 = param_4;
local_50 = param_3;
do {
iVar4 = 0;
if (*local_58 < 1) {
LAB_0010122a:
... |
5,086 | func0 | #include <stdio.h>
#include <assert.h>
int contains(int arr[], int size, int num) {
for (int i = 0; i < size; i++) {
if (arr[i] == num) {
return 1; // Found the number
}
}
return 0; // Not found
}
| void func0(int l1[], int l1_size, int l2[][5], int l2_sizes[], int result[][5]) {
for (int i = 0; i < 3; i++) { // Assuming there are 3 sublists in l2
int idx = 0;
for (int j = 0; j < l2_sizes[i]; j++) {
if (contains(l1, l1_size, l2[i][j])) {
result[i][idx++] = l2[i... | int main() {
int l1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int l1_size = sizeof(l1) / sizeof(l1[0]);
int l2[3][5] = {
{12, 18, 23, 25, 45},
{7, 11, 19, 24, 28},
{1, 5, 8, 18, 15}
};
int l2_sizes[3] = {5, 5, 5}; // Sizes of each sublist in l2
in... | O2 | c | func0:
endbr64
lea -0x1(%rsi),%eax
push %r13
mov %rcx,%r9
mov %esi,%r11d
push %r12
mov %r8,%r13
mov %rdx,%r12
lea 0x4(%rdi,%rax,4),%rcx
push %rbp
xor %ebp,%ebp
push %rbx
mov %rdi,%rbx
mov (%r9),%eax
lea 0x0(%r13,%rbp,1),%r10
xor %esi,%esi
test %eax,%eax
jle 1625 <func0+0x75... | func0:
endbr64
lea eax, [rsi-1]
push r14
mov r9, rcx
mov r11d, esi
push r13
mov r10, rdx
lea rcx, [rdi+rax*4+4]
mov r14d, 5
push r12
mov r13d, 4
lea r12, [r8+3Ch]
push rbp
xor ebp, ebp
push rbx
mov rbx, rdi
loc_15E2:
mov eax, [r9]
xor esi, esi
xor edi, ... | long long func0(long long a1, int a2, long long a3, _DWORD *a4, long long a5)
{
long long v8; // rcx
long long v9; // r12
long long result; // rax
long long v12; // rsi
int v13; // edi
int v14; // edx
_QWORD *v15; // rsi
unsigned long long v16; // rdi
unsigned int v17; // edx
long long v18; // rsi
... | func0:
ENDBR64
LEA EAX,[RSI + -0x1]
PUSH R14
MOV R9,RCX
MOV R11D,ESI
PUSH R13
MOV R10,RDX
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV R14D,0x5
PUSH R12
MOV R13D,0x4
LEA R12,[R8 + 0x3c]
PUSH RBP
XOR EBP,EBP
PUSH RBX
MOV RBX,RDI
LAB_001015e2:
MOV EAX,dword ptr [R9]
XOR ESI,ESI
XOR EDI,EDI
TEST EAX,EAX
JLE 0x00101625
NOP dword ptr ... | /* WARNING: Removing unreachable block (ram,0x001016c2) */
void func0(int *param_1,int param_2,long param_3,int *param_4,long param_5)
{
long lVar1;
int8 *puVar2;
int iVar3;
uint uVar4;
int *piVar5;
ulong uVar6;
uint uVar7;
long lVar8;
int iVar9;
int iVar10;
lVar1 = param_5 + 0x3c;
do {
... |
5,087 | func0 | #include <stdio.h>
#include <assert.h>
int contains(int arr[], int size, int num) {
for (int i = 0; i < size; i++) {
if (arr[i] == num) {
return 1; // Found the number
}
}
return 0; // Not found
}
| void func0(int l1[], int l1_size, int l2[][5], int l2_sizes[], int result[][5]) {
for (int i = 0; i < 3; i++) { // Assuming there are 3 sublists in l2
int idx = 0;
for (int j = 0; j < l2_sizes[i]; j++) {
if (contains(l1, l1_size, l2[i][j])) {
result[i][idx++] = l2[i... | int main() {
int l1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14};
int l1_size = sizeof(l1) / sizeof(l1[0]);
int l2[3][5] = {
{12, 18, 23, 25, 45},
{7, 11, 19, 24, 28},
{1, 5, 8, 18, 15}
};
int l2_sizes[3] = {5, 5, 5}; // Sizes of each sublist in l2
in... | O3 | c | func0:
endbr64
lea -0x1(%rsi),%eax
push %r15
mov %rcx,%r10
mov %esi,%r11d
push %r14
lea 0x4(%rdi,%rax,4),%rcx
mov %r8,%r14
xor %r15d,%r15d
push %r13
mov %rdx,%r13
push %r12
push %rbp
xor %ebp,%ebp
push %rbx
mov %rdi,%rbx
mov (%r10),%r8d
lea (%r14,%rbp,1),%r12
xor %edi,%ed... | func0:
endbr64
push r15
lea rax, [r8+3Ch]
mov r15, r8
push r14
mov r14, rdi
push r13
mov r13d, esi
push r12
mov r12, rdx
push rbp
mov rbp, rcx
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rax
movsxd rax, esi
lea rbx, [rdi+rax*4]
loc_15C1:
mov edi, [rbp+0]
xor ... | long long func0(_DWORD *a1, int a2, long long a3, int *a4, long long a5)
{
long long v5; // r15
_DWORD *v10; // rbx
int v11; // edi
long long v12; // rcx
int v13; // esi
int v14; // edx
_DWORD *v15; // rax
long long v16; // rax
long long result; // rax
long long v18; // [rsp+8h] [rbp-40h]
v5 = a... | func0:
ENDBR64
PUSH R15
LEA RAX,[R8 + 0x3c]
MOV R15,R8
PUSH R14
MOV R14,RDI
PUSH R13
MOV R13D,ESI
PUSH R12
MOV R12,RDX
PUSH RBP
MOV RBP,RCX
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RAX,ESI
LEA RBX,[RDI + RAX*0x4]
LAB_001015c1:
MOV EDI,dword ptr [RBP]
XOR ECX,ECX
XOR ESI,ESI
TEST EDI,EDI
JLE 0x00101607... | void func0(int *param_1,int param_2,long param_3,int *param_4,long param_5)
{
long lVar1;
int iVar2;
int *piVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
lVar1 = param_5 + 0x3c;
do {
iVar7 = *param_4;
lVar4 = 0;
iVar5 = 0;
iVar6 = 0;
if (iVar7 < 1) {
LAB_00101607:
me... |
5,088 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char name[100];
int marks;
} student_data;
typedef struct {
char name[100];
int total_marks;
} aggregated_data;
| aggregated_data func0(student_data stdata[], int size) {
int i, j, found;
aggregated_data *temp = malloc(size * sizeof(aggregated_data));
int temp_count = 0;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < temp_count; j++) {
if (strcmp(temp[j].name, stdat... | int main() {
student_data test1[5] = {{"Juan Whelan", 90}, {"Sabah Colley", 88}, {"Peter Nichols", 7}, {"Juan Whelan", 122}, {"Sabah Colley", 84}};
aggregated_data result1 = func0(test1, 5);
assert(strcmp(result1.name, "Juan Whelan") == 0 && result1.total_marks == 212);
student_data test2[5] =... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %edx,-0xb4(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0xb4(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
add... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_A8], rdi
mov [rbp+var_B0], rsi
mov [rbp+var_B4], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_B4]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax... | _QWORD * func0(_QWORD *a1, long long a2, int a3)
{
long long v3; // rdx
int i; // [rsp+28h] [rbp-98h]
int k; // [rsp+28h] [rbp-98h]
int j; // [rsp+2Ch] [rbp-94h]
int v9; // [rsp+30h] [rbp-90h]
int v10; // [rsp+34h] [rbp-8Ch]
long long *ptr; // [rsp+38h] [rbp-88h]
long long v12; // [rsp+40h] [rbp-80h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV dword ptr [RBP + -0xb4],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0xb4]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2... | int8 * func0(int8 *param_1,long param_2,int param_3)
{
long lVar1;
bool bVar2;
int iVar3;
int8 *__ptr;
int8 *puVar4;
long in_FS_OFFSET;
int local_a0;
int local_9c;
int local_94;
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
in... |
5,089 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char name[100];
int marks;
} student_data;
typedef struct {
char name[100];
int total_marks;
} aggregated_data;
| aggregated_data func0(student_data stdata[], int size) {
int i, j, found;
aggregated_data *temp = malloc(size * sizeof(aggregated_data));
int temp_count = 0;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < temp_count; j++) {
if (strcmp(temp[j].name, stdat... | int main() {
student_data test1[5] = {{"Juan Whelan", 90}, {"Sabah Colley", 88}, {"Peter Nichols", 7}, {"Juan Whelan", 122}, {"Sabah Colley", 84}};
aggregated_data result1 = func0(test1, 5);
assert(strcmp(result1.name, "Juan Whelan") == 0 && result1.total_marks == 212);
student_data test2[5] =... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,0x18(%rsp)
mov %rsi,%rbp
mov %edx,%ebx
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1100... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_B0], rdi
mov rbp, rsi
mov ebx, edx
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
movsxd rax, edx
lea rdx, [rax+rax*2]
lea rdi, [rax+rdx*4]
shl rdi, 3
c... | __m128i * func0(__m128i *a1, long long a2, int a3)
{
const __m128i *v4; // rax
const __m128i *v5; // r15
long long v6; // r13
int v7; // r14d
const __m128i *v8; // rbx
__int32 v9; // ebx
const __m128i *v10; // rax
__int32 v11; // edx
long long v13; // [rsp+8h] [rbp-C0h]
__m128i v14; // [rsp+20h] [rb... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x18],RDI
MOV RBP,RSI
MOV EBX,EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[RAX + RAX*0x2]
LEA RDI,[RAX + RDX*0x4]
SHL RDI,0x3
CALL 0x00101100
MOV R15,RAX
TEST EBX,... | int8 * func0(int8 *param_1,char *param_2,int param_3)
{
long lVar1;
int iVar2;
char *__ptr;
char *pcVar3;
char *__s1;
int iVar4;
long in_FS_OFFSET;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
int8 local_68;
... |
5,090 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char name[100];
int marks;
} student_data;
typedef struct {
char name[100];
int total_marks;
} aggregated_data;
| aggregated_data func0(student_data stdata[], int size) {
int i, j, found;
aggregated_data *temp = malloc(size * sizeof(aggregated_data));
int temp_count = 0;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < temp_count; j++) {
if (strcmp(temp[j].name, stdat... | int main() {
student_data test1[5] = {{"Juan Whelan", 90}, {"Sabah Colley", 88}, {"Peter Nichols", 7}, {"Juan Whelan", 122}, {"Sabah Colley", 84}};
aggregated_data result1 = func0(test1, 5);
assert(strcmp(result1.name, "Juan Whelan") == 0 && result1.total_marks == 212);
student_data test2[5] =... | O2 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1100 <mall... | func0:
endbr64
push r15
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
push rbx
mov ebx, edx
sub rsp, 88h
mov rax, fs:28h
mov [rsp+0B8h+var_40], rax
xor eax, eax
movsxd rax, edx
lea rdx, [rax+rax*2]
lea rdi, [rax+rdx*4]
shl rdi, 3
call _malloc... | __m128i * func0(__m128i *a1, long long a2, int a3)
{
long long v3; // r14
const __m128i *v5; // rax
const __m128i *v6; // r12
int v7; // ebp
const __m128i *v8; // r15
long long v9; // rax
__int32 v10; // ebx
const __m128i *v11; // rax
__m128i v12; // xmm6
__m128i v13; // xmm7
long long v14; // rax... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,EDX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x78],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[RAX + RAX*0x2]
LEA RDI,[RAX + RDX*0x4]
SHL RDI,0x3
CALL 0x00101100
MOV R12,RAX
TEST EBX,EBX
JLE 0x0010160e
... | int8 * func0(int8 *param_1,char *param_2,int param_3)
{
long lVar1;
int iVar2;
char *__ptr;
char *pcVar3;
long lVar4;
int iVar5;
char *__s1;
long in_FS_OFFSET;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
i... |
5,091 | func0 | #include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>
typedef struct {
char name[100];
int marks;
} student_data;
typedef struct {
char name[100];
int total_marks;
} aggregated_data;
| aggregated_data func0(student_data stdata[], int size) {
int i, j, found;
aggregated_data *temp = malloc(size * sizeof(aggregated_data));
int temp_count = 0;
for (i = 0; i < size; i++) {
found = 0;
for (j = 0; j < temp_count; j++) {
if (strcmp(temp[j].name, stdat... | int main() {
student_data test1[5] = {{"Juan Whelan", 90}, {"Sabah Colley", 88}, {"Peter Nichols", 7}, {"Juan Whelan", 122}, {"Sabah Colley", 84}};
aggregated_data result1 = func0(test1, 5);
assert(strcmp(result1.name, "Juan Whelan") == 0 && result1.total_marks == 212);
student_data test2[5] =... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov %edx,%ebx
sub $0x88,%rsp
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
movslq %edx,%rax
lea (%rax,%rax,2),%rdx
lea (%rax,%rdx,4),%rdi
shl $0x3,%rdi
callq 1100 <mall... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov ebp, edx
push rbx
mov rbx, rsi
sub rsp, 98h
mov [rsp+0C8h+var_B0], rdi
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
movsxd rax, edx
lea rdx, [rax+rax*2]
lea r15, [rax+rdx*4]
lea r14, ds:... | __m128i * func0(__m128i *a1, long long a2, int a3)
{
long long v4; // rbx
size_t v5; // r14
const __m128i *v6; // rax
__m128i *v7; // r12
size_t v8; // rax
int v9; // r14d
long long v10; // r13
__m128i *v11; // r15
long long v12; // rax
__int32 v13; // ebx
const __m128i *v14; // rax
__m128i v15;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x98
MOV qword ptr [RSP + 0x18],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOVSXD RAX,EDX
LEA RDX,[RAX + RAX*0x2]
LEA R15,[RAX + RDX*0x4]
LEA R14,[R15*0x8]
MOV RDI,R14
MOV qword ptr [RSP ... | int8 * func0(int8 *param_1,char *param_2,int param_3)
{
size_t __size;
long lVar1;
int iVar2;
char *__ptr;
char *pcVar3;
ulong uVar4;
size_t sVar5;
ulong uVar6;
char *__s2;
long lVar7;
int iVar8;
char *__s1;
long in_FS_OFFSET;
int8 local_a8;
int8 uStack_a0;
int8 local_98;
int8 uStack_... |
5,092 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int n) {
double nCr = 1;
double res = 1;
for (int r = 1; r <= n; r++) {
nCr = (nCr * (n + 1 - r)) / r;
res += nCr * nCr;
}
return res;
}
| int main() {
assert(func0(1) == 2.0);
assert(func0(2) == 6.0);
assert(func0(3) == 20.0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x24(%rbp)
movsd 0xf24(%rip),%xmm0
movsd %xmm0,-0x10(%rbp)
movsd 0xf17(%rip),%xmm0
movsd %xmm0,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11b2 <func0+0x69>
mov -0x24(%rbp),%eax
add $0x1,%eax
sub -0x14(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd -0x10(%rbp),... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_24], edi
movsd xmm0, cs:qword_2060
movsd [rbp+var_10], xmm0
movsd xmm0, cs:qword_2060
movsd [rbp+var_8], xmm0
mov [rbp+var_14], 1
jmp short loc_11BA
loc_1177:
mov eax, [rbp+var_24]
add eax, 1
sub eax, [rbp+var_14]
pxor xmm0, xmm... | double func0(int a1)
{
int i; // [rsp+10h] [rbp-14h]
double v3; // [rsp+14h] [rbp-10h]
double v4; // [rsp+1Ch] [rbp-8h]
v3 = 1.0;
v4 = 1.0;
for ( i = 1; i <= a1; ++i )
{
v3 = (double)(a1 + 1 - i) * v3 / (double)i;
v4 = v3 * v3 + v4;
}
return v4;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x24],EDI
MOVSD XMM0,qword ptr [0x00102060]
MOVSD qword ptr [RBP + -0x10],XMM0
MOVSD XMM0,qword ptr [0x00102060]
MOVSD qword ptr [RBP + -0x8],XMM0
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011ba
LAB_00101177:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
SUB EAX,dw... | double func0(int param_1)
{
int4 local_1c;
int8 local_18;
int8 local_10;
local_18 = DAT_00102060;
local_10 = DAT_00102060;
for (local_1c = 1; local_1c <= param_1; local_1c = local_1c + 1) {
local_18 = ((double)((param_1 + 1) - local_1c) * local_18) / (double)local_1c;
local_10 = local_18 * local... |
5,093 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int n) {
double nCr = 1;
double res = 1;
for (int r = 1; r <= n; r++) {
nCr = (nCr * (n + 1 - r)) / r;
res += nCr * nCr;
}
return res;
}
| int main() {
assert(func0(1) == 2.0);
assert(func0(2) == 6.0);
assert(func0(3) == 20.0);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 119b <func0+0x52>
add $0x1,%edi
mov %edi,%ecx
mov $0x1,%eax
movsd 0xf1d(%rip),%xmm2
movapd %xmm2,%xmm0
mov %edi,%edx
sub %eax,%edx
pxor %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
mulsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd %xmm1,%xmm0
movapd %xmm0,%xmm1... | func0:
endbr64
test edi, edi
jle short loc_1199
add edi, 1
mov eax, 1
movsd xmm1, cs:qword_2058
movapd xmm0, xmm1
loc_1165:
mov edx, edi
sub edx, eax
pxor xmm2, xmm2
cvtsi2sd xmm2, edx
mulsd xmm0, xmm2
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
divsd xmm0, xmm2
movapd xmm2, xmm0
mulsd xmm... | __int128 __usercall func0@<xmm0>(int a1@<edi>)
{
int v1; // edi
int v2; // eax
__int128 v3; // xmm1
double v4; // xmm0_8
if ( a1 <= 0 )
return 0x3FF0000000000000uLL;
v1 = a1 + 1;
v2 = 1;
v3 = 0x3FF0000000000000uLL;
v4 = 1.0;
do
{
v4 = v4 * (double)(v1 - v2) / (double)v2;
*(double *)&v... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101199
ADD EDI,0x1
MOV EAX,0x1
MOVSD XMM1,qword ptr [0x00102058]
MOVAPD XMM0,XMM1
LAB_00101165:
MOV EDX,EDI
SUB EDX,EAX
PXOR XMM2,XMM2
CVTSI2SD XMM2,EDX
MULSD XMM0,XMM2
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
DIVSD XMM0,XMM2
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
ADDSD XMM1,XMM2
ADD EAX,0x1
CMP E... | double func0(int param_1)
{
int iVar1;
double dVar2;
double dVar3;
dVar3 = DAT_00102058;
if (0 < param_1) {
iVar1 = 1;
dVar2 = DAT_00102058;
do {
dVar2 = (dVar2 * (double)((param_1 + 1) - iVar1)) / (double)iVar1;
dVar3 = dVar3 + dVar2 * dVar2;
iVar1 = iVar1 + 1;
} while (... |
5,094 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int n) {
double nCr = 1;
double res = 1;
for (int r = 1; r <= n; r++) {
nCr = (nCr * (n + 1 - r)) / r;
res += nCr * nCr;
}
return res;
}
| int main() {
assert(func0(1) == 2.0);
assert(func0(2) == 6.0);
assert(func0(3) == 20.0);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1198 <func0+0x58>
movsd 0xeb8(%rip),%xmm2
add $0x1,%edi
mov $0x1,%eax
movapd %xmm2,%xmm0
nopl 0x0(%rax)
mov %edi,%edx
pxor %xmm1,%xmm1
sub %eax,%edx
cvtsi2sd %edx,%xmm1
mulsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
add $0x1,%eax
divsd %xmm1,%xmm0
m... | func0:
endbr64
test edi, edi
jle short loc_1260
movsd xmm1, cs:qword_2058
lea ecx, [rdi+1]
mov eax, 1
movapd xmm0, xmm1
nop dword ptr [rax+00h]
loc_1220:
mov edx, ecx
pxor xmm2, xmm2
sub edx, eax
cvtsi2sd xmm2, edx
mov edx, eax
mulsd xmm0, xmm2
pxor xmm2, xmm2
cvtsi2sd xmm2, ea... | double func0(int a1)
{
double v1; // xmm1_8
int v2; // eax
double v3; // xmm0_8
int v4; // edx
double v5; // xmm0_8
double v6; // xmm2_8
if ( a1 <= 0 )
return 1.0;
v1 = 1.0;
v2 = 1;
v3 = 1.0;
do
{
v4 = v2;
v5 = v3 * (double)(a1 + 1 - v2);
v6 = (double)v2++;
v3 = v5 / v6;
... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101260
MOVSD XMM1,qword ptr [0x00102058]
LEA ECX,[RDI + 0x1]
MOV EAX,0x1
MOVAPD XMM0,XMM1
NOP dword ptr [RAX]
LAB_00101220:
MOV EDX,ECX
PXOR XMM2,XMM2
SUB EDX,EAX
CVTSI2SD XMM2,EDX
MOV EDX,EAX
MULSD XMM0,XMM2
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
ADD EAX,0x1
DIVSD XMM0,XMM2
MOVAPD XMM2,XM... | double func0(int param_1)
{
int iVar1;
bool bVar2;
double dVar3;
double dVar4;
if (0 < param_1) {
dVar3 = DAT_00102058;
dVar4 = DAT_00102058;
iVar1 = 1;
do {
dVar3 = (dVar3 * (double)((param_1 + 1) - iVar1)) / (double)iVar1;
dVar4 = dVar4 + dVar3 * dVar3;
bVar2 = param_1 ... |
5,095 | func0 |
#include <stdio.h>
#include <assert.h>
| double func0(int n) {
double nCr = 1;
double res = 1;
for (int r = 1; r <= n; r++) {
nCr = (nCr * (n + 1 - r)) / r;
res += nCr * nCr;
}
return res;
}
| int main() {
assert(func0(1) == 2.0);
assert(func0(2) == 6.0);
assert(func0(3) == 20.0);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1198 <func0+0x58>
movsd 0xeb8(%rip),%xmm2
add $0x1,%edi
mov $0x1,%eax
movapd %xmm2,%xmm0
nopl 0x0(%rax)
mov %edi,%edx
pxor %xmm1,%xmm1
sub %eax,%edx
cvtsi2sd %edx,%xmm1
mulsd %xmm1,%xmm0
pxor %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
add $0x1,%eax
divsd %xmm1,%xmm0
m... | func0:
endbr64
test edi, edi
jle short loc_1198
movsd xmm1, cs:qword_2008
add edi, 1
mov eax, 1
movapd xmm0, xmm1
nop dword ptr [rax+00h]
loc_1160:
mov edx, edi
pxor xmm2, xmm2
sub edx, eax
cvtsi2sd xmm2, edx
mulsd xmm0, xmm2
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
add eax, 1
divsd ... | double func0(int a1)
{
double v1; // xmm1_8
int v2; // edi
int v3; // eax
double v4; // xmm0_8
int v5; // edx
double v6; // xmm2_8
if ( a1 <= 0 )
return 1.0;
v1 = 1.0;
v2 = a1 + 1;
v3 = 1;
v4 = 1.0;
do
{
v5 = v2 - v3;
v6 = (double)v3++;
v4 = v4 * (double)v5 / v6;
v1 = v1 ... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101198
MOVSD XMM1,qword ptr [0x00102008]
ADD EDI,0x1
MOV EAX,0x1
MOVAPD XMM0,XMM1
NOP dword ptr [RAX]
LAB_00101160:
MOV EDX,EDI
PXOR XMM2,XMM2
SUB EDX,EAX
CVTSI2SD XMM2,EDX
MULSD XMM0,XMM2
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
ADD EAX,0x1
DIVSD XMM0,XMM2
MOVAPD XMM2,XMM0
MULSD XMM2,XMM0
A... | double func0(int param_1)
{
int iVar1;
int iVar2;
double dVar3;
double dVar4;
double dVar5;
if (0 < param_1) {
iVar1 = 1;
dVar3 = DAT_00102008;
dVar4 = DAT_00102008;
do {
iVar2 = (param_1 + 1) - iVar1;
dVar5 = (double)iVar1;
iVar1 = iVar1 + 1;
dVar3 = (dVar3 * (do... |
5,096 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct Dict Dict;
typedef struct DictEntry DictEntry;
struct DictEntry {
char *key;
Dict *value; // NULL if not a dict
};
struct Dict {
int size;
DictEntry *entries;
};
| int func0(Dict *d) {
if (d == NULL) return 0;
if (d->size == 0) return 1;
int max_depth = 0;
for(int i = 0; i < d->size; i++) {
int depth = func0(d->entries[i].value);
if(depth > max_depth) max_depth = depth;
}
return 1 + max_depth;
}
| int main() {
// First assert: {'a':1, 'b': {'c': {'d': {}}}} == 4
Dict d_inner_most = {0, NULL};
DictEntry entries_c[] = { {"d", &d_inner_most} };
Dict dict_c = {1, entries_c};
DictEntry entries_b[] = { {"c", &dict_c} };
Dict dict_b = {1, entries_b};
DictEntry entries_a_b[] = { {"a", ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
cmpq $0x0,-0x18(%rbp)
jne 1187 <func0+0x1e>
mov $0x0,%eax
jmp 11ef <func0+0x86>
mov -0x18(%rbp),%rax
mov (%rax),%eax
test %eax,%eax
jne 1198 <func0+0x2f>
mov $0x1,%eax
jmp 11ef <func0+0x86>
movl $0x0,-0xc... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_18], rdi
cmp [rbp+var_18], 0
jnz short loc_1187
mov eax, 0
jmp short locret_11EF
loc_1187:
mov rax, [rbp+var_18]
mov eax, [rax]
test eax, eax
jnz short loc_1198
mov eax, 1
jmp short locret_11EF
loc_1198:... | long long func0(long long a1)
{
int v2; // [rsp+14h] [rbp-Ch]
int i; // [rsp+18h] [rbp-8h]
int v4; // [rsp+1Ch] [rbp-4h]
if ( !a1 )
return 0LL;
if ( !*(_DWORD *)a1 )
return 1LL;
v2 = 0;
for ( i = 0; i < *(_DWORD *)a1; ++i )
{
v4 = func0(*(_QWORD *)(16LL * i + *(_QWORD *)(a1 + 8) + 8));
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x00101187
MOV EAX,0x0
JMP 0x001011ef
LAB_00101187:
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
TEST EAX,EAX
JNZ 0x00101198
MOV EAX,0x1
JMP 0x001011ef
LAB_00101198:
MOV dword ptr [RBP + -0xc]... | int func0(int *param_1)
{
int iVar1;
int local_14;
int local_10;
if (param_1 == (int *)0x0) {
local_14 = 0;
}
else if (*param_1 == 0) {
local_14 = 1;
}
else {
local_14 = 0;
for (local_10 = 0; local_10 < *param_1; local_10 = local_10 + 1) {
iVar1 = func0(*(int8 *)(*(long *)(para... |
5,097 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct Dict Dict;
typedef struct DictEntry DictEntry;
struct DictEntry {
char *key;
Dict *value; // NULL if not a dict
};
struct Dict {
int size;
DictEntry *entries;
};
| int func0(Dict *d) {
if (d == NULL) return 0;
if (d->size == 0) return 1;
int max_depth = 0;
for(int i = 0; i < d->size; i++) {
int depth = func0(d->entries[i].value);
if(depth > max_depth) max_depth = depth;
}
return 1 + max_depth;
}
| int main() {
// First assert: {'a':1, 'b': {'c': {'d': {}}}} == 4
Dict d_inner_most = {0, NULL};
DictEntry entries_c[] = { {"d", &d_inner_most} };
Dict dict_c = {1, entries_c};
DictEntry entries_b[] = { {"c", &dict_c} };
Dict dict_b = {1, entries_b};
DictEntry entries_a_b[] = { {"a", ... | O1 | c | func0:
endbr64
test %rdi,%rdi
je 11bb <func0+0x52>
mov (%rdi),%edx
mov $0x1,%eax
test %edx,%edx
je 11c1 <func0+0x58>
push %r12
push %rbp
push %rbx
mov $0x0,%ebx
jle 11b3 <func0+0x4a>
mov 0x8(%rdi),%rcx
lea 0x8(%rcx),%rbp
lea -0x1(%rdx),%eax
shl $0x4,%rax
lea 0x18(%rcx,%rax,1... | func0:
endbr64
test rdi, rdi
jz short loc_11BB
mov edx, [rdi]
mov eax, 1
test edx, edx
jz short locret_11C1
push r12
push rbp
push rbx
mov ebx, 0
jle short loc_11B3
mov rcx, [rdi+8]
lea rbp, [rcx+8]
lea eax, [rdx-1]
shl rax, 4
lea r12, [rcx+rax+18h]
loc_119C:... | long long func0(long long a1)
{
int v1; // edx
long long result; // rax
int v3; // ebx
long long v4; // rcx
_QWORD *v5; // rbp
long long v6; // r12
int v7; // eax
if ( !a1 )
return 0LL;
v1 = *(_DWORD *)a1;
result = 1LL;
if ( *(_DWORD *)a1 )
{
v3 = 0;
if ( v1 > 0 )
{
v4 = ... | func0:
ENDBR64
TEST RDI,RDI
JZ 0x001011bb
MOV EDX,dword ptr [RDI]
MOV EAX,0x1
TEST EDX,EDX
JZ 0x001011c1
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,0x0
JLE 0x001011b3
MOV RCX,qword ptr [RDI + 0x8]
LEA RBP,[RCX + 0x8]
LEA EAX,[RDX + -0x1]
SHL RAX,0x4
LEA R12,[RCX + RAX*0x1 + 0x18]
LAB_0010119c:
MOV RDI,qword ptr [RBP]
CALL 0x00... | int func0(int *param_1)
{
int iVar1;
long lVar2;
int iVar3;
int iVar4;
int8 *puVar5;
if (param_1 == (int *)0x0) {
return 0;
}
iVar1 = *param_1;
if (iVar1 != 0) {
iVar4 = 0;
if (0 < iVar1) {
lVar2 = *(long *)(param_1 + 2);
puVar5 = (int8 *)(lVar2 + 8);
do {
iVa... |
5,098 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct Dict Dict;
typedef struct DictEntry DictEntry;
struct DictEntry {
char *key;
Dict *value; // NULL if not a dict
};
struct Dict {
int size;
DictEntry *entries;
};
| int func0(Dict *d) {
if (d == NULL) return 0;
if (d->size == 0) return 1;
int max_depth = 0;
for(int i = 0; i < d->size; i++) {
int depth = func0(d->entries[i].value);
if(depth > max_depth) max_depth = depth;
}
return 1 + max_depth;
}
| int main() {
// First assert: {'a':1, 'b': {'c': {'d': {}}}} == 4
Dict d_inner_most = {0, NULL};
DictEntry entries_c[] = { {"d", &d_inner_most} };
Dict dict_c = {1, entries_c};
DictEntry entries_b[] = { {"c", &dict_c} };
Dict dict_b = {1, entries_b};
DictEntry entries_a_b[] = { {"a", ... | O2 | c | func0:
endbr64
test %rdi,%rdi
je 1450 <func0+0x20>
mov (%rdi),%eax
test %eax,%eax
je 1448 <func0+0x18>
jmp 1460 <func0.part.0>
nopl 0x0(%rax)
mov $0x1,%eax
retq
xchg %ax,%ax
xor %eax,%eax
retq
data16 nopw %cs:0x0(%rax,%rax,1)
xchg %ax,%ax
| func0_part_0:
mov edx, [rdi]
test edx, edx
jle loc_15C4
push r15
lea eax, [rdx-1]
xor r11d, r11d
push r14
shl rax, 4
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rcx, [rdi+8]
lea rax, [rcx+rax+18h]
lea r10, [rcx+8]
mov [rsp+78h+var_78], rax
loc_13C3:
... | long long func0_part_0(long long a1)
{
int v1; // r11d
long long v2; // rcx
_QWORD *v3; // r10
long long v4; // rax
int v5; // edx
int v6; // ecx
long long v7; // rcx
long long v8; // rax
_QWORD *v9; // r8
int v10; // ecx
_QWORD *v11; // r10
long long v12; // rax
int v13; // esi
int v14; //... | func0.part.0:
MOV EDX,dword ptr [RDI]
TEST EDX,EDX
JLE 0x001015c4
PUSH R15
LEA EAX,[RDX + -0x1]
XOR R11D,R11D
PUSH R14
SHL RAX,0x4
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RCX,qword ptr [RDI + 0x8]
LEA RAX,[RCX + RAX*0x1 + 0x18]
LEA R10,[RCX + 0x8]
MOV qword ptr [RSP],RAX
LAB_001013c3:
MOV RAX,qword ptr [R1... | int func0_part_0(int *param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
long lVar6;
int *piVar7;
long lVar8;
long lVar9;
long lVar10;
long lVar11;
int iVar12;
int iVar13;
int iVar14;
int8 *puVar15;
int8 *puVar16;
int8 *puVar17;
int iVar18;
int iVar19;
int8 *puVar... |
5,099 | func0 |
#include <assert.h>
#include <stdio.h>
typedef struct Dict Dict;
typedef struct DictEntry DictEntry;
struct DictEntry {
char *key;
Dict *value; // NULL if not a dict
};
struct Dict {
int size;
DictEntry *entries;
};
| int func0(Dict *d) {
if (d == NULL) return 0;
if (d->size == 0) return 1;
int max_depth = 0;
for(int i = 0; i < d->size; i++) {
int depth = func0(d->entries[i].value);
if(depth > max_depth) max_depth = depth;
}
return 1 + max_depth;
}
| int main() {
// First assert: {'a':1, 'b': {'c': {'d': {}}}} == 4
Dict d_inner_most = {0, NULL};
DictEntry entries_c[] = { {"d", &d_inner_most} };
Dict dict_c = {1, entries_c};
DictEntry entries_b[] = { {"c", &dict_c} };
Dict dict_b = {1, entries_b};
DictEntry entries_a_b[] = { {"a", ... | O3 | c | func0:
endbr64
test %rdi,%rdi
je 1540 <func0+0xb0>
mov (%rdi),%edx
mov $0x1,%eax
test %edx,%edx
je 1533 <func0+0xa3>
jle 1533 <func0+0xa3>
mov 0x8(%rdi),%rcx
lea -0x1(%rdx),%eax
xor %esi,%esi
shl $0x4,%rax
lea 0x8(%rcx),%r8
lea 0x18(%rcx,%rax,1),%r9
mov (%r8),%rdi
test %rdi,%... | func0_part_0:
movsxd rdx, dword ptr [rdi]
test edx, edx
jle loc_15CD
push r15
shl rdx, 4
push r14
push r13
push r12
xor r12d, r12d
push rbp
push rbx
sub rsp, 48h
mov r13, [rdi+8]
lea rcx, [rdx+r13]
mov r15, r13
mov r14, rcx
loc_13BE:
mov rdx, [r15+8]
test rdx... | long long func0_part_0(int *a1)
{
long long v1; // rdx
int v2; // r12d
long long v3; // r15
long long v4; // r14
int *v5; // rdx
long long v6; // rax
int v7; // r13d
long long v8; // rsi
long long v9; // rbp
int v10; // ecx
long long v11; // r13
int *v12; // rdx
long long v13; // rax
int v1... | func0.part.0:
MOVSXD RDX,dword ptr [RDI]
TEST EDX,EDX
JLE 0x001015cd
PUSH R15
SHL RDX,0x4
PUSH R14
PUSH R13
PUSH R12
XOR R12D,R12D
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV R13,qword ptr [RDI + 0x8]
LEA RCX,[RDX + R13*0x1]
MOV R15,R13
MOV R14,RCX
LAB_001013be:
MOV RDX,qword ptr [R15 + 0x8]
TEST RDX,RDX
JZ 0x001015c8
MOVSXD RA... | int func0_part_0(int *param_1)
{
long lVar1;
long lVar2;
long lVar3;
int *piVar4;
int iVar5;
long lVar6;
int iVar7;
int iVar8;
long lVar9;
long lVar10;
long lVar11;
int iVar12;
int iVar13;
int iVar14;
long lVar15;
long lVar16;
long lVar17;
if (0 < *param_1) {
iVar12 = 0;
... |
5,100 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
int msb = 0;
n = n / 2;
while (n > 0) {
n = n / 2;
msb++;
}
return (1 << msb);
}
| int main() {
assert(func0(6) == 4);
assert(func0(10) == 8);
assert(func0(18) == 16);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 1161 <func0+0x18>
mov $0x0,%eax
jmp 11a0 <func0+0x57>
movl $0x0,-0x4(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x14(%rbp)
jmp 118c <func0+0x43>
m... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jnz short loc_1161
mov eax, 0
jmp short loc_11A0
loc_1161:
mov [rbp+var_4], 0
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_14], eax
jmp short ... | long long func0(int a1)
{
int i; // [rsp+0h] [rbp-14h]
char v3; // [rsp+10h] [rbp-4h]
if ( !a1 )
return 0LL;
v3 = 0;
for ( i = a1 / 2; i > 0; i /= 2 )
++v3;
return (unsigned int)(1 << v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101161
MOV EAX,0x0
JMP 0x001011a0
LAB_00101161:
MOV dword ptr [RBP + -0x4],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010118c
LAB_0... | int func0(int param_1)
{
byte bVar1;
int iVar2;
int4 local_1c;
if (param_1 == 0) {
iVar2 = 0;
}
else {
bVar1 = 0;
for (local_1c = param_1 / 2; 0 < local_1c; local_1c = local_1c / 2) {
bVar1 = bVar1 + 1;
}
iVar2 = 1 << (bVar1 & 0x1f);
}
return iVar2;
} |
5,101 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
int msb = 0;
n = n / 2;
while (n > 0) {
n = n / 2;
msb++;
}
return (1 << msb);
}
| int main() {
assert(func0(6) == 4);
assert(func0(10) == 8);
assert(func0(18) == 16);
return 0;
}
| O1 | c | func0:
endbr64
mov %edi,%eax
test %edi,%edi
je 117e <func0+0x35>
shr $0x1f,%eax
add %edi,%eax
sar %eax
cmp $0x1,%edi
jle 117f <func0+0x36>
mov $0x0,%ecx
mov %eax,%edx
mov %eax,%esi
shr $0x1f,%esi
add %esi,%eax
sar %eax
add $0x1,%ecx
cmp $0x1,%edx
jg 1164 <func0+0x1b>
... | func0:
endbr64
mov eax, edi
test edi, edi
jz short locret_117E
shr eax, 1Fh
add eax, edi
sar eax, 1
cmp edi, 1
jle short loc_117F
mov ecx, 0
loc_1164:
mov edx, eax
mov esi, eax
shr esi, 1Fh
add eax, esi
sar eax, 1
add ecx, 1
cmp edx, 1
jg short loc_11... | long long func0(int a1)
{
long long result; // rax
int v2; // eax
char v3; // cl
int v4; // edx
result = (unsigned int)a1;
if ( a1 )
{
v2 = a1 / 2;
if ( a1 <= 1 )
{
v3 = 0;
}
else
{
v3 = 0;
do
{
v4 = v2;
v2 /= 2;
++v3;
}
... | func0:
ENDBR64
MOV EAX,EDI
TEST EDI,EDI
JZ 0x0010117e
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CMP EDI,0x1
JLE 0x0010117f
MOV ECX,0x0
LAB_00101164:
MOV EDX,EAX
MOV ESI,EAX
SHR ESI,0x1f
ADD EAX,ESI
SAR EAX,0x1
ADD ECX,0x1
CMP EDX,0x1
JG 0x00101164
LAB_00101177:
MOV EAX,0x1
SHL EAX,CL
LAB_0010117e:
RET
LAB_0010117f:
MOV ECX,... | int func0(int param_1)
{
bool bVar1;
int iVar2;
byte bVar3;
if (param_1 != 0) {
if (param_1 < 2) {
bVar3 = 0;
}
else {
bVar3 = 0;
iVar2 = param_1 / 2;
do {
bVar3 = bVar3 + 1;
bVar1 = 1 < iVar2;
iVar2 = iVar2 / 2;
} while (bVar1);
}
pa... |
5,102 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
int msb = 0;
n = n / 2;
while (n > 0) {
n = n / 2;
msb++;
}
return (1 << msb);
}
| int main() {
assert(func0(6) == 4);
assert(func0(10) == 8);
assert(func0(18) == 16);
return 0;
}
| O2 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
cmp $0x1,%edi
jle 1170 <func0+0x30>
xor %ecx,%ecx
nopw 0x0(%rax,%rax,1)
add $0x1,%ecx
sar %eax
jne 1160 <func0+0x20>
mov $0x1,%eax
shl %cl,%eax
retq
mov ... | func0:
endbr64
xor eax, eax
test edi, edi
jz short locret_1175
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
cmp edi, 1
jle short loc_1170
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1160:
add ecx, 1
sar eax, 1
jnz short loc_1160
mov eax, 1
shl eax, cl... | long long func0(int a1)
{
long long result; // rax
int v2; // eax
char v3; // cl
result = 0LL;
if ( a1 )
{
v2 = a1 / 2;
if ( a1 <= 1 )
{
return 1LL;
}
else
{
v3 = 0;
do
{
++v3;
v2 >>= 1;
}
while ( v2 );
return (unsigned int)... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CMP EDI,0x1
JLE 0x00101170
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
ADD ECX,0x1
SAR EAX,0x1
JNZ 0x00101160
MOV EAX,0x1
SHL EAX,CL
RET
LAB_00101170:
MOV EAX,0x1
LAB_00101175:
RET | int func0(int param_1)
{
int iVar1;
byte bVar2;
iVar1 = 0;
if (param_1 != 0) {
iVar1 = param_1 / 2;
if (1 < param_1) {
bVar2 = 0;
do {
bVar2 = bVar2 + 1;
iVar1 = iVar1 >> 1;
} while (iVar1 != 0);
return 1 << (bVar2 & 0x1f);
}
iVar1 = 1;
}
return iV... |
5,103 | func0 |
#include <assert.h>
| int func0(int n) {
if (n == 0)
return 0;
int msb = 0;
n = n / 2;
while (n > 0) {
n = n / 2;
msb++;
}
return (1 << msb);
}
| int main() {
assert(func0(6) == 4);
assert(func0(10) == 8);
assert(func0(18) == 16);
return 0;
}
| O3 | c | func0:
endbr64
xor %eax,%eax
test %edi,%edi
je 1175 <func0+0x35>
mov %edi,%eax
shr $0x1f,%eax
add %edi,%eax
sar %eax
cmp $0x1,%edi
jle 1170 <func0+0x30>
xor %ecx,%ecx
nopw 0x0(%rax,%rax,1)
add $0x1,%ecx
sar %eax
jne 1160 <func0+0x20>
mov $0x1,%eax
shl %cl,%eax
retq
mov ... | func0:
endbr64
xor eax, eax
test edi, edi
jz short locret_1175
mov eax, edi
shr eax, 1Fh
add eax, edi
sar eax, 1
cmp edi, 1
jle short loc_1170
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1160:
add ecx, 1
sar eax, 1
jnz short loc_1160
mov eax, 1
shl eax, cl... | long long func0(int a1)
{
long long result; // rax
int v2; // eax
char v3; // cl
result = 0LL;
if ( a1 )
{
v2 = a1 / 2;
if ( a1 <= 1 )
{
return 1LL;
}
else
{
v3 = 0;
do
{
++v3;
v2 >>= 1;
}
while ( v2 );
return (unsigned int)... | func0:
ENDBR64
XOR EAX,EAX
TEST EDI,EDI
JZ 0x00101175
MOV EAX,EDI
SHR EAX,0x1f
ADD EAX,EDI
SAR EAX,0x1
CMP EDI,0x1
JLE 0x00101170
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101160:
ADD ECX,0x1
SAR EAX,0x1
JNZ 0x00101160
MOV EAX,0x1
SHL EAX,CL
RET
LAB_00101170:
MOV EAX,0x1
LAB_00101175:
RET | int func0(int param_1)
{
int iVar1;
byte bVar2;
iVar1 = 0;
if (param_1 != 0) {
iVar1 = param_1 / 2;
if (1 < param_1) {
bVar2 = 0;
do {
bVar2 = bVar2 + 1;
iVar1 = iVar1 >> 1;
} while (iVar1 != 0);
return 1 << (bVar2 & 0x1f);
}
iVar1 = 1;
}
return iV... |
5,104 | func0 |
#include <stdio.h>
#include <limits.h>
#include <assert.h>
| int func0(int a[], int n) {
int mx = INT_MIN;
for (int j = 1; j < n; j++) {
if (mx > a[j]) {
return 0;
}
if (a[j - 1] > mx) {
mx = a[j - 1];
}
}
return 1;
}
| int main() {
int arr1[] = {1, 0, 2};
int arr2[] = {1, 2, 0};
int arr3[] = {1, 2, 1};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 3) == 0);
assert(func0(arr3, 3) == 1);
printf("All tests passed.\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x80000000,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 1202 <func0+0x79>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x8(%rbp)
jle 11ca <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], 1
jmp short loc_1202
loc_11A8:
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)
{
signed int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0x80000000;
for ( i = 1; i < a2; ++i )
{
if ( v3 > *(_DWORD *)(4LL * i + a1) )
return 0LL;
if ( v3 < *(_DWORD *)(4LL * i - 4 + a1) )
v3 = *(_DWORD *)(4LL * i - 4 + a1);
}
re... | 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],0x1
JMP 0x00101202
LAB_001011a8:
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]
... | int8 func0(long param_1,int param_2)
{
int local_10;
int local_c;
local_10 = -0x80000000;
local_c = 1;
while( true ) {
if (param_2 <= local_c) {
return 1;
}
if (*(int *)(param_1 + (long)local_c * 4) < local_10) break;
if (local_10 < *(int *)(param_1 + (long)local_c * 4 + -4)) {
... |
5,105 | func0 |
#include <stdio.h>
#include <limits.h>
#include <assert.h>
| int func0(int a[], int n) {
int mx = INT_MIN;
for (int j = 1; j < n; j++) {
if (mx > a[j]) {
return 0;
}
if (a[j - 1] > mx) {
mx = a[j - 1];
}
}
return 1;
}
| int main() {
int arr1[] = {1, 0, 2};
int arr2[] = {1, 2, 0};
int arr3[] = {1, 2, 1};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 3) == 0);
assert(func0(arr3, 3) == 1);
printf("All tests passed.\n");
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x1,%esi
jle 11bc <func0+0x33>
mov %rdi,%rax
lea -0x2(%rsi),%edx
lea (%rdi,%rdx,4),%rsi
mov $0x80000000,%edx
mov (%rax),%ecx
cmp %ecx,%edx
cmovl %ecx,%edx
cmp %rsi,%rax
je 11c2 <func0+0x39>
add $0x4,%rax
cmp %edx,0x4(%rax)
jge 11a1 <func0+0x18>
mov $0x0,%e... | func0:
endbr64
cmp esi, 1
jle short loc_11BC
mov rax, rdi
lea edx, [rsi-2]
lea rsi, [rdi+rdx*4]
mov edx, 80000000h
loc_11A1:
mov ecx, [rax]
cmp edx, ecx
cmovl edx, ecx
cmp rax, rsi
jz short loc_11C2
add rax, 4
cmp [rax+4], edx
jge short loc_11A1
mov eax, 0
retn... | long long func0(signed int *a1, int a2)
{
signed int *v2; // rax
signed int *v3; // rsi
signed int v4; // edx
if ( a2 <= 1 )
return 1LL;
v2 = a1;
v3 = &a1[a2 - 2];
v4 = 0x80000000;
while ( 1 )
{
if ( v4 < *v2 )
v4 = *v2;
if ( v2 == v3 )
break;
++v2;
if ( v2[1] < v4 )
... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011bc
MOV RAX,RDI
LEA EDX,[RSI + -0x2]
LEA RSI,[RDI + RDX*0x4]
MOV EDX,0x80000000
LAB_001011a1:
MOV ECX,dword ptr [RAX]
CMP EDX,ECX
CMOVL EDX,ECX
CMP RAX,RSI
JZ 0x001011c2
ADD RAX,0x4
CMP dword ptr [RAX + 0x4],EDX
JGE 0x001011a1
MOV EAX,0x0
RET
LAB_001011bc:
MOV EAX,0x1
RET
LAB_00101... | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
if (param_2 < 2) {
return 1;
}
iVar3 = -0x80000000;
piVar2 = param_1;
while( true ) {
if (iVar3 < *piVar2) {
iVar3 = *piVar2;
}
if (piVar2 == param_1 + (param_2 - 2)) break;
piVar1 = piVar2 + 2;
... |
5,106 | func0 |
#include <stdio.h>
#include <limits.h>
#include <assert.h>
| int func0(int a[], int n) {
int mx = INT_MIN;
for (int j = 1; j < n; j++) {
if (mx > a[j]) {
return 0;
}
if (a[j - 1] > mx) {
mx = a[j - 1];
}
}
return 1;
}
| int main() {
int arr1[] = {1, 0, 2};
int arr2[] = {1, 2, 0};
int arr3[] = {1, 2, 1};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 3) == 0);
assert(func0(arr3, 3) == 1);
printf("All tests passed.\n");
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x1,%esi
jle 11a0 <func0+0x30>
lea -0x2(%rsi),%eax
lea (%rdi,%rax,4),%rcx
mov $0x80000000,%eax
nopl (%rax)
mov (%rdi),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %rcx,%rdi
je 11a0 <func0+0x30>
add $0x4,%rdi
cmp %eax,0x4(%rdi)
jge 1188 <func0+0x18>
xor %eax,%eax
... | func0:
endbr64
cmp esi, 1
jle short loc_12D0
lea eax, [rsi-2]
lea rcx, [rdi+rax*4]
mov eax, 80000000h
nop dword ptr [rax]
loc_12B8:
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp rdi, rcx
jz short loc_12D0
add rdi, 4
cmp [rdi+4], eax
jge short loc_12B8
xor eax,... | long long func0(signed int *a1, int a2)
{
signed int *v2; // rcx
signed int v3; // eax
if ( a2 > 1 )
{
v2 = &a1[a2 - 2];
v3 = 0x80000000;
while ( 1 )
{
if ( v3 < *a1 )
v3 = *a1;
if ( a1 == v2 )
break;
++a1;
if ( a1[1] < v3 )
return 0LL;
}
}... | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001012d0
LEA EAX,[RSI + -0x2]
LEA RCX,[RDI + RAX*0x4]
MOV EAX,0x80000000
NOP dword ptr [RAX]
LAB_001012b8:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
CMP RDI,RCX
JZ 0x001012d0
ADD RDI,0x4
CMP dword ptr [RDI + 0x4],EAX
JGE 0x001012b8
XOR EAX,EAX
RET
LAB_001012d0:
MOV EAX,0x1
RET | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int *piVar3;
if (1 < param_2) {
iVar2 = -0x80000000;
piVar3 = param_1;
while( true ) {
if (iVar2 < *piVar3) {
iVar2 = *piVar3;
}
if (piVar3 == param_1 + (param_2 - 2)) break;
piVar1 = piVar3 + 2;
... |
5,107 | func0 |
#include <stdio.h>
#include <limits.h>
#include <assert.h>
| int func0(int a[], int n) {
int mx = INT_MIN;
for (int j = 1; j < n; j++) {
if (mx > a[j]) {
return 0;
}
if (a[j - 1] > mx) {
mx = a[j - 1];
}
}
return 1;
}
| int main() {
int arr1[] = {1, 0, 2};
int arr2[] = {1, 2, 0};
int arr3[] = {1, 2, 1};
assert(func0(arr1, 3) == 1);
assert(func0(arr2, 3) == 0);
assert(func0(arr3, 3) == 1);
printf("All tests passed.\n");
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x1,%esi
jle 11a0 <func0+0x30>
lea -0x2(%rsi),%eax
lea (%rdi,%rax,4),%rcx
mov $0x80000000,%eax
nopl (%rax)
mov (%rdi),%edx
cmp %edx,%eax
cmovl %edx,%eax
cmp %rdi,%rcx
je 11a0 <func0+0x30>
add $0x4,%rdi
cmp %eax,0x4(%rdi)
jge 1188 <func0+0x18>
xor %eax,%eax
... | func0:
endbr64
cmp esi, 1
jle short loc_11B0
lea eax, [rsi-2]
lea rcx, [rdi+rax*4+4]
mov eax, 80000000h
jmp short loc_11A0
loc_1190:
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
add rdi, 4
cmp rdi, rcx
jz short loc_11B0
loc_11A0:
cmp [rdi+4], eax
jge short loc_1190
x... | long long func0(signed int *a1, int a2)
{
long long v2; // rcx
signed int v3; // eax
if ( a2 <= 1 )
return 1LL;
v2 = (long long)&a1[a2 - 2 + 1];
v3 = 0x80000000;
while ( a1[1] >= v3 )
{
if ( v3 < *a1 )
v3 = *a1;
if ( ++a1 == (signed int *)v2 )
return 1LL;
}
return 0LL;
} | func0:
ENDBR64
CMP ESI,0x1
JLE 0x001011b0
LEA EAX,[RSI + -0x2]
LEA RCX,[RDI + RAX*0x4 + 0x4]
MOV EAX,0x80000000
JMP 0x001011a0
LAB_00101190:
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
ADD RDI,0x4
CMP RDI,RCX
JZ 0x001011b0
LAB_001011a0:
CMP dword ptr [RDI + 0x4],EAX
JGE 0x00101190
XOR EAX,EAX
RET
LAB_001011b0:
MO... | int8 func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (1 < param_2) {
piVar1 = param_1 + (ulong)(param_2 - 2) + 1;
iVar2 = -0x80000000;
do {
if (param_1[1] < iVar2) {
return 0;
}
if (iVar2 < *param_1) {
iVar2 = *param_1;
}
param_1 = param_1... |
5,108 | func0 |
#include <assert.h>
| int func0(int arr[], int ranges[][2], int rotations, int index) {
for (int i = rotations - 1; i >= 0; i--) {
int left = ranges[i][0];
int right = ranges[i][1];
if (left <= index && right >= index) {
if (index == left) {
index = right;
} else {
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int ranges1[][2] = {{0, 2}, {0, 3}};
assert(func0(arr1, ranges1, 2, 1) == 3);
int arr2[] = {1, 2, 3, 4};
int ranges2[][2] = {{0, 1}, {0, 2}};
assert(func0(arr2, ranges2, 1, 2) == 3);
int arr3[] = {1, 2, 3, 4, 5, 6};
int ranges3[][2] ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
mov %edx,-0x24(%rbp)
mov %ecx,-0x28(%rbp)
mov -0x24(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
jmp 11e5 <func0+0x7c>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x20(%rbp),%rax
add %rdx,%r... | 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_28], ecx
mov eax, [rbp+var_24]
sub eax, 1
mov [rbp+var_C], eax
jmp short loc_11E5
loc_118A:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+... | long long func0(long long a1, long long a2, int a3, int a4)
{
int i; // [rsp+1Ch] [rbp-Ch]
int v7; // [rsp+20h] [rbp-8h]
for ( i = a3 - 1; i >= 0; --i )
{
v7 = *(_DWORD *)(8LL * i + a2);
if ( v7 <= a4 && *(_DWORD *)(8LL * i + a2 + 4) >= a4 )
{
if ( a4 == v7 )
a4 = *(_DWORD *)(8LL * i... | 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 dword ptr [RBP + -0x28],ECX
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001011e5
LAB_0010118a:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8... | int4 func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
int iVar2;
int iVar3;
int local_30;
int local_14;
local_30 = param_4;
for (local_14 = param_3 + -1; -1 < local_14; local_14 = local_14 + -1) {
iVar1 = *(int *)(param_2 + (long)local_14 * 8);
iVar2 = *(int *)(param_2 + (... |
5,109 | func0 |
#include <assert.h>
| int func0(int arr[], int ranges[][2], int rotations, int index) {
for (int i = rotations - 1; i >= 0; i--) {
int left = ranges[i][0];
int right = ranges[i][1];
if (left <= index && right >= index) {
if (index == left) {
index = right;
} else {
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int ranges1[][2] = {{0, 2}, {0, 3}};
assert(func0(arr1, ranges1, 2, 1) == 3);
int arr2[] = {1, 2, 3, 4};
int ranges2[][2] = {{0, 1}, {0, 2}};
assert(func0(arr2, ranges2, 1, 2) == 3);
int arr3[] = {1, 2, 3, 4, 5, 6};
int ranges3[][2] ... | O1 | c | func0:
endbr64
test %edx,%edx
jle 11b2 <func0+0x49>
movslq %edx,%r8
shl $0x3,%r8
lea (%rsi,%r8,1),%rax
lea -0x8(%rsi,%r8,1),%r8
lea -0x1(%rdx),%edx
shl $0x3,%rdx
sub %rdx,%r8
jmp 11a2 <func0+0x39>
lea -0x1(%rcx),%r9d
cmp %ecx,%edx
cmovne %r9d,%esi
mov %esi,%ecx
sub $0x8,%rax
cmp ... | func0:
endbr64
mov r9, rdi
test edx, edx
jle short loc_11B5
movsxd rdi, edx
shl rdi, 3
lea rax, [rsi+rdi]
lea rdi, [rsi+rdi-8]
lea edx, [rdx-1]
shl rdx, 3
sub rdi, rdx
jmp short loc_11A5
loc_1190:
lea r8d, [rcx-1]
cmp edx, ecx
cmovnz esi, r8d
mov ecx, esi
loc_119C:
s... | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v5; // rax
long long v6; // rdi
int v7; // esi
int v8; // edx
if ( a3 > 0 )
{
v5 = a2 + 8LL * a3;
v6 = v5 - 8 - 8LL * (unsigned int)(a3 - 1);
do
{
v8 = *(_DWORD *)(v5 - 8);
v7 = *(_DWORD *)(v5 - 4);
i... | func0:
ENDBR64
MOV R9,RDI
TEST EDX,EDX
JLE 0x001011b5
MOVSXD RDI,EDX
SHL RDI,0x3
LEA RAX,[RSI + RDI*0x1]
LEA RDI,[RSI + RDI*0x1 + -0x8]
LEA EDX,[RDX + -0x1]
SHL RDX,0x3
SUB RDI,RDX
JMP 0x001011a5
LAB_00101190:
LEA R8D,[RCX + -0x1]
CMP EDX,ECX
CMOVNZ ESI,R8D
MOV ECX,ESI
LAB_0010119c:
SUB RAX,0x8
CMP RAX,RDI
JZ 0x001011b... | int4 func0(long param_1,long param_2,int param_3,int param_4)
{
long lVar1;
int iVar2;
bool bVar3;
if (0 < param_3) {
lVar1 = param_2 + (long)param_3 * 8;
do {
if (((*(int *)(lVar1 + -8) <= param_4) && (param_4 <= *(int *)(lVar1 + -4))) &&
(iVar2 = param_4 + -1, bVar3 = *(int *)(lVar1... |
5,110 | func0 |
#include <assert.h>
| int func0(int arr[], int ranges[][2], int rotations, int index) {
for (int i = rotations - 1; i >= 0; i--) {
int left = ranges[i][0];
int right = ranges[i][1];
if (left <= index && right >= index) {
if (index == left) {
index = right;
} else {
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int ranges1[][2] = {{0, 2}, {0, 3}};
assert(func0(arr1, ranges1, 2, 1) == 3);
int arr2[] = {1, 2, 3, 4};
int ranges2[][2] = {{0, 1}, {0, 2}};
assert(func0(arr2, ranges2, 1, 2) == 3);
int arr3[] = {1, 2, 3, 4, 5, 6};
int ranges3[][2] ... | O2 | c | func0:
endbr64
test %edx,%edx
jle 118b <func0+0x4b>
movslq %edx,%r8
sub $0x1,%edx
shl $0x3,%r8
shl $0x3,%rdx
lea (%rsi,%r8,1),%rax
lea -0x8(%rsi,%r8,1),%r8
sub %rdx,%r8
nopw 0x0(%rax,%rax,1)
mov -0x8(%rax),%edx
mov -0x4(%rax),%esi
cmp %ecx,%edx
jg 1182 <func0+0x42>
cmp %ecx,%esi... | func0:
endbr64
mov r9, rdi
test edx, edx
jle short loc_133B
movsxd rdi, edx
sub edx, 1
shl rdi, 3
shl rdx, 3
lea rax, [rsi+rdi]
lea rdi, [rsi+rdi-8]
sub rdi, rdx
nop dword ptr [rax]
loc_1318:
mov edx, [rax-8]
mov esi, [rax-4]
cmp edx, ecx
jg short loc_1332
cmp ... | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v5; // rax
long long v6; // rdi
int v7; // edx
int v8; // esi
if ( a3 > 0 )
{
v5 = a2 + 8LL * a3;
v6 = v5 - 8 - 8LL * (unsigned int)(a3 - 1);
do
{
v7 = *(_DWORD *)(v5 - 8);
v8 = *(_DWORD *)(v5 - 4);
i... | func0:
ENDBR64
MOV R9,RDI
TEST EDX,EDX
JLE 0x0010133b
MOVSXD RDI,EDX
SUB EDX,0x1
SHL RDI,0x3
SHL RDX,0x3
LEA RAX,[RSI + RDI*0x1]
LEA RDI,[RSI + RDI*0x1 + -0x8]
SUB RDI,RDX
NOP dword ptr [RAX]
LAB_00101318:
MOV EDX,dword ptr [RAX + -0x8]
MOV ESI,dword ptr [RAX + -0x4]
CMP EDX,ECX
JG 0x00101332
CMP ESI,ECX
JL 0x00101332
... | int4 func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
long lVar2;
bool bVar3;
if (0 < param_3) {
lVar2 = param_2 + (long)param_3 * 8;
do {
if (((*(int *)(lVar2 + -8) <= param_4) && (param_4 <= *(int *)(lVar2 + -4))) &&
(iVar1 = param_4 + -1, bVar3 = *(int *)(lVar2... |
5,111 | func0 |
#include <assert.h>
| int func0(int arr[], int ranges[][2], int rotations, int index) {
for (int i = rotations - 1; i >= 0; i--) {
int left = ranges[i][0];
int right = ranges[i][1];
if (left <= index && right >= index) {
if (index == left) {
index = right;
} else {
... | int main() {
int arr1[] = {1, 2, 3, 4, 5};
int ranges1[][2] = {{0, 2}, {0, 3}};
assert(func0(arr1, ranges1, 2, 1) == 3);
int arr2[] = {1, 2, 3, 4};
int ranges2[][2] = {{0, 1}, {0, 2}};
assert(func0(arr2, ranges2, 1, 2) == 3);
int arr3[] = {1, 2, 3, 4, 5, 6};
int ranges3[][2] ... | O3 | c | func0:
endbr64
test %edx,%edx
jle 11e9 <func0+0x49>
movslq %edx,%r8
sub $0x1,%edx
shl $0x3,%r8
shl $0x3,%rdx
lea (%rsi,%r8,1),%rax
lea -0x8(%rsi,%r8,1),%r8
sub %rdx,%r8
nopw 0x0(%rax,%rax,1)
mov -0x4(%rax),%edx
mov -0x8(%rax),%esi
cmp %ecx,%edx
jl 11e0 <func0+0x40>
cmp %ecx,%esi... | func0:
endbr64
mov r9, rdi
test edx, edx
jle short loc_11D9
movsxd rdi, edx
sub edx, 1
shl rdi, 3
shl rdx, 3
lea rax, [rsi+rdi]
lea rdi, [rsi+rdi-8]
sub rdi, rdx
nop dword ptr [rax]
loc_11B8:
mov edx, [rax-4]
mov esi, [rax-8]
cmp edx, ecx
jl short loc_11D0
cmp ... | long long func0(long long a1, long long a2, int a3, int a4)
{
long long v5; // rax
long long v6; // rdi
int v7; // edx
int v8; // esi
if ( a3 > 0 )
{
v5 = a2 + 8LL * a3;
v6 = v5 - 8 - 8LL * (unsigned int)(a3 - 1);
do
{
v7 = *(_DWORD *)(v5 - 4);
v8 = *(_DWORD *)(v5 - 8);
i... | func0:
ENDBR64
MOV R9,RDI
TEST EDX,EDX
JLE 0x001011d9
MOVSXD RDI,EDX
SUB EDX,0x1
SHL RDI,0x3
SHL RDX,0x3
LEA RAX,[RSI + RDI*0x1]
LEA RDI,[RSI + RDI*0x1 + -0x8]
SUB RDI,RDX
NOP dword ptr [RAX]
LAB_001011b8:
MOV EDX,dword ptr [RAX + -0x4]
MOV ESI,dword ptr [RAX + -0x8]
CMP EDX,ECX
JL 0x001011d0
CMP ESI,ECX
JG 0x001011d0
... | int4 func0(long param_1,long param_2,int param_3,int param_4)
{
int iVar1;
long lVar2;
bool bVar3;
if (0 < param_3) {
lVar2 = param_2 + (long)param_3 * 8;
do {
if (((param_4 <= *(int *)(lVar2 + -4)) &&
(bVar3 = *(int *)(lVar2 + -8) != param_4, *(int *)(lVar2 + -8) <= param_4)) &&
... |
5,112 | func0 | #include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char** func0(char *words[], int size) {
regex_t regex;
regmatch_t matches[3];
static char* result[2];
int ret;
ret = regcomp(®ex, "(P\\w+)\\W(P\\w+)", REG_EXTENDED);
if (ret) {
fprintf(stderr, "Could not compile regex\n");
return NULL;
}
for (int i = ... | int main() {
char *test_words1[] = {"Python PHP", "Java JavaScript", "c c++"};
char *test_words2[] = {"Python Programming", "Java Programming"};
char *test_words3[] = {"Pqrst Pqr", "qrstuv"};
char **result = func0(test_words1, 3);
assert(result != NULL && strcmp(result[0], "Python") == 0 ... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
add $0xffffffffffffff80,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov $0x1,%edx
lea 0xdad(%rip),%rsi
mov %rax,%rdi
callq 10f0 <regcomp@plt>
mov %eax,-0x64(%rbp)
cmp... | func0:
endbr64
push rbp
mov rbp, rsp
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_78], rdi
mov [rbp+var_7C], esi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rax, [rbp+preg]
mov edx, 1; cflags
lea rcx, pattern; "(P\\w+)\\W(P\\w+)"
mov rsi, rcx; pattern
mov rdi, ra... | long long * func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-68h]
regex_t preg; // [rsp+20h] [rbp-60h] BYREF
regmatch_t pmatch; // [rsp+60h] [rbp-20h] BYREF
int v6; // [rsp+68h] [rbp-18h]
int v7; // [rsp+6Ch] [rbp-14h]
int v8; // [rsp+70h] [rbp-10h]
int v9; // [rsp+74h] [rbp-Ch]
unsigned long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
ADD RSP,-0x80
MOV qword ptr [RBP + -0x78],RDI
MOV dword ptr [RBP + -0x7c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x60]
MOV EDX,0x1
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x64],EAX
CMP dword ... | int1 * func0(long param_1,int param_2)
{
int iVar1;
int1 *puVar2;
long in_FS_OFFSET;
int local_70;
regex_t local_68;
regmatch_t local_28;
int local_20;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = regcomp(&local_68,"(P\\w+)\\W(... |
5,113 | func0 | #include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char** func0(char *words[], int size) {
regex_t regex;
regmatch_t matches[3];
static char* result[2];
int ret;
ret = regcomp(®ex, "(P\\w+)\\W(P\\w+)", REG_EXTENDED);
if (ret) {
fprintf(stderr, "Could not compile regex\n");
return NULL;
}
for (int i = ... | int main() {
char *test_words1[] = {"Python PHP", "Java JavaScript", "c c++"};
char *test_words2[] = {"Python Programming", "Java Programming"};
char *test_words3[] = {"Pqrst Pqr", "qrstuv"};
char **result = func0(test_words1, 3);
assert(result != NULL && strcmp(result[0], "Python") == 0 ... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x68,%rsp
mov %rdi,%r12
mov %esi,%ebp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0x1,%edx
lea 0xdc9(%rip),%rsi
callq 10e0 <regcomp@plt>
test %eax,%eax
jne 12aa <func0+0xa1>
test %ebp,%ebp
j... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 68h
mov r12, rdi
mov ebp, esi
mov rax, fs:28h
mov [rsp+88h+var_30], rax
xor eax, eax
mov rdi, rsp
mov edx, 1
lea rsi, aPWWPW; "(P\\w+)\\W(P\\w+)"
call _regcomp
test eax, eax
jnz short loc_12CA
test e... | long long * func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
_BYTE v4[64]; // [rsp+0h] [rbp-88h] BYREF
_BYTE v5[8]; // [rsp+40h] [rbp-48h] BYREF
int v6; // [rsp+48h] [rbp-40h]
int v7; // [rsp+4Ch] [rbp-3Ch]
int v8; // [rsp+50h] [rbp-38h]
int v9; // [rsp+54h] [rbp-34h]
unsigned long long v10; // [rsp+58h] ... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x68
MOV R12,RDI
MOV EBP,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV EDX,0x1
LEA RSI,[0x102004]
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x001012ca
TEST EBP,EBP
JLE 0x0010129e
MOV RBX,R12
LEA EAX,[RBP + -0x1]
LEA R13,[R12 ... | int1 * func0(long *param_1,int param_2)
{
long *plVar1;
int iVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar2 = regcomp(&rStack_88,"(P\\w+)\... |
5,114 | func0 | #include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char** func0(char *words[], int size) {
regex_t regex;
regmatch_t matches[3];
static char* result[2];
int ret;
ret = regcomp(®ex, "(P\\w+)\\W(P\\w+)", REG_EXTENDED);
if (ret) {
fprintf(stderr, "Could not compile regex\n");
return NULL;
}
for (int i = ... | int main() {
char *test_words1[] = {"Python PHP", "Java JavaScript", "c c++"};
char *test_words2[] = {"Python Programming", "Java Programming"};
char *test_words3[] = {"Pqrst Pqr", "qrstuv"};
char **result = func0(test_words1, 3);
assert(result != NULL && strcmp(result[0], "Python") == 0 ... | O2 | c | func0:
endbr64
push %r13
mov $0x1,%edx
push %r12
push %rbp
mov %esi,%ebp
lea 0xbfd(%rip),%rsi
push %rbx
mov %rdi,%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10e0 <regcomp@plt>
test %eax,%eax
jne 14f8 <func0+0x108>
... | func0:
endbr64
push r13
mov edx, 1
push r12
mov r12d, esi
lea rsi, aPWWPW; "(P\\w+)\\W(P\\w+)"
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+var_s58], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp
call _regcomp
test eax, eax
jnz loc_14F0
... | long long * func0(_QWORD *a1, int a2)
{
_QWORD *v2; // rbx
_BYTE _0[64]; // [rsp+0h] [rbp+0h] BYREF
char vars40; // [rsp+40h] [rbp+40h] BYREF
int vars48; // [rsp+48h] [rbp+48h]
int vars4C; // [rsp+4Ch] [rbp+4Ch]
int vars50; // [rsp+50h] [rbp+50h]
int vars54; // [rsp+54h] [rbp+54h]
unsigned long long var... | func0:
ENDBR64
PUSH R13
MOV EDX,0x1
PUSH R12
MOV R12D,ESI
LEA RSI,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x001014f0
TEST R12D,R12D
JLE 0x001014e0
LEA EAX,[R12 + -0x1]
LEA R12,[R... | int1 * func0(long *param_1,int param_2)
{
long *plVar1;
int iVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar2 = regcomp(&rStack_88,"(P\\w+)\... |
5,115 | func0 | #include <stdio.h>
#include <assert.h>
#include <regex.h>
#include <string.h>
| char** func0(char *words[], int size) {
regex_t regex;
regmatch_t matches[3];
static char* result[2];
int ret;
ret = regcomp(®ex, "(P\\w+)\\W(P\\w+)", REG_EXTENDED);
if (ret) {
fprintf(stderr, "Could not compile regex\n");
return NULL;
}
for (int i = ... | int main() {
char *test_words1[] = {"Python PHP", "Java JavaScript", "c c++"};
char *test_words2[] = {"Python Programming", "Java Programming"};
char *test_words3[] = {"Pqrst Pqr", "qrstuv"};
char **result = func0(test_words1, 3);
assert(result != NULL && strcmp(result[0], "Python") == 0 ... | O3 | c | func0:
endbr64
push %r13
mov $0x1,%edx
push %r12
push %rbp
mov %esi,%ebp
lea 0xbdd(%rip),%rsi
push %rbx
mov %rdi,%rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
mov %rsp,%r13
mov %r13,%rdi
callq 10e0 <regcomp@plt>
test %eax,%eax
jne 1518 <func0+0x108>
... | func0:
endbr64
push r13
mov edx, 1; cflags
push r12
movsxd r12, esi
lea rsi, pattern; "(P\\w+)\\W(P\\w+)"
push rbp
push rbx
mov rbx, rdi
sub rsp, 68h
mov rax, fs:28h
mov [rsp+var_s58], rax
xor eax, eax
mov rbp, rsp
mov rdi, rbp; preg
call _regcomp
test eax, eax
jnz... | long long * func0(const char **a1, int a2)
{
const char **v2; // rbx
regex_t vars0; // [rsp+0h] [rbp+0h] BYREF
regmatch_t pmatch; // [rsp+40h] [rbp+40h] BYREF
int vars48; // [rsp+48h] [rbp+48h]
int vars4C; // [rsp+4Ch] [rbp+4Ch]
int vars50; // [rsp+50h] [rbp+50h]
int vars54; // [rsp+54h] [rbp+54h]
unsig... | func0:
ENDBR64
PUSH R13
MOV EDX,0x1
PUSH R12
MOVSXD R12,ESI
LEA RSI,[0x102004]
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x68
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x58],RAX
XOR EAX,EAX
MOV RBP,RSP
MOV RDI,RBP
CALL 0x001010f0
TEST EAX,EAX
JNZ 0x00101500
TEST R12D,R12D
JLE 0x001014f0
LEA R13,[RBX + R12*0x8]
LEA R... | int1 * func0(long *param_1,int param_2)
{
long *plVar1;
int iVar2;
int1 *puVar3;
long in_FS_OFFSET;
regex_t rStack_88;
regmatch_t local_48;
int local_40;
int local_3c;
int local_38;
int local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar2 = regcomp(&rStack_88,"(P\\w+)\... |
5,116 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int index, int k) {
int dp[n][n];
for(int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
if (a[i] > a[0]) {
dp[0][i] = a[i] + a[0];
} else {
... | int main() {
int a1[] = {1, 101, 2, 3, 100, 4, 5};
int a2[] = {11, 15, 19, 21, 26, 28, 31};
assert(func0(a1, 7, 4, 6) == 11);
assert(func0(a1, 7, 2, 5) == 7);
assert(func0(a2, 7, 2, 4) == 71);
printf("All test cases passed\n");
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %esi,-0x7c(%rbp)
mov %edx,-0x80(%rbp)
mov %ecx,-0x84(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,-0x90(%rbp)... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_58], rdi
mov [rbp+var_5C], esi
mov [rbp+var_60], edx
mov [rbp+var_64], ecx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov r8d, [rbp+var_5C]
mov r9d, [rbp+va... | long long func0(_DWORD *a1, int a2, int a3, int a4)
{
unsigned long long v4; // rcx
unsigned long long v5; // rax
void *v6; // rsp
int v7; // esi
_BYTE v9[12]; // [rsp+8h] [rbp-70h] BYREF
int v10; // [rsp+14h] [rbp-64h]
int v11; // [rsp+18h] [rbp-60h]
int v12; // [rsp+1Ch] [rbp-5Ch]
_DWORD *v13; // [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x58],RDI
MOV dword ptr [RBP + -0x5c],ESI
MOV dword ptr [RBP + -0x60],EDX
MOV dword ptr [RBP + -0x64],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV R8D,dword ptr [RBP + -0x5c]
MOV R9... | int4 func0(int *param_1,int param_2,int param_3,int param_4)
{
long lVar1;
ulong uVar2;
ulong uVar3;
int *puVar4;
long in_FS_OFFSET;
int auStack_78 [12];
int local_6c;
int local_68;
int local_64;
int *local_60;
int local_4c;
int local_48;
int local_44;
int local_40;
int local_3c;
long l... |
5,117 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int index, int k) {
int dp[n][n];
for(int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
if (a[i] > a[0]) {
dp[0][i] = a[i] + a[0];
} else {
... | int main() {
int a1[] = {1, 101, 2, 3, 100, 4, 5};
int a2[] = {11, 15, 19, 21, 26, 28, 31};
assert(func0(a1, 7, 4, 6) == 11);
assert(func0(a1, 7, 2, 5) == 7);
assert(func0(a2, 7, 2, 4) == 71);
printf("All test cases passed\n");
return 0;
}
| O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x48,%rsp
mov %edx,-0x64(%rbp)
mov %ecx,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0x0(,%rax,4),%rbx
imul %rax,%rax
lea 0xf(,%rax,4),%rax
mov ... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov [rbp+var_54], edx
mov [rbp+var_58], ecx
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movsxd rax, esi
lea rbx, ds:0[rax*4]
imul rax, rax
lea rax, ds:0Fh[rax*4... | long long func0(int *a1, int a2, int a3, int a4)
{
unsigned long long v4; // rbx
signed long long v5; // rax
void *v6; // rsp
_BYTE *v7; // rdx
unsigned int i; // ecx
_DWORD *v9; // rax
int v10; // r9d
long long v11; // r8
long long j; // rax
int v13; // ecx
int v14; // edx
_BYTE *v15; // r13
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RBP + -0x54],EDX
MOV dword ptr [RBP + -0x58],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVSXD RAX,ESI
LEA RBX,[RAX*0x4]
IMUL RAX,RAX
LEA RAX,[0xf + RAX*0x4]
MOV RCX,RAX
AND RCX,... | int4 func0(int *param_1,uint param_2,int param_3,int param_4)
{
long lVar1;
int iVar2;
long lVar3;
uint uVar4;
ulong uVar5;
int4 *puVar6;
ulong uVar7;
uint uVar8;
int iVar9;
ulong uVar10;
int iVar11;
int4 *puVar12;
long lVar13;
int1 *puVar14;
int1 *puVar15;
int1 *puVar16;
int1 *puVar1... |
5,118 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int index, int k) {
int dp[n][n];
for(int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
if (a[i] > a[0]) {
dp[0][i] = a[i] + a[0];
} else {
... | int main() {
int a1[] = {1, 101, 2, 3, 100, 4, 5};
int a2[] = {11, 15, 19, 21, 26, 28, 31};
assert(func0(a1, 7, 4, 6) == 11);
assert(func0(a1, 7, 2, 5) == 7);
assert(func0(a2, 7, 2, 4) == 71);
printf("All test cases passed\n");
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x38,%rsp
mov %edx,-0x5c(%rbp)
mov %ecx,-0x60(%rbp)
mov %rsp,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0x0(,%rax,4),%r15
imul %rax,%rax
lea 0xf(,... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12d, esi
push rbx
mov rbx, rdi
sub rsp, 48h
mov [rbp+var_4C], edx
mov [rbp+var_50], ecx
movsxd rcx, esi
mov rsi, rsp
lea r9, ds:0[rcx*4]
mov rax, fs:28h
mov [rbp+var_38], rax
xor ... | long long func0(_DWORD *a1, int a2, int a3, int a4)
{
long long v6; // rcx
unsigned long long v7; // r9
long long v8; // rdx
long long *v9; // rsi
__int16 v10; // dx
signed long long v11; // rdx
void *v12; // rsp
_BYTE *v13; // rdi
int v14; // ebx
unsigned long long v15; // r14
_DWORD *v16; // rb... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,ESI
PUSH RBX
MOV RBX,RDI
SUB RSP,0x48
MOV dword ptr [RBP + -0x4c],EDX
MOV dword ptr [RBP + -0x50],ECX
MOVSXD RCX,ESI
MOV RSI,RSP
LEA R9,[RCX*0x4]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RAX,RCX
IMUL RAX,... | int4 func0(int *param_1,uint param_2,int param_3,int param_4)
{
long lVar1;
long lVar2;
int iVar3;
void *pvVar4;
ulong uVar5;
int iVar6;
long lVar7;
uint uVar8;
int1 *puVar9;
int iVar11;
int1 *__s;
int1 *puVar12;
int1 *puVar13;
ulong uVar14;
int iVar15;
long in_FS_OFFSET;
int1 auStack... |
5,119 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int a[], int n, int index, int k) {
int dp[n][n];
for(int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
if (a[i] > a[0]) {
dp[0][i] = a[i] + a[0];
} else {
... | int main() {
int a1[] = {1, 101, 2, 3, 100, 4, 5};
int a2[] = {11, 15, 19, 21, 26, 28, 31};
assert(func0(a1, 7, 4, 6) == 11);
assert(func0(a1, 7, 2, 5) == 7);
assert(func0(a2, 7, 2, 4) == 71);
printf("All test cases passed\n");
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
mov %esi,%r14d
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x48,%rsp
mov %edx,-0x5c(%rbp)
mov %ecx,-0x60(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movslq %esi,%rax
lea 0x0(,%rax,4),%rbx
imul %rax... | func0:
endbr64
push rbp
movsxd rax, ecx
mov rbp, rsp
push r15
push r14
push r13
movsxd r13, esi
push r12
mov r12, rdi
lea r14, ds:0[r13*4]
push rbx
sub rsp, 48h
mov rcx, fs:28h
mov [rbp+var_38], rcx
xor ecx, ecx
mov rcx, r13
mov r8, rsp
imul rcx, r13
lea rc... | long long func0(signed int *a1, int a2, int a3, int a4)
{
long long v4; // rax
unsigned long long v6; // r14
long long v7; // rdi
_BYTE *v8; // r8
__int16 v9; // di
signed long long v10; // rdi
void *v11; // rsp
_BYTE *v12; // r10
unsigned long long v13; // r11
char *v14; // rdi
int v15; // r13d
... | func0:
ENDBR64
PUSH RBP
MOVSXD RAX,ECX
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
MOVSXD R13,ESI
PUSH R12
MOV R12,RDI
LEA R14,[R13*0x4]
PUSH RBX
SUB RSP,0x48
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RCX
XOR ECX,ECX
MOV RCX,R13
MOV R8,RSP
IMUL RCX,R13
LEA RCX,[0xf + RCX*0x4]
MOV RDI,RCX
AND RCX,-0x1000
SUB R8... | int4 func0(int *param_1,uint param_2,int param_3,int param_4)
{
uint *puVar1;
long lVar2;
int iVar3;
long lVar4;
uint uVar5;
uint uVar6;
uint uVar7;
uint uVar8;
int **ppuVar9;
void *pvVar10;
ulong uVar11;
int *piVar12;
int *puVar13;
int **ppuVar14;
int iVar16;
int *puVar17;
int iVar18... |
5,120 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *str;
int num;
int *array;
int array_size;
int boolean;
} Tuple;
| Tuple func0(Tuple tuplex, int m, int n) {
Tuple tuplex_colon;
tuplex_colon.str = strdup(tuplex.str);
tuplex_colon.num = tuplex.num;
tuplex_colon.array = (int *)malloc(sizeof(int) * (tuplex.array_size + 1));
for (int i = 0; i < tuplex.array_size; i++) {
tuplex_colon.array[i] = tuplex.ar... | int main() {
Tuple tup1 = {"HELLO", 5, NULL, 0, 1};
Tuple result;
result = func0(tup1, 2, 50);
assert(strcmp(result.str, "HELLO") == 0 && result.num == 5 && result.array[0] == 50 && result.boolean == 1);
result = func0(tup1, 2, 100);
assert(strcmp(result.str, "HELLO") == 0 && result.nu... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov 0x10(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strdup@plt>
mov %rax,-0x20(%rbp)
mov 0x18(%rbp),%eax
mov %eax,-0x18(%rbp)
mov 0x28(%rbp),%eax
add $0x1,%eax
cltq
shl ... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov rax, [rbp+s]
mov rdi, rax; s
call _strdup
mov [rbp+var_20], rax
mov eax, [rbp+arg_8]
mov dword ptr [rbp+var_18], eax
mov eax, dword ptr [rbp+arg_18]
a... | char ** func0(char **a1, int a2, int a3, int a4, int a5, int a6, char *s, int a8, long long a9, long long a10)
{
int i; // [rsp+1Ch] [rbp-24h]
char *v13; // [rsp+20h] [rbp-20h]
char *v14; // [rsp+28h] [rbp-18h]
char *v15; // [rsp+30h] [rbp-10h]
char *v16; // [rsp+38h] [rbp-8h]
v13 = strdup(s);
LODWORD(v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV RAX,qword ptr [RBP + 0x10]
MOV RDI,RAX
CALL 0x001010f0
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RBP + 0x18]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RB... | int8 * func0(int8 *param_1,int8 param_2,int4 param_3)
{
char *pcVar1;
void *pvVar2;
char *param_7;
int4 param_8;
long param_9;
int param_10;
int4 param_11;
int local_2c;
int4 uStack_1c;
pcVar1 = strdup(param_7);
pvVar2 = malloc((long)(param_10 + 1) << 2);
for (local_2c = 0; local_2c < param_... |
5,121 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *str;
int num;
int *array;
int array_size;
int boolean;
} Tuple;
| Tuple func0(Tuple tuplex, int m, int n) {
Tuple tuplex_colon;
tuplex_colon.str = strdup(tuplex.str);
tuplex_colon.num = tuplex.num;
tuplex_colon.array = (int *)malloc(sizeof(int) * (tuplex.array_size + 1));
for (int i = 0; i < tuplex.array_size; i++) {
tuplex_colon.array[i] = tuplex.ar... | int main() {
Tuple tup1 = {"HELLO", 5, NULL, 0, 1};
Tuple result;
result = func0(tup1, 2, 50);
assert(strcmp(result.str, "HELLO") == 0 && result.num == 5 && result.array[0] == 50 && result.boolean == 1);
result = func0(tup1, 2, 100);
assert(strcmp(result.str, "HELLO") == 0 && result.nu... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,%rbx
mov %edx,%r12d
mov 0x68(%rsp),%r13d
mov 0x50(%rsp),%rdi
callq 10d0 <strdup@plt>
mov %rax,0x8(%rsp)
mov 0x58(%rsp),%r15d
lea 0x1(%r13),%r14d
movslq %r14d,%rbp
shl $0x2,%rbp
mov ... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rbp, rdi
mov r13d, edx
mov ebx, [rsp+48h+arg_18]
mov rdi, [rsp+48h+arg_0]
call _strdup
mov [rsp+48h+var_40], rax
mov r15d, [rsp+48h+arg_8]
lea r14d, [rbx+1]
movsxd r12, r14d
shl ... | long long func0(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7,
int a8,
long long a9,
long long a10)
{
int v11; // r14d
long long v12; // rax
long long v13; // rdx
long long v15; // [rsp... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RBP,RDI
MOV R13D,EDX
MOV EBX,dword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOV R15D,dword ptr [RSP + 0x58]
LEA R14D,[RBX + 0x1]
MOVSXD R12,R14D
SHL R12,0x2
MOV RDI,R12
CALL 0x00101... | int8 * func0(int8 *param_1,int8 param_2,int4 param_3)
{
char *pcVar1;
void *pvVar2;
ulong uVar3;
size_t __size;
char *in_stack_00000008;
int4 in_stack_00000010;
long in_stack_00000018;
int iStack0000000000000020;
int4 uStack0000000000000024;
pcVar1 = strdup(in_stack_00000008);
__size = (long)(... |
5,122 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *str;
int num;
int *array;
int array_size;
int boolean;
} Tuple;
| Tuple func0(Tuple tuplex, int m, int n) {
Tuple tuplex_colon;
tuplex_colon.str = strdup(tuplex.str);
tuplex_colon.num = tuplex.num;
tuplex_colon.array = (int *)malloc(sizeof(int) * (tuplex.array_size + 1));
for (int i = 0; i < tuplex.array_size; i++) {
tuplex_colon.array[i] = tuplex.ar... | int main() {
Tuple tup1 = {"HELLO", 5, NULL, 0, 1};
Tuple result;
result = func0(tup1, 2, 50);
assert(strcmp(result.str, "HELLO") == 0 && result.num == 5 && result.array[0] == 50 && result.boolean == 1);
result = func0(tup1, 2, 100);
assert(strcmp(result.str, "HELLO") == 0 && result.nu... | O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
mov %edx,%r13d
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x68(%rsp),%ebp
mov 0x50(%rsp),%rdi
callq 10d0 <strdup@plt>
lea 0x1(%rbp),%r14d
mov 0x58(%rsp),%r15d
movslq %r14d,%rdx
mov %rax,%rbx
shl $0x2,%rdx
mov %rd... | func0:
endbr64
push r15
push r14
push r13
mov r13d, edx
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 18h
mov ebx, [rsp+48h+arg_18]
mov rdi, [rsp+48h+arg_0]
call _strdup
lea r14d, [rbx+1]
mov r15d, [rsp+48h+arg_8]
movsxd rbp, r14d
mov [rsp+48h+var_40], rax
shl ... | long long func0(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7,
int a8,
long long a9,
long long a10)
{
int v11; // r14d
long long v12; // rax
long long v13; // rcx
long long result; // r... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13D,EDX
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV EBX,dword ptr [RSP + 0x68]
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00101110
LEA R14D,[RBX + 0x1]
MOV R15D,dword ptr [RSP + 0x58]
MOVSXD RBP,R14D
MOV qword ptr [RSP + 0x8],RAX
SHL RBP,0x2
MOV RDI,RBP
CALL 0x00101... | int8 * func0(int8 *param_1,int8 param_2,int4 param_3)
{
char *pcVar1;
void *__dest;
size_t __size;
char *in_stack_00000008;
int4 in_stack_00000010;
void *in_stack_00000018;
int iStack0000000000000020;
int4 uStack0000000000000024;
pcVar1 = strdup(in_stack_00000008);
__size = (long)(iStack00000000... |
5,123 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
typedef struct {
char *str;
int num;
int *array;
int array_size;
int boolean;
} Tuple;
| Tuple func0(Tuple tuplex, int m, int n) {
Tuple tuplex_colon;
tuplex_colon.str = strdup(tuplex.str);
tuplex_colon.num = tuplex.num;
tuplex_colon.array = (int *)malloc(sizeof(int) * (tuplex.array_size + 1));
for (int i = 0; i < tuplex.array_size; i++) {
tuplex_colon.array[i] = tuplex.ar... | int main() {
Tuple tup1 = {"HELLO", 5, NULL, 0, 1};
Tuple result;
result = func0(tup1, 2, 50);
assert(strcmp(result.str, "HELLO") == 0 && result.num == 5 && result.array[0] == 50 && result.boolean == 1);
result = func0(tup1, 2, 100);
assert(strcmp(result.str, "HELLO") == 0 && result.nu... | O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x18,%rsp
mov 0x68(%rsp),%r13d
mov 0x50(%rsp),%rdi
mov %edx,0xc(%rsp)
callq 10f0 <strdup@plt>
lea 0x1(%r13),%r14d
mov 0x58(%rsp),%r15d
movslq %r14d,%rbx
mov %rax,%rbp
shl $0x2,%rbx
mov ... | func0:
endbr64
push r15
push r14
mov r14d, edx
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 18h
mov rdi, [rsp+48h+s]; s
mov ebx, dword ptr [rsp+48h+arg_18]
call _strdup
mov r15d, [rsp+48h+arg_8]
mov rbp, rax
lea eax, [rbx+1]
movsxd r12, eax
mov [rsp... | long long func0(long long a1, int a2, int a3, int a4, int a5, int a6, char *s, int a8, void *src, long long a10)
{
char *v12; // rbp
void *v13; // rdi
long long result; // rax
v12 = strdup(s);
v13 = malloc(4LL * ((int)a10 + 1));
if ( (int)a10 > 0 )
v13 = memcpy(v13, src, 4LL * (unsigned int)a10);
*(... | func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14D,EDX
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RDI,qword ptr [RSP + 0x50]
MOV EBX,dword ptr [RSP + 0x68]
CALL 0x00101110
MOV R15D,dword ptr [RSP + 0x58]
MOV RBP,RAX
LEA EAX,[RBX + 0x1]
MOVSXD R12,EAX
MOV dword ptr [RSP + 0xc],EAX
SHL R12,0x2
MOV RDI,R12
CA... | int8 * func0(int8 *param_1,int8 param_2,int4 param_3)
{
char *pcVar1;
void *__dest;
size_t __size;
char *param_7;
int4 param_8;
void *param_9;
int param_10;
int4 param_11;
pcVar1 = strdup(param_7);
__size = (long)(param_10 + 1) * 4;
__dest = malloc(__size);
if (0 < param_10) {
__dest = m... |
5,124 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)b - *(int*)a);
}
| int* func0(int* nums1, int* nums2, int size1, int size2, int N) {
int* result = malloc(sizeof(int) * N);
int* products = malloc(sizeof(int) * size1 * size2);
int index = 0;
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
products[index++] = nums1[i] * ... | int main() {
int nums1[] = {1, 2, 3, 4, 5, 6};
int nums2[] = {3, 6, 8, 9, 10, 6};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int* res;
res = func0(nums1, nums2, size1, size2, 3);
assert(res[0] == 60 && res[1] == 54 && res[2] == 50... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %edx,-0x34(%rbp)
mov %ecx,-0x38(%rbp)
mov %r8d,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10d0 <malloc@plt>
mov %rax,-0x10(%rbp)
mov -0x34(%rbp),%eax
mo... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov [rbp+var_34], edx
mov [rbp+var_38], ecx
mov [rbp+var_3C], r8d
mov eax, [rbp+var_3C]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_10], rax
mov eax, [rbp+... | _DWORD * func0(long long a1, long long a2, int a3, int a4, int a5)
{
int v5; // eax
int v10; // [rsp+20h] [rbp-20h]
int i; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+28h] [rbp-18h]
int k; // [rsp+2Ch] [rbp-14h]
_DWORD *v14; // [rsp+30h] [rbp-10h]
_DWORD *base; // [rsp+38h] [rbp-8h]
v14 = malloc(4LL * a5);
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x34],EDX
MOV dword ptr [RBP + -0x38],ECX
MOV dword ptr [RBP + -0x3c],R8D
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x10],RAX
MO... | void * func0(long param_1,long param_2,int param_3,int param_4,int param_5)
{
void *pvVar1;
void *__base;
int local_28;
int local_24;
int local_20;
int local_1c;
pvVar1 = malloc((long)param_5 << 2);
__base = malloc((long)param_4 * (long)param_3 * 4);
local_28 = 0;
for (local_24 = 0; local_24 < p... |
5,125 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)b - *(int*)a);
}
| int* func0(int* nums1, int* nums2, int size1, int size2, int N) {
int* result = malloc(sizeof(int) * N);
int* products = malloc(sizeof(int) * size1 * size2);
int index = 0;
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
products[index++] = nums1[i] * ... | int main() {
int nums1[] = {1, 2, 3, 4, 5, 6};
int nums2[] = {3, 6, 8, 9, 10, 6};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int* res;
res = func0(nums1, nums2, size1, size2, 3);
assert(res[0] == 60 && res[1] == 54 && res[2] == 50... | O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %rdi,0x8(%rsp)
mov %rsi,%rbx
mov %edx,%r14d
mov %ecx,%ebp
mov %r8d,%r15d
movslq %r8d,%rdi
shl $0x2,%rdi
callq 10d0 <malloc@plt>
mov %rax,%r13
movslq %r14d,%rdi
movslq %ebp,%rax
imul %rax,... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov [rsp+48h+var_40], rdi
mov rbx, rsi
mov r14d, edx
mov r12d, ecx
mov [rsp+48h+var_44], r8d
movsxd rdi, r8d
shl rdi, 2
call _malloc
mov r13, rax
movsxd r15, r14d
movsxd rax, r12d
im... | long long func0(int *a1, long long a2, int a3, int a4, int a5)
{
long long v8; // r13
long long v9; // rbp
int *v10; // r8
int v11; // r9d
int v12; // esi
long long v13; // rax
long long v14; // rax
v8 = malloc(4LL * a5);
v9 = malloc(4 * a4 * (long long)a3);
if ( a3 > 0 )
{
v10 = a1;
v11... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RBX,RSI
MOV R14D,EDX
MOV R12D,ECX
MOV dword ptr [RSP + 0x4],R8D
MOVSXD RDI,R8D
SHL RDI,0x2
CALL 0x001010d0
MOV R13,RAX
MOVSXD R15,R14D
MOVSXD RAX,R12D
IMUL R15,RAX
LEA RDI,[R15*0x4]
CALL 0x001010d0
MOV RB... | void * func0(int *param_1,long param_2,int param_3,uint param_4,uint param_5)
{
int *piVar1;
int iVar2;
void *pvVar3;
void *__base;
ulong uVar4;
int iVar5;
pvVar3 = malloc((long)(int)param_5 << 2);
__base = malloc((long)param_3 * (long)(int)param_4 * 4);
if (0 < param_3) {
piVar1 = param_1 + (... |
5,126 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)b - *(int*)a);
}
| int* func0(int* nums1, int* nums2, int size1, int size2, int N) {
int* result = malloc(sizeof(int) * N);
int* products = malloc(sizeof(int) * size1 * size2);
int index = 0;
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
products[index++] = nums1[i] * ... | int main() {
int nums1[] = {1, 2, 3, 4, 5, 6};
int nums2[] = {3, 6, 8, 9, 10, 6};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int* res;
res = func0(nums1, nums2, size1, size2, 3);
assert(res[0] == 60 && res[1] == 54 && res[2] == 50... | O2 | c | func0:
endbr64
push %r15
mov %edx,%r15d
push %r14
push %r13
mov %ecx,%r13d
push %r12
mov %rdi,%r12
movslq %r8d,%rdi
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
shl $0x2,%rdi
sub $0x18,%rsp
callq 10d0 <malloc@plt>
movslq %r15d,%rdi
mov %rax,%r14
movslq %r13d,%rax
imul %rax,%rdi... | func0:
endbr64
push r15
movsxd rax, r8d
mov r15d, edx
push r14
mov r14, rdi
lea rdi, ds:0[rax*4]
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov ebx, ecx
sub rsp, 28h
mov [rsp+58h+var_54], eax
mov [rsp+58h+var_48], rax
call _malloc
movsxd r10, ebx
movsxd rsi,... | long long func0(int *a1, long long a2, int a3, int a4, int a5)
{
int *v6; // r14
long long v9; // r12
long long v10; // rsi
long long v11; // rbp
int v12; // r11d
long long v13; // r15
int v14; // edi
long long v15; // rax
long long v18; // [rsp+10h] [rbp-48h]
long long v19; // [rsp+18h] [rbp-40h]
... | func0:
ENDBR64
PUSH R15
MOVSXD RAX,R8D
MOV R15D,EDX
PUSH R14
MOV R14,RDI
LEA RDI,[RAX*0x4]
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ECX
SUB RSP,0x28
MOV dword ptr [RSP + 0x4],EAX
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
MOVSXD R10,EBX
MOVSXD RSI,R15D
IMUL RSI,R10
MOV qword ptr [RSP + 0x18],R10
MOV ... | void * func0(int *param_1,long param_2,int param_3,int param_4,int param_5)
{
int *piVar1;
int iVar2;
void *__dest;
void *__base;
long lVar3;
size_t __nmemb;
int iVar4;
__dest = malloc((long)param_5 * 4);
__nmemb = (long)param_3 * (long)param_4;
__base = malloc(__nmemb * 4);
if (0 < param_3) {... |
5,127 | func0 |
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int compare(const void *a, const void *b) {
return (*(int*)b - *(int*)a);
}
| int* func0(int* nums1, int* nums2, int size1, int size2, int N) {
int* result = malloc(sizeof(int) * N);
int* products = malloc(sizeof(int) * size1 * size2);
int index = 0;
for (int i = 0; i < size1; i++) {
for (int j = 0; j < size2; j++) {
products[index++] = nums1[i] * ... | int main() {
int nums1[] = {1, 2, 3, 4, 5, 6};
int nums2[] = {3, 6, 8, 9, 10, 6};
int size1 = sizeof(nums1) / sizeof(nums1[0]);
int size2 = sizeof(nums2) / sizeof(nums2[0]);
int* res;
res = func0(nums1, nums2, size1, size2, 3);
assert(res[0] == 60 && res[1] == 54 && res[2] == 50... | O3 | c | func0:
endbr64
push %r15
push %r14
mov %edx,%r14d
push %r13
mov %rdi,%r13
movslq %r8d,%rdi
push %r12
push %rbp
mov %ecx,%ebp
push %rbx
mov %rsi,%rbx
sub $0x28,%rsp
mov %edi,0x1c(%rsp)
shl $0x2,%rdi
mov %edx,0x18(%rsp)
callq 10f0 <malloc@plt>
movslq %r14d,%rdi
mov %rax,0x10(%rsp)
... | func0:
endbr64
push r15
movsxd r15, edx
push r14
push r13
push r12
push rbp
mov ebp, ecx
push rbx
mov rbx, rsi
sub rsp, 28h
mov [rsp+58h+var_48], rdi
movsxd rdi, r8d
mov r13, rdi
shl rdi, 2; size
call _malloc
mov [rsp+58h+dest], rax
movsxd rax, ebp
imul rax, r15
le... | void * func0(unsigned int *a1, long long a2, int a3, int a4, int a5)
{
long long v5; // r15
int v8; // r13d
char *v9; // rax
size_t v10; // r10
void *v11; // r12
unsigned int *v12; // rcx
unsigned int v13; // r9d
int v14; // r8d
unsigned int *v15; // r14
unsigned int v16; // edx
__m128i v17; // xm... | func0:
ENDBR64
PUSH R15
MOVSXD R15,EDX
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,ECX
PUSH RBX
MOV RBX,RSI
SUB RSP,0x28
MOV qword ptr [RSP + 0x10],RDI
MOVSXD RDI,R8D
MOV R13,RDI
SHL RDI,0x2
CALL 0x001010f0
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RAX,EBP
IMUL RAX,R15
LEA RDI,[RAX*0x4]
MOV qword ptr [RSP],RAX
CALL 0x001010... | void * func0(uint *param_1,long param_2,int param_3,uint param_4,uint param_5)
{
uint *puVar1;
int8 *puVar2;
long lVar3;
int auVar4 [16];
ulong uVar5;
ulong uVar6;
void *__dest;
size_t __nmemb;
void *__base;
uint uVar7;
uint uVar8;
long lVar9;
int iVar10;
int iVar11;
uint uVar12;
__d... |
5,128 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a >= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(5, 10) == 10);
assert(func0(-1, -2) == -1);
assert(func0(9, 7) == 9);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 1164 <func0+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <func0+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jl short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 < (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
5,129 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a >= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(5, 10) == 10);
assert(func0(-1, -2) == -1);
assert(func0(9, 7) == 9);
return 0;
}
| O1 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
5,130 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a >= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(5, 10) == 10);
assert(func0(-1, -2) == -1);
assert(func0(9, 7) == 9);
return 0;
}
| O2 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
5,131 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a >= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(5, 10) == 10);
assert(func0(-1, -2) == -1);
assert(func0(9, 7) == 9);
return 0;
}
| O3 | c | func0:
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovge %edi,%eax
retq
nopl 0x0(%rax)
| func0:
endbr64
cmp edi, esi
mov eax, esi
cmovge eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 >= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVGE EAX,EDI
RET | int func0(int param_1,int param_2)
{
if (param_2 <= param_1) {
param_2 = param_1;
}
return param_2;
} |
5,132 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* str1, char* result) {
int j = 0;
for (int i = 0; i < strlen(str1); i++) {
if (!isspace(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char result[100];
func0("python 3.0", result);
assert(strcmp(result, "python3.0") == 0);
func0("item1", result);
assert(strcmp(result, "item1") == 0);
func0("15.10", result);
assert(strcmp(result, "15.10") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1249 <func0+0x80>
callq 10d0 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x14(%rbp),%edx
movslq %edx,%rcx
mov -0x28(%rbp),%rdx
add %r... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_1249
loc_11EE:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_14]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, ... | long long func0(const char *a1, long long a2)
{
int v2; // eax
int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x2000) == 0 )
{
v2 = v4++;
*(_BYTE *)(a2 + v2) = a1[i];
}
}
*(_BYTE *)(v4 ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00101249
LAB_001011ee:
CALL 0x001010d0
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RCX,EDX
MOV RDX,qword ptr ... | long func0(char *param_1,long param_2)
{
ushort **ppuVar1;
size_t sVar2;
int local_20;
int local_1c;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= (ulong)(long)local_1c) break;
ppuVar1 = __ctype_b_loc();
if (((*ppuVar1)[param_1[local_1c]] & 0x2000) =... |
5,133 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* str1, char* result) {
int j = 0;
for (int i = 0; i < strlen(str1); i++) {
if (!isspace(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char result[100];
func0("python 3.0", result);
assert(strcmp(result, "python3.0") == 0);
func0("item1", result);
assert(strcmp(result, "item1") == 0);
func0("15.10", result);
assert(strcmp(result, "15.10") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov %rsi,%r15
mov $0x0,%ebx
mov $0x0,%r12d
mov $0xffffffffffffffff,%r14
mov $0x0,%r13d
jmp 11bf <func0+0x36>
add $0x1,%rbx
mov %r14,%rcx
mov %rbp,%rdi
mov %r13d,%eax
rep... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
mov r13, rsi
mov ebx, 0
mov r12d, 0
jmp short loc_11EE
loc_11EA:
add rbx, 1
loc_11EE:
mov rdi, rbp
call _strlen
cmp rax, rbx
jbe short loc_1225
call ___ctype_b_loc
mov rdx, rax
movzx ... | long long func0(long long a1, long long a2)
{
unsigned long long v2; // rbx
int v3; // r12d
_QWORD *v4; // rdx
char v5; // al
v2 = 0LL;
v3 = 0;
while ( strlen(a1) > v2 )
{
v4 = (_QWORD *)__ctype_b_loc();
v5 = *(_BYTE *)(a1 + v2);
if ( (*(_BYTE *)(*v4 + 2LL * v5 + 1) & 0x20) == 0 )
*(... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
MOV R13,RSI
MOV EBX,0x0
MOV R12D,0x0
JMP 0x001011ee
LAB_001011ea:
ADD RBX,0x1
LAB_001011ee:
MOV RDI,RBP
CALL 0x00101090
CMP RAX,RBX
JBE 0x00101225
CALL 0x001010d0
MOV RDX,RAX
MOVZX EAX,byte ptr [RBP + RBX*0x1]
MOVSX RCX,AL
MOV RDX,qword ptr [RDX... | long func0(char *param_1,long param_2)
{
size_t sVar1;
ushort **ppuVar2;
ulong uVar3;
int iVar4;
uVar3 = 0;
iVar4 = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= uVar3) break;
ppuVar2 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar2 + (long)param_1[uVar3] * 2 + 1) & 0x20) ==... |
5,134 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* str1, char* result) {
int j = 0;
for (int i = 0; i < strlen(str1); i++) {
if (!isspace(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char result[100];
func0("python 3.0", result);
assert(strcmp(result, "python3.0") == 0);
func0("item1", result);
assert(strcmp(result, "item1") == 0);
func0("15.10", result);
assert(strcmp(result, "15.10") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
mov %rsi,%r15
push %r14
xor %r14d,%r14d
push %r13
xor %r13d,%r13d
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x18,%rsp
callq 1080 <strlen@plt>
movl $0x0,0xc(%rsp)
mov %rax,%rbx
jmp 1315 <func0+0x65>
callq 10b0 <__ctype_b_loc@plt>
movsbq 0x0(%rbp,%r14,1... | func0:
endbr64
push r15
mov r15, rsi
push r14
xor r14d, r14d
push r13
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_12FF
loc_12D8:
call ___ctype_b_loc
movsx rcx, byte ptr [rbp+rbx+0]
mov r8, rax
mov rdx, [r8]
test ... | long long func0(long long a1, long long a2)
{
int v2; // r14d
long long v3; // r13
unsigned long long i; // rbx
_QWORD *v5; // rax
long long v6; // rcx
_BYTE *v7; // r12
v2 = 0;
v3 = 0LL;
for ( i = 0LL; ; ++i )
{
v7 = (_BYTE *)(a2 + v3);
if ( strlen(a1) <= i )
break;
v5 = (_QWORD... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
XOR R14D,R14D
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001012ff
LAB_001012d8:
CALL 0x001010b0
MOVSX RCX,byte ptr [RBP + RBX*0x1]
MOV R8,RAX
MOV RDX,qword ptr [R8]
TEST byte ptr [RDX + RCX*0x2 + 0x1],0x20
JNZ 0x001012fb
MOV b... | long func0(char *param_1,long param_2)
{
ushort **ppuVar1;
size_t sVar2;
ulong uVar3;
long lVar4;
int iVar5;
iVar5 = 0;
lVar4 = 0;
uVar3 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= uVar3) break;
ppuVar1 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar1 + (long)param_1... |
5,135 | func0 | #include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
| char* func0(const char* str1, char* result) {
int j = 0;
for (int i = 0; i < strlen(str1); i++) {
if (!isspace(str1[i])) {
result[j++] = str1[i];
}
}
result[j] = '\0';
return result;
}
| int main() {
char result[100];
func0("python 3.0", result);
assert(strcmp(result, "python3.0") == 0);
func0("item1", result);
assert(strcmp(result, "item1") == 0);
func0("15.10", result);
assert(strcmp(result, "15.10") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
mov %rsi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1080 <strlen@plt>
test %rax,%rax
je 1348 <func0+0x98>
mov %rax,%r13
xor %ebx,%ebx
xor %r14d,%r14d
callq 10b0 <__ctype_b_loc@plt>
mov %r12,%rdx
mov %rax,%... | func0:
endbr64
push r15
mov r15, rsi
push r14
xor r14d, r14d
push r13
xor r13d, r13d
push r12
push rbp
mov rbp, rdi
push rbx
xor ebx, ebx
sub rsp, 8
jmp short loc_12FF
loc_12D8:
call ___ctype_b_loc
movsx rcx, byte ptr [rbp+rbx+0]
mov rdx, rax
mov rdx, [rdx]
tes... | long long func0(char *s, long long a2)
{
int v2; // r14d
long long v3; // r13
size_t i; // rbx
const unsigned __int16 **v5; // rax
long long v6; // rcx
_BYTE *v7; // r12
v2 = 0;
v3 = 0LL;
for ( i = 0LL; ; ++i )
{
v7 = (_BYTE *)(a2 + v3);
if ( i >= strlen(s) )
break;
v5 = __ctype_... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
XOR R14D,R14D
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
XOR EBX,EBX
SUB RSP,0x8
JMP 0x001012ff
LAB_001012d8:
CALL 0x001010b0
MOVSX RCX,byte ptr [RBP + RBX*0x1]
MOV RDX,RAX
MOV RDX,qword ptr [RDX]
TEST byte ptr [RDX + RCX*0x2 + 0x1],0x20
JNZ 0x001012fb
MOV... | long func0(char *param_1,long param_2)
{
ushort **ppuVar1;
size_t sVar2;
ulong uVar3;
long lVar4;
int iVar5;
iVar5 = 0;
lVar4 = 0;
uVar3 = 0;
while( true ) {
sVar2 = strlen(param_1);
if (sVar2 <= uVar3) break;
ppuVar1 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar1 + (long)param_1... |
5,136 | func0 |
#include <assert.h>
| int func0(int n) {
if (!(n & (n + 1))) {
return n;
}
int pos = 0, temp = n, count = 0;
while (temp) {
if (!(temp & 1)) {
pos = count;
}
count++;
temp >>= 1;
}
return (n | (1 << pos));
}
| int main() {
assert(func0(10) == 14);
assert(func0(12) == 14);
assert(func0(15) == 15);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
and -0x14(%rbp),%eax
test %eax,%eax
jne 1166 <func0+0x1d>
mov -0x14(%rbp),%eax
jmp 11aa <func0+0x61>
movl $0x0,-0xc(%rbp)
mov -0x14(%rbp),%eax
mov %eax,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
add eax, 1
and eax, [rbp+var_14]
test eax, eax
jnz short loc_1166
mov eax, [rbp+var_14]
jmp short loc_11AA
loc_1166:
mov [rbp+var_C], 0
mov eax, [rbp+var_14]
mov [rbp+var_8], eax
mov [r... | long long func0(unsigned int a1)
{
char v2; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
char v4; // [rsp+10h] [rbp-4h]
if ( (a1 & (a1 + 1)) == 0 )
return a1;
v2 = 0;
v3 = a1;
v4 = 0;
while ( v3 )
{
if ( (v3 & 1) == 0 )
v2 = v4;
++v4;
v3 >>= 1;
}
return a1 | (1 << v2);... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
AND EAX,dword ptr [RBP + -0x14]
TEST EAX,EAX
JNZ 0x00101166
MOV EAX,dword ptr [RBP + -0x14]
JMP 0x001011aa
LAB_00101166:
MOV dword ptr [RBP + -0xc],0x0
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x... | uint func0(uint param_1)
{
byte bVar1;
byte bVar2;
int4 local_10;
if ((param_1 + 1 & param_1) != 0) {
bVar1 = 0;
bVar2 = 0;
for (local_10 = param_1; local_10 != 0; local_10 = (int)local_10 >> 1) {
if ((local_10 & 1) == 0) {
bVar1 = bVar2;
}
bVar2 = bVar2 + 1;
}
... |
5,137 | func0 |
#include <assert.h>
| int func0(int n) {
if (!(n & (n + 1))) {
return n;
}
int pos = 0, temp = n, count = 0;
while (temp) {
if (!(temp & 1)) {
pos = count;
}
count++;
temp >>= 1;
}
return (n | (1 << pos));
}
| int main() {
assert(func0(10) == 14);
assert(func0(12) == 14);
assert(func0(15) == 15);
return 0;
}
| O1 | c | func0:
endbr64
lea 0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
je 1171 <func0+0x28>
mov $0x0,%edx
mov $0x0,%ecx
test $0x1,%al
cmove %edx,%ecx
add $0x1,%edx
sar %eax
jne 1160 <func0+0x17>
mov %edi,%eax
bts %ecx,%eax
retq
| func0:
endbr64
lea edx, [rdi+1]
mov eax, edi
test edx, edi
jz short locret_1171
mov edx, 0
mov ecx, 0
loc_1160:
test al, 1
cmovz ecx, edx
add edx, 1
sar eax, 1
jnz short loc_1160
mov eax, edi
bts eax, ecx
locret_1171:
retn | int func0(int a1)
{
int result; // eax
char v2; // dl
char v3; // cl
result = a1;
if ( (a1 & (a1 + 1)) != 0 )
{
v2 = 0;
v3 = 0;
do
{
if ( (result & 1) == 0 )
v3 = v2;
++v2;
result >>= 1;
}
while ( result );
return a1 | (1 << v3);
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x00101171
MOV EDX,0x0
MOV ECX,0x0
LAB_00101160:
TEST AL,0x1
CMOVZ ECX,EDX
ADD EDX,0x1
SAR EAX,0x1
JNZ 0x00101160
MOV EAX,EDI
BTS EAX,ECX
LAB_00101171:
RET | uint func0(uint param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
if ((param_1 + 1 & param_1) != 0) {
uVar3 = 0;
uVar2 = 0;
uVar1 = param_1;
do {
if ((uVar1 & 1) == 0) {
uVar2 = uVar3;
}
uVar3 = uVar3 + 1;
uVar1 = (int)uVar1 >> 1;
} while (uVar1 != 0);
pa... |
5,138 | func0 |
#include <assert.h>
| int func0(int n) {
if (!(n & (n + 1))) {
return n;
}
int pos = 0, temp = n, count = 0;
while (temp) {
if (!(temp & 1)) {
pos = count;
}
count++;
temp >>= 1;
}
return (n | (1 << pos));
}
| int main() {
assert(func0(10) == 14);
assert(func0(12) == 14);
assert(func0(15) == 15);
return 0;
}
| O2 | c | func0:
endbr64
lea 0x1(%rdi),%eax
test %edi,%eax
je 1210 <func0+0x10>
jmp 11c0 <func0.part.0>
nopl (%rax)
mov %edi,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| func0:
endbr64
lea edx, [rdi+1]
mov eax, edi
test edx, edi
jz short locret_1169
xor ecx, ecx
xor edx, edx
nop dword ptr [rax+00000000h]
loc_1158:
test al, 1
cmovz ecx, edx
add edx, 1
sar eax, 1
jnz short loc_1158
mov eax, edi
bts eax, ecx
locret_1169:
retn | int func0(int a1)
{
int result; // eax
char v2; // cl
char v3; // dl
result = a1;
if ( (a1 & (a1 + 1)) != 0 )
{
v2 = 0;
v3 = 0;
do
{
if ( (result & 1) == 0 )
v2 = v3;
++v3;
result >>= 1;
}
while ( result );
return a1 | (1 << v2);
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x00101169
XOR ECX,ECX
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101158:
TEST AL,0x1
CMOVZ ECX,EDX
ADD EDX,0x1
SAR EAX,0x1
JNZ 0x00101158
MOV EAX,EDI
BTS EAX,ECX
LAB_00101169:
RET | uint func0(uint param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
if ((param_1 + 1 & param_1) != 0) {
uVar2 = 0;
uVar3 = 0;
uVar1 = param_1;
do {
if ((uVar1 & 1) == 0) {
uVar2 = uVar3;
}
uVar3 = uVar3 + 1;
uVar1 = (int)uVar1 >> 1;
} while (uVar1 != 0);
pa... |
5,139 | func0 |
#include <assert.h>
| int func0(int n) {
if (!(n & (n + 1))) {
return n;
}
int pos = 0, temp = n, count = 0;
while (temp) {
if (!(temp & 1)) {
pos = count;
}
count++;
temp >>= 1;
}
return (n | (1 << pos));
}
| int main() {
assert(func0(10) == 14);
assert(func0(12) == 14);
assert(func0(15) == 15);
return 0;
}
| O3 | c | func0:
endbr64
lea 0x1(%rdi),%edx
mov %edi,%eax
test %edi,%edx
je 1169 <func0+0x29>
xor %ecx,%ecx
xor %edx,%edx
nopl 0x0(%rax)
test $0x1,%al
cmove %edx,%ecx
add $0x1,%edx
sar %eax
jne 1158 <func0+0x18>
mov %edi,%eax
bts %ecx,%eax
retq
nopw 0x0(%rax,%rax,1)
| func0:
endbr64
lea edx, [rdi+1]
mov eax, edi
test edx, edi
jz short locret_1169
xor ecx, ecx
xor edx, edx
nop dword ptr [rax+00000000h]
loc_1158:
test al, 1
cmovz ecx, edx
add edx, 1
sar eax, 1
jnz short loc_1158
mov eax, edi
bts eax, ecx
locret_1169:
retn | int func0(int a1)
{
int result; // eax
char v2; // cl
char v3; // dl
result = a1;
if ( (a1 & (a1 + 1)) != 0 )
{
v2 = 0;
v3 = 0;
do
{
if ( (result & 1) == 0 )
v2 = v3;
++v3;
result >>= 1;
}
while ( result );
return a1 | (1 << v2);
}
return result;
} | func0:
ENDBR64
LEA EDX,[RDI + 0x1]
MOV EAX,EDI
TEST EDX,EDI
JZ 0x00101169
XOR ECX,ECX
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_00101158:
TEST AL,0x1
CMOVZ ECX,EDX
ADD EDX,0x1
SAR EAX,0x1
JNZ 0x00101158
MOV EAX,EDI
BTS EAX,ECX
LAB_00101169:
RET | uint func0(uint param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
if ((param_1 + 1 & param_1) != 0) {
uVar2 = 0;
uVar3 = 0;
uVar1 = param_1;
do {
if ((uVar1 & 1) == 0) {
uVar2 = uVar3;
}
uVar3 = uVar3 + 1;
uVar1 = (int)uVar1 >> 1;
} while (uVar1 != 0);
pa... |
5,140 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double volume = (1.0/3) * M_PI * r * r * h;
return volume;
}
| int main() {
assert(func0(5, 12) == 314.15926535897927);
assert(func0(10, 15) == 1570.7963267948965);
assert(func0(19, 17) == 6426.651371693521);
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 1.047197551196598 * 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;
} |
5,141 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double volume = (1.0/3) * M_PI * r * r * h;
return volume;
}
| int main() {
assert(func0(5, 12) == 314.15926535897927);
assert(func0(10, 15) == 1570.7963267948965);
assert(func0(19, 17) == 6426.651371693521);
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 * 1.047197551196598 * 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;
} |
5,142 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double volume = (1.0/3) * M_PI * r * r * h;
return volume;
}
| int main() {
assert(func0(5, 12) == 314.15926535897927);
assert(func0(10, 15) == 1570.7963267948965);
assert(func0(19, 17) == 6426.651371693521);
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 1.047197551196598 * 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,143 | func0 |
#include <math.h>
#include <assert.h>
| double func0(double r, double h) {
double volume = (1.0/3) * M_PI * r * r * h;
return volume;
}
| int main() {
assert(func0(5, 12) == 314.15926535897927);
assert(func0(10, 15) == 1570.7963267948965);
assert(func0(19, 17) == 6426.651371693521);
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 1.047197551196598 * 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,144 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, size_t size) {
for (int i = 0; i < size; i++) {
if (list1[i] >= 0) {
return list1[i];
}
}
return -1; // Return -1 if no positive number is found
}
| int main() {
int list1[] = {-1, -2, 1, 2};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 1);
int list2[] = {3, 4, -5};
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 3);
int list3[] = {-2, -3, 1};
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 1);
return... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %rsi,-0x20(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11b8 <func0+0x4f>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
js 11b4 <func0+0x4b>
mov -0x4(%rbp),%eax
cl... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_4], 0
jmp short loc_11B8
loc_1182:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
test eax, eax
js short loc_11B4
mov eax... | long long func0(long long a1, unsigned long long a2)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= 0 )
return *(unsigned int *)(4LL * i + a1);
}
return 0xFFFFFFFFLL;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011b8
LAB_00101182:
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]
TEST EAX,EAX
JS 0x001011b4
MOV EAX,dwo... | int4 func0(long param_1,ulong param_2)
{
int local_c;
local_c = 0;
while( true ) {
if (param_2 <= (ulong)(long)local_c) {
return 0xffffffff;
}
if (-1 < *(int *)(param_1 + (long)local_c * 4)) break;
local_c = local_c + 1;
}
return *(int4 *)(param_1 + (long)local_c * 4);
} |
5,145 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, size_t size) {
for (int i = 0; i < size; i++) {
if (list1[i] >= 0) {
return list1[i];
}
}
return -1; // Return -1 if no positive number is found
}
| int main() {
int list1[] = {-1, -2, 1, 2};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 1);
int list2[] = {3, 4, -5};
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 3);
int list3[] = {-2, -3, 1};
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 1);
return... | O1 | c | func0:
endbr64
test %rsi,%rsi
je 118f <func0+0x26>
mov $0x0,%eax
mov (%rdi,%rax,4),%edx
test %edx,%edx
jns 118c <func0+0x23>
add $0x1,%rax
cmp %rax,%rsi
jne 1177 <func0+0xe>
mov $0xffffffff,%edx
mov %edx,%eax
retq
mov $0xffffffff,%edx
jmp 118c <func0+0x23>
| func0:
endbr64
test rsi, rsi
jz short loc_118F
mov eax, 0
loc_1177:
mov edx, [rdi+rax*4]
test edx, edx
jns short loc_118C
add rax, 1
cmp rsi, rax
jnz short loc_1177
mov edx, 0FFFFFFFFh
loc_118C:
mov eax, edx
retn
loc_118F:
mov edx, 0FFFFFFFFh
jmp short loc_118C | long long func0(long long a1, long long a2)
{
long long v2; // rax
int v3; // edx
if ( a2 )
{
v2 = 0LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 >= 0 )
break;
if ( a2 == ++v2 )
return (unsigned int)-1;
}
}
else
{
return (unsigned int)-1;
... | func0:
ENDBR64
TEST RSI,RSI
JZ 0x0010118f
MOV EAX,0x0
LAB_00101177:
MOV EDX,dword ptr [RDI + RAX*0x4]
TEST EDX,EDX
JNS 0x0010118c
ADD RAX,0x1
CMP RSI,RAX
JNZ 0x00101177
MOV EDX,0xffffffff
LAB_0010118c:
MOV EAX,EDX
RET
LAB_0010118f:
MOV EDX,0xffffffff
JMP 0x0010118c | int func0(long param_1,long param_2)
{
int iVar1;
long lVar2;
if (param_2 != 0) {
lVar2 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
if (-1 < iVar1) {
return iVar1;
}
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
return -1;
} |
5,146 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, size_t size) {
for (int i = 0; i < size; i++) {
if (list1[i] >= 0) {
return list1[i];
}
}
return -1; // Return -1 if no positive number is found
}
| int main() {
int list1[] = {-1, -2, 1, 2};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 1);
int list2[] = {3, 4, -5};
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 3);
int list3[] = {-2, -3, 1};
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 1);
return... | O2 | c | func0:
endbr64
test %rsi,%rsi
je 1170 <func0+0x30>
xor %eax,%eax
jmp 1159 <func0+0x19>
nopl (%rax)
add $0x1,%rax
cmp %rax,%rsi
je 1170 <func0+0x30>
mov (%rdi,%rax,4),%r8d
test %r8d,%r8d
js 1150 <func0+0x10>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov ... | func0:
endbr64
test rsi, rsi
jz short loc_1170
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rsi, rax
jz short loc_1170
loc_1159:
mov r8d, [rdi+rax*4]
test r8d, r8d
js short loc_1150
mov eax, r8d
retn
loc_1170:
mov r8d, 0FFFFFFFFh
mov eax, r8d
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
int v3; // r8d
if ( !a2 )
return 0xFFFFFFFFLL;
v2 = 0LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 >= 0 )
break;
if ( a2 == ++v2 )
return 0xFFFFFFFFLL;
}
return (unsigned int)v3;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x00101170
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101170
LAB_00101159:
MOV R8D,dword ptr [RDI + RAX*0x4]
TEST R8D,R8D
JS 0x00101150
MOV EAX,R8D
RET
LAB_00101170:
MOV R8D,0xffffffff
MOV EAX,R8D
RET | int func0(long param_1,long param_2)
{
int iVar1;
long lVar2;
if (param_2 != 0) {
lVar2 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
if (-1 < iVar1) {
return iVar1;
}
lVar2 = lVar2 + 1;
} while (param_2 != lVar2);
}
return -1;
} |
5,147 | func0 |
#include <assert.h>
#include <stddef.h>
| int func0(int* list1, size_t size) {
for (int i = 0; i < size; i++) {
if (list1[i] >= 0) {
return list1[i];
}
}
return -1; // Return -1 if no positive number is found
}
| int main() {
int list1[] = {-1, -2, 1, 2};
assert(func0(list1, sizeof(list1)/sizeof(list1[0])) == 1);
int list2[] = {3, 4, -5};
assert(func0(list2, sizeof(list2)/sizeof(list2[0])) == 3);
int list3[] = {-2, -3, 1};
assert(func0(list3, sizeof(list3)/sizeof(list3[0])) == 1);
return... | O3 | c | func0:
endbr64
test %rsi,%rsi
je 1170 <func0+0x30>
xor %eax,%eax
jmp 1159 <func0+0x19>
nopl (%rax)
add $0x1,%rax
cmp %rsi,%rax
je 1170 <func0+0x30>
mov (%rdi,%rax,4),%r8d
test %r8d,%r8d
js 1150 <func0+0x10>
mov %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0xffffffff,%r8d
mov ... | func0:
endbr64
test rsi, rsi
jz short loc_1168
xor eax, eax
jmp short loc_1159
loc_1150:
add rax, 1
cmp rax, rsi
jz short loc_1168
loc_1159:
mov edx, [rdi+rax*4]
test edx, edx
js short loc_1150
mov eax, edx
retn
loc_1168:
mov edx, 0FFFFFFFFh
mov eax, edx
retn | long long func0(long long a1, long long a2)
{
long long v2; // rax
int v3; // edx
if ( !a2 )
return 0xFFFFFFFFLL;
v2 = 0LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 >= 0 )
break;
if ( ++v2 == a2 )
return 0xFFFFFFFFLL;
}
return (unsigned int)v3;
} | func0:
ENDBR64
TEST RSI,RSI
JZ 0x00101168
XOR EAX,EAX
JMP 0x00101159
LAB_00101150:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x00101168
LAB_00101159:
MOV EDX,dword ptr [RDI + RAX*0x4]
TEST EDX,EDX
JS 0x00101150
MOV EAX,EDX
RET
LAB_00101168:
MOV EDX,0xffffffff
MOV EAX,EDX
RET | int func0(long param_1,long param_2)
{
int iVar1;
long lVar2;
if (param_2 != 0) {
lVar2 = 0;
do {
iVar1 = *(int *)(param_1 + lVar2 * 4);
if (-1 < iVar1) {
return iVar1;
}
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
}
return -1;
} |
5,148 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int grid[2][100], int n) {
int incl = grid[0][0] > grid[1][0] ? grid[0][0] : grid[1][0];
int excl = 0;
for (int i = 1; i < n; i++) {
int excl_new = excl > incl ? excl : incl;
int max_value = grid[0][i] > grid[1][i] ? grid[0][i] : grid[1][i];
incl = excl + max_value;
... | int main() {
int grid1[2][100] = {{1, 4, 5}, {2, 0, 0}};
assert(func0(grid1, 3) == 7);
int grid2[2][100] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
assert(func0(grid2, 5) == 24);
int grid3[2][100] = {{7, 9, 11, 15, 19}, {21, 25, 28, 31, 32}};
assert(func0(grid3, 5) == 81);
return 0;... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x28(%rbp),%rax
add $0x190,%rax
mov (%rax),%edx
mov -0x28(%rbp),%rax
mov (%rax),%eax
cmp %eax,%edx
cmovge %edx,%eax
mov %eax,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11ec <func0... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
add rax, 190h
mov edx, [rax]
mov rax, [rbp+var_28]
mov eax, [rax]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_14], eax
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp s... | long long func0(int *a1, int a2)
{
int v2; // eax
int v3; // eax
int v4; // eax
long long result; // rax
signed int v6; // [rsp+18h] [rbp-14h]
signed int v7; // [rsp+1Ch] [rbp-10h]
int i; // [rsp+20h] [rbp-Ch]
int v9; // [rsp+24h] [rbp-8h]
v2 = *a1;
if ( a1[100] >= *a1 )
v2 = a1[100];
v6 = v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x190
MOV EDX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x10],0x0
MOV... | int func0(int *param_1,int param_2)
{
int iVar1;
int local_1c;
int local_18;
int local_14;
local_1c = *param_1;
if (*param_1 <= param_1[100]) {
local_1c = param_1[100];
}
local_18 = 0;
for (local_14 = 1; local_14 < param_2; local_14 = local_14 + 1) {
iVar1 = local_18;
if (local_18 <= l... |
5,149 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int grid[2][100], int n) {
int incl = grid[0][0] > grid[1][0] ? grid[0][0] : grid[1][0];
int excl = 0;
for (int i = 1; i < n; i++) {
int excl_new = excl > incl ? excl : incl;
int max_value = grid[0][i] > grid[1][i] ? grid[0][i] : grid[1][i];
incl = excl + max_value;
... | int main() {
int grid1[2][100] = {{1, 4, 5}, {2, 0, 0}};
assert(func0(grid1, 3) == 7);
int grid2[2][100] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
assert(func0(grid2, 5) == 24);
int grid3[2][100] = {{7, 9, 11, 15, 19}, {21, 25, 28, 31, 32}};
assert(func0(grid3, 5) == 81);
return 0;... | O1 | c | func0:
endbr64
mov (%rdi),%eax
cmp %eax,0x190(%rdi)
cmovge 0x190(%rdi),%eax
cmp $0x1,%esi
jle 11b9 <func0+0x50>
lea 0x4(%rdi),%rdx
lea -0x2(%rsi),%ecx
lea 0x8(%rdi,%rcx,4),%rdi
mov $0x0,%ecx
mov %ecx,%esi
cmp %eax,%ecx
cmovl %eax,%ecx
mov (%rdx),%eax
cmp %eax,0x190(%rdx)
cmovge 0x19... | func0:
endbr64
mov eax, [rdi+190h]
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp esi, 1
jle short loc_11B5
lea rdx, [rdi+4]
lea ecx, [rsi-2]
lea r8, [rdi+rcx*4+8]
mov ecx, 0
loc_1190:
mov edi, ecx
cmp ecx, eax
cmovl ecx, eax
mov eax, [rdx+190h]
mov esi, [rdx]
cmp... | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
long long v4; // r8
int v5; // ecx
int v6; // edi
int v7; // eax
result = (unsigned int)a1[100];
if ( (int)result < *a1 )
result = (unsigned int)*a1;
if ( a2 <= 1 )
{
v5 = 0;
}
else
{
v3 = a1 + 1;
v4 ... | ||
5,150 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int grid[2][100], int n) {
int incl = grid[0][0] > grid[1][0] ? grid[0][0] : grid[1][0];
int excl = 0;
for (int i = 1; i < n; i++) {
int excl_new = excl > incl ? excl : incl;
int max_value = grid[0][i] > grid[1][i] ? grid[0][i] : grid[1][i];
incl = excl + max_value;
... | int main() {
int grid1[2][100] = {{1, 4, 5}, {2, 0, 0}};
assert(func0(grid1, 3) == 7);
int grid2[2][100] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
assert(func0(grid2, 5) == 24);
int grid3[2][100] = {{7, 9, 11, 15, 19}, {21, 25, 28, 31, 32}};
assert(func0(grid3, 5) == 81);
return 0;... | O2 | c | func0:
endbr64
mov (%rdi),%eax
cmp %eax,0x190(%rdi)
cmovge 0x190(%rdi),%eax
cmp $0x1,%esi
jle 1380 <func0+0x60>
lea -0x2(%rsi),%ecx
lea 0x4(%rdi),%rdx
lea 0x8(%rdi,%rcx,4),%rdi
xor %ecx,%ecx
nopw %cs:0x0(%rax,%rax,1)
cmp %eax,%ecx
mov %ecx,%esi
cmovl %eax,%ecx
mov (%rdx),%eax
cmp ... | func0:
endbr64
mov eax, [rdi+190h]
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp esi, 1
jle short loc_13C0
lea ecx, [rsi-2]
lea rdx, [rdi+4]
lea r8, [rdi+rcx*4+8]
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1398:
cmp ecx, eax
mov esi, [rdx]
mov edi, ecx
cmovl ecx, e... | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
long long v4; // r8
int v5; // ecx
int v6; // edi
int v7; // eax
result = (unsigned int)a1[100];
if ( (int)result < *a1 )
result = (unsigned int)*a1;
if ( a2 <= 1 )
{
if ( (int)result < 0 )
return 0LL;
}
... | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x190]
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ESI,0x1
JLE 0x001013c0
LEA ECX,[RSI + -0x2]
LEA RDX,[RDI + 0x4]
LEA R8,[RDI + RCX*0x4 + 0x8]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101398:
CMP ECX,EAX
MOV ESI,dword ptr [RDX]
MOV EDI,ECX
CMOVL ECX,EAX
MOV EAX,dword ptr ... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
iVar1 = param_1[100];
if (param_1[100] < *param_1) {
iVar1 = *param_1;
}
if (1 < param_2) {
piVar4 = param_1 + 1;
iVar2 = 0;
do {
iVar3 = iVar2;
if (iVar2 < iVar1) {
iVar3 = iVar1;... |
5,151 | func0 |
#include <stdio.h>
#include <assert.h>
| int func0(int grid[2][100], int n) {
int incl = grid[0][0] > grid[1][0] ? grid[0][0] : grid[1][0];
int excl = 0;
for (int i = 1; i < n; i++) {
int excl_new = excl > incl ? excl : incl;
int max_value = grid[0][i] > grid[1][i] ? grid[0][i] : grid[1][i];
incl = excl + max_value;
... | int main() {
int grid1[2][100] = {{1, 4, 5}, {2, 0, 0}};
assert(func0(grid1, 3) == 7);
int grid2[2][100] = {{1, 2, 3, 4, 5}, {6, 7, 8, 9, 10}};
assert(func0(grid2, 5) == 24);
int grid3[2][100] = {{7, 9, 11, 15, 19}, {21, 25, 28, 31, 32}};
assert(func0(grid3, 5) == 81);
return 0;... | O3 | c | func0:
endbr64
mov (%rdi),%eax
cmp %eax,0x190(%rdi)
cmovge 0x190(%rdi),%eax
cmp $0x1,%esi
jle 1320 <func0+0x60>
lea -0x2(%rsi),%ecx
lea 0x4(%rdi),%rdx
lea 0x8(%rdi,%rcx,4),%rdi
xor %ecx,%ecx
nopw %cs:0x0(%rax,%rax,1)
cmp %eax,%ecx
mov %ecx,%esi
cmovl %eax,%ecx
mov (%rdx),%eax
cmp ... | func0:
endbr64
mov eax, [rdi+190h]
mov edx, [rdi]
cmp eax, edx
cmovl eax, edx
cmp esi, 1
jle short loc_1190
lea ecx, [rsi-2]
lea rdx, [rdi+4]
lea r8, [rdi+rcx*4+8]
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1168:
cmp ecx, eax
mov esi, [rdx]
mov edi, ecx
cmovl ecx, e... | long long func0(int *a1, int a2)
{
long long result; // rax
int *v3; // rdx
long long v4; // r8
int v5; // ecx
int v6; // edi
int v7; // eax
result = (unsigned int)a1[100];
if ( (int)result < *a1 )
result = (unsigned int)*a1;
if ( a2 <= 1 )
{
if ( (int)result < 0 )
return 0LL;
}
... | func0:
ENDBR64
MOV EAX,dword ptr [RDI + 0x190]
MOV EDX,dword ptr [RDI]
CMP EAX,EDX
CMOVL EAX,EDX
CMP ESI,0x1
JLE 0x00101190
LEA ECX,[RSI + -0x2]
LEA RDX,[RDI + 0x4]
LEA R8,[RDI + RCX*0x4 + 0x8]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101168:
CMP ECX,EAX
MOV ESI,dword ptr [RDX]
MOV EDI,ECX
CMOVL ECX,EAX
MOV EAX,dword ptr ... | int func0(int *param_1,int param_2)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
iVar1 = param_1[100];
if (param_1[100] < *param_1) {
iVar1 = *param_1;
}
if (1 < param_2) {
piVar4 = param_1 + 1;
iVar2 = 0;
do {
iVar3 = iVar2;
if (iVar2 < iVar1) {
iVar3 = iVar1;... |
5,152 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str) {
int n = strlen(str);
int i = 0;
int currlen = 0;
int maxlen = 0;
int st = -1;
static char result[100];
while (i < n) {
if (str[i] == ' ') {
if (currlen % 2 == 0) {
if (maxlen < currlen) {
maxl... | int main() {
assert(strcmp(func0("python language"), "language") == 0);
assert(strcmp(func0("maximum even length"), "length") == 0);
assert(strcmp(func0("eve"), "-1") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1090 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
jmp 122c <func0+0x83>
mov -0x14(%rbp),... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_14], 0
mov [rbp+var_10], 0
mov [rbp+var_C], 0
mov [rbp+var_8], 0FFFFFFFFh
jmp short loc_122C
loc_11E6:
mov eax, [rbp+va... | char * func0(const char *a1)
{
int v2; // [rsp+1Ch] [rbp-14h]
int v3; // [rsp+20h] [rbp-10h]
int v4; // [rsp+24h] [rbp-Ch]
int v5; // [rsp+28h] [rbp-8h]
int v6; // [rsp+2Ch] [rbp-4h]
v6 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = 0;
v5 = -1;
while ( v2 < v6 )
{
if ( a1[v2] == 32 )
{
if ( (... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101090
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x0010122c
... | int1 * func0(char *param_1)
{
size_t sVar1;
int1 *puVar2;
int local_1c;
uint local_18;
uint local_14;
int local_10;
sVar1 = strlen(param_1);
local_18 = 0;
local_14 = 0;
local_10 = -1;
for (local_1c = 0; local_1c < (int)sVar1; local_1c = local_1c + 1) {
if (param_1[local_1c] == ' ') {
... |
5,153 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str) {
int n = strlen(str);
int i = 0;
int currlen = 0;
int maxlen = 0;
int st = -1;
static char result[100];
while (i < n) {
if (str[i] == ' ') {
if (currlen % 2 == 0) {
if (maxlen < currlen) {
maxl... | int main() {
assert(strcmp(func0("python language"), "language") == 0);
assert(strcmp(func0("maximum even length"), "length") == 0);
assert(strcmp(func0("eve"), "-1") == 0);
return 0;
}
| O1 | c | func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rdi
lea 0xe78(%rip),%rax
test %edi,%edi
jle 1234 <func0+0xcb>
lea -0x1(%rdi),%r8d
mov $0x0,%eax
mov $0xffffffff,%r10d
mov $0x0,%r9d
mov $0x0,%edx
jmp 11ce <... | func0:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
call _strlen
mov r9, rax
lea rax, unk_2004
test r9d, r9d
jle loc_125D
lea edi, [r9-1]
mov edx, 0
mov r10d, 0FFFFFFFFh
mov r8d, 0
mov ecx, 0
jmp short loc_1205
loc_11EA:
test cl, 1
jnz short loc_11F4
c... | void * func0(long long a1)
{
int v1; // r9d
void *result; // rax
long long v3; // rdx
int v4; // r10d
int v5; // r8d
int v6; // ecx
long long v7; // rbp
v1 = strlen();
result = &unk_2004;
if ( v1 > 0 )
{
v3 = 0LL;
v4 = -1;
v5 = 0;
v6 = 0;
while ( 1 )
{
if ( *(_BYTE *... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
CALL 0x00101080
MOV R9,RAX
LEA RAX,[0x102004]
TEST R9D,R9D
JLE 0x0010125d
LEA EDI,[R9 + -0x1]
MOV EDX,0x0
MOV R10D,0xffffffff
MOV R8D,0x0
MOV ECX,0x0
JMP 0x00101205
LAB_001011ea:
TEST CL,0x1
JNZ 0x001011f4
CMP ECX,R8D
JG 0x00101212
LAB_001011f4:
MOV ECX,0x0
LAB_0... | int * func0(char *param_1)
{
size_t sVar1;
int *puVar2;
uint uVar3;
ulong uVar4;
uint uVar5;
int iVar6;
int iVar7;
bool bVar8;
sVar1 = strlen(param_1);
puVar2 = &DAT_00102004;
iVar6 = (int)sVar1;
if (0 < iVar6) {
iVar7 = -1;
uVar5 = 0;
uVar3 = 0;
uVar4 = 0;
do {
if ... |
5,154 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str) {
int n = strlen(str);
int i = 0;
int currlen = 0;
int maxlen = 0;
int st = -1;
static char result[100];
while (i < n) {
if (str[i] == ' ') {
if (currlen % 2 == 0) {
if (maxlen < currlen) {
maxl... | int main() {
assert(strcmp(func0("python language"), "language") == 0);
assert(strcmp(func0("maximum even length"), "length") == 0);
assert(strcmp(func0("eve"), "-1") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%r10
lea 0xd78(%rip),%rax
test %r10d,%r10d
jle 1310 <func0+0xa0>
lea -0x1(%r10),%edi
xor %edx,%edx
mov $0xffffffff,%esi
xor %r9d,%r9d
xor %ecx,%ecx
jmp 12b7 <func0+0x47>
nopl 0x0(%ra... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov r10, rax
lea rax, unk_2004
test r10d, r10d
jle short loc_131D
lea esi, [r10-1]
xor edx, edx
mov r11d, 0FFFFFFFFh
xor r9d, r9d
xor ecx, ecx
jmp short loc_12C7
loc_12B8:
add ecx, 1
loc_12B... | _BYTE * func0(long long a1)
{
int v2; // r10d
_BYTE *result; // rax
long long v4; // rsi
long long v5; // rdx
int v6; // r11d
int v7; // r9d
int v8; // ecx
long long v9; // r8
long long v10; // rbp
int v11; // edi
v2 = strlen();
result = &unk_2004;
if ( v2 <= 0 )
return result;
v4 = (un... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101080
MOV R10,RAX
LEA RAX,[0x102004]
TEST R10D,R10D
JLE 0x0010131d
LEA ESI,[R10 + -0x1]
XOR EDX,EDX
MOV R11D,0xffffffff
XOR R9D,R9D
XOR ECX,ECX
JMP 0x001012c7
LAB_001012b8:
ADD ECX,0x1
LAB_001012bb:
LEA R8,[RDX + 0x1]
CMP RSI,RDX
JZ 0x001012e4
LAB_00101... | int * func0(char *param_1)
{
uint uVar1;
size_t sVar2;
int *puVar3;
uint uVar4;
ulong uVar5;
uint uVar6;
int iVar7;
int iVar8;
sVar2 = strlen(param_1);
puVar3 = &DAT_00102004;
iVar7 = (int)sVar2;
if (0 < iVar7) {
uVar5 = 0;
iVar8 = -1;
uVar6 = 0;
uVar4 = 0;
while( true ) ... |
5,155 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char* str) {
int n = strlen(str);
int i = 0;
int currlen = 0;
int maxlen = 0;
int st = -1;
static char result[100];
while (i < n) {
if (str[i] == ' ') {
if (currlen % 2 == 0) {
if (maxlen < currlen) {
maxl... | int main() {
assert(strcmp(func0("python language"), "language") == 0);
assert(strcmp(func0("maximum even length"), "length") == 0);
assert(strcmp(func0("eve"), "-1") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%r10
lea 0xd78(%rip),%rax
test %r10d,%r10d
jle 1310 <func0+0xa0>
lea -0x1(%r10),%edi
xor %edx,%edx
mov $0xffffffff,%esi
xor %r9d,%r9d
xor %ecx,%ecx
jmp 12b7 <func0+0x47>
nopl 0x0(%ra... | func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov r9, rax
lea rax, unk_2004
test r9d, r9d
jle short loc_1319
lea esi, [r9-1]
xor edx, edx
mov r10d, 0FFFFFFFFh
xor edi, edi
xor ecx, ecx
jmp short loc_12C7
loc_12B8:
add ecx, 1
loc_12BB:
l... | _BYTE * func0(const char *a1)
{
int v2; // r9d
_BYTE *result; // rax
long long v4; // rsi
long long v5; // rdx
int v6; // r10d
int v7; // edi
int v8; // ecx
long long v9; // r8
v2 = strlen(a1);
result = &unk_2004;
if ( v2 <= 0 )
return result;
v4 = (unsigned int)(v2 - 1);
v5 = 0LL;
v6 =... | func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x00101080
MOV R9,RAX
LEA RAX,[0x102004]
TEST R9D,R9D
JLE 0x00101319
LEA ESI,[R9 + -0x1]
XOR EDX,EDX
MOV R10D,0xffffffff
XOR EDI,EDI
XOR ECX,ECX
JMP 0x001012c7
LAB_001012b8:
ADD ECX,0x1
LAB_001012bb:
LEA R8,[RDX + 0x1]
CMP RDX,RSI
JZ 0x001012e1
LAB_001012c4:... | int * func0(char *param_1)
{
uint uVar1;
size_t sVar2;
int *puVar3;
uint uVar4;
ulong uVar5;
uint uVar6;
int iVar7;
int iVar8;
sVar2 = strlen(param_1);
puVar3 = &DAT_00102004;
iVar7 = (int)sVar2;
if (0 < iVar7) {
uVar5 = 0;
iVar8 = -1;
uVar6 = 0;
uVar4 = 0;
while( true ) ... |
5,156 | func0 |
#include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0;
int right = n - 1;
int result = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (x == A[mid]) {
result = mid;
left = mid + 1;
} else if (x < A[mid]) {
right = mid - 1;
... | int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 8, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 2, 1, 5, 6, 6, 6, 9, 9, 9};
assert(func0(arr1, 10, 5) == 3);
assert(func0(arr2, 10, 9) == 9);
assert(func0(arr3, 10, 6) == 6);
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,-0x10(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
mov %eax,-0xc(%rbp)
movl $0xffffffff,-0x8(%rbp)
jmp 1203 <func0+0x9a>
mov -0x10(%rbp),%edx
mov -0xc(%rbp),%eax
add %edx,%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_10], 0
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_C], eax
mov [rbp+var_8], 0FFFFFFFFh
jmp short loc_1203
loc_1194:
mov edx, [rbp+var_10]
mov eax, [rbp... | long long func0(long long a1, int a2, int a3)
{
int v4; // [rsp+10h] [rbp-10h]
int v5; // [rsp+14h] [rbp-Ch]
unsigned int v6; // [rsp+18h] [rbp-8h]
int v7; // [rsp+1Ch] [rbp-4h]
v4 = 0;
v5 = a2 - 1;
v6 = -1;
while ( v4 <= v5 )
{
v7 = (v4 + v5) / 2;
if ( a3 == *(_DWORD *)(4LL * v7 + a1) )
... | 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 + -0x10],0x0
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
MOV dword ptr [RBP + -0x8],0xffffffff
JMP 0x00101203
LAB_00101194:
MOV EDX,dword ... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
local_14 = param_2 + -1;
local_10 = -1;
while (local_18 <= local_14) {
iVar1 = (local_14 + local_18) / 2;
if (param_3 == *(int *)(param_1 + (long)iVar1 * 4)) {
local_... |
5,157 | func0 |
#include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0;
int right = n - 1;
int result = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (x == A[mid]) {
result = mid;
left = mid + 1;
} else if (x < A[mid]) {
right = mid - 1;
... | int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 8, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 2, 1, 5, 6, 6, 6, 9, 9, 9};
assert(func0(arr1, 10, 5) == 3);
assert(func0(arr2, 10, 9) == 9);
assert(func0(arr3, 10, 6) == 6);
return 0;
}
| O1 | c | func0:
endbr64
sub $0x1,%esi
js 11b0 <func0+0x47>
mov $0xffffffff,%r9d
mov $0x0,%r8d
jmp 118c <func0+0x23>
lea 0x1(%rax),%r8d
mov %eax,%r9d
cmp %esi,%r8d
jg 11b6 <func0+0x4d>
lea (%r8,%rsi,1),%ecx
mov %ecx,%eax
shr $0x1f,%eax
add %ecx,%eax
sar %eax
movslq %eax,%rcx
mov (%r... | func0:
endbr64
sub esi, 1
js short loc_11B0
mov r9d, 0FFFFFFFFh
mov r8d, 0
jmp short loc_118C
loc_1180:
lea r8d, [rax+1]
mov r9d, eax
loc_1187:
cmp r8d, esi
jg short loc_11B6
loc_118C:
lea ecx, [r8+rsi]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
movsxd r... | long long func0(long long a1, int a2, int a3)
{
int v3; // esi
unsigned int v4; // r9d
int v5; // r8d
int v6; // eax
int v7; // ecx
v3 = a2 - 1;
if ( v3 < 0 )
{
return (unsigned int)-1;
}
else
{
v4 = -1;
v5 = 0;
do
{
v6 = (v5 + v3) / 2;
v7 = *(_DWORD *)(a1 + 4LL *... | func0:
ENDBR64
SUB ESI,0x1
JS 0x001011b0
MOV R9D,0xffffffff
MOV R8D,0x0
JMP 0x0010118c
LAB_00101180:
LEA R8D,[RAX + 0x1]
MOV R9D,EAX
LAB_00101187:
CMP R8D,ESI
JG 0x001011b6
LAB_0010118c:
LEA ECX,[R8 + RSI*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
MOV ECX,dword ptr [RDI + RCX*0x4]
CMP ECX,EDX
... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
param_2 = param_2 + -1;
if (param_2 < 0) {
iVar2 = -1;
}
else {
iVar3 = 0;
iVar4 = -1;
do {
iVar2 = (iVar3 + param_2) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (... |
5,158 | func0 |
#include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0;
int right = n - 1;
int result = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (x == A[mid]) {
result = mid;
left = mid + 1;
} else if (x < A[mid]) {
right = mid - 1;
... | int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 8, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 2, 1, 5, 6, 6, 6, 9, 9, 9};
assert(func0(arr1, 10, 5) == 3);
assert(func0(arr2, 10, 9) == 9);
assert(func0(arr3, 10, 6) == 6);
return 0;
}
| O2 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%esi
js 13d9 <func0+0x39>
xor %ecx,%ecx
jmp 13c1 <func0+0x21>
nopl 0x0(%rax,%rax,1)
jle 13e0 <func0+0x40>
lea -0x1(%rax),%esi
cmp %ecx,%esi
jl 13d9 <func0+0x39>
lea (%rsi,%rcx,1),%eax
sar %eax
movslq %eax,%r8
cmp %edx,(%rdi,%r8,4)
jne ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub esi, 1
js short loc_1339
xor ecx, ecx
jmp short loc_1321
loc_1318:
jle short loc_1340
lea esi, [rax-1]
loc_131D:
cmp esi, ecx
jl short loc_1339
loc_1321:
lea eax, [rsi+rcx]
sar eax, 1
movsxd r8, eax
cmp [rdi+r8*4], edx
jnz sho... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // esi
int v5; // ecx
int v6; // eax
v3 = -1;
v4 = a2 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) >> 1;
if ( *(_DWORD *)(a1 + 4LL * v6) != a3 )
break;
... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB ESI,0x1
JS 0x00101339
XOR ECX,ECX
JMP 0x00101321
LAB_00101318:
JLE 0x00101340
LEA ESI,[RAX + -0x1]
LAB_0010131d:
CMP ESI,ECX
JL 0x00101339
LAB_00101321:
LEA EAX,[RSI + RCX*0x1]
SAR EAX,0x1
MOVSXD R8,EAX
CMP dword ptr [RDI + R8*0x4],EDX
JNZ 0x00101318
LEA ECX,[RAX + 0x1]
MOV R9D,EAX... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar3 = 0;
do {
while( true ) {
iVar2 = param_2 + iVar3 >> 1;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (iVa... |
5,159 | func0 |
#include <assert.h>
| int func0(int A[], int n, int x) {
int left = 0;
int right = n - 1;
int result = -1;
while (left <= right) {
int mid = (left + right) / 2;
if (x == A[mid]) {
result = mid;
left = mid + 1;
} else if (x < A[mid]) {
right = mid - 1;
... | int main() {
int arr1[] = {2, 5, 5, 5, 6, 6, 8, 9, 9, 9};
int arr2[] = {2, 3, 5, 8, 6, 6, 8, 9, 9, 9};
int arr3[] = {2, 2, 1, 5, 6, 6, 6, 9, 9, 9};
assert(func0(arr1, 10, 5) == 3);
assert(func0(arr2, 10, 9) == 9);
assert(func0(arr3, 10, 6) == 6);
return 0;
}
| O3 | c | func0:
endbr64
mov $0xffffffff,%r9d
sub $0x1,%esi
js 1389 <func0+0x39>
xor %ecx,%ecx
jmp 1371 <func0+0x21>
nopl 0x0(%rax,%rax,1)
jge 1390 <func0+0x40>
lea -0x1(%rax),%esi
cmp %esi,%ecx
jg 1389 <func0+0x39>
lea (%rsi,%rcx,1),%eax
sar %eax
movslq %eax,%r8
cmp (%rdi,%r8,4),%edx
jne ... | func0:
endbr64
mov r9d, 0FFFFFFFFh
sub esi, 1
js short loc_13B3
xor r8d, r8d
jmp short loc_1392
loc_1388:
jge short loc_13C0
lea esi, [rax-1]
loc_138D:
cmp r8d, esi
jg short loc_13B3
loc_1392:
lea ecx, [rsi+r8]
mov eax, ecx
shr eax, 1Fh
add eax, ecx
sar eax, 1
m... | long long func0(long long a1, int a2, int a3)
{
unsigned int v3; // r9d
int v4; // esi
int v5; // r8d
int v6; // eax
v3 = -1;
v4 = a2 - 1;
if ( v4 >= 0 )
{
v5 = 0;
do
{
while ( 1 )
{
v6 = (v4 + v5) / 2;
if ( a3 != *(_DWORD *)(a1 + 4LL * v6) )
break;
... | func0:
ENDBR64
MOV R9D,0xffffffff
SUB ESI,0x1
JS 0x001013b3
XOR R8D,R8D
JMP 0x00101392
LAB_00101388:
JGE 0x001013c0
LEA ESI,[RAX + -0x1]
LAB_0010138d:
CMP R8D,ESI
JG 0x001013b3
LAB_00101392:
LEA ECX,[RSI + R8*0x1]
MOV EAX,ECX
SHR EAX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOVSXD RCX,EAX
CMP EDX,dword ptr [RDI + RCX*0x4]
JNZ 0x00... | int func0(long param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
iVar4 = -1;
param_2 = param_2 + -1;
if (-1 < param_2) {
iVar3 = 0;
do {
while( true ) {
iVar2 = (param_2 + iVar3) / 2;
iVar1 = *(int *)(param_1 + (long)iVar2 * 4);
if (pa... |
5,160 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
int count;
char value;
} Element;
typedef struct {
int is_pair;
union {
char single;
Element pair;
} data;
} EncodedValue;
| EncodedValue* func0(char* alist, int *return_size) {
int alist_len = strlen(alist);
EncodedValue *result = (EncodedValue*) malloc(sizeof(EncodedValue) * alist_len);
int i = 0;
int res_idx = 0;
while (i < alist_len) {
char current = alist[i];
int count = 1;
while (i ... | int main() {
int size;
EncodedValue *test1 = func0("11234451", &size);
assert(size == 6);
assert(test1[0].is_pair && test1[0].data.pair.count == 2 && test1[0].data.pair.value == '1');
assert(!test1[1].is_pair && test1[1].data.single == '2');
assert(!test1[2].is_pair && test1[2].data.sing... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 10c0 <strlen@plt>
mov %eax,-0xc(%rbp)
mov -0xc(%rbp),%eax
movslq %eax,%rdx
mov %rdx,%rax
add %rax,%rax
add %rdx,%rax
shl $0x2,%rax
mov %rax,%... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
movsxd rdx, eax
mov rax, rdx
add rax, rax
add rax, rdx
shl rax, 2
mov rdi, rax; size... | _DWORD * func0(const char *a1, _DWORD *a2)
{
char *v2; // rax
char v4; // [rsp+17h] [rbp-19h]
int v5; // [rsp+18h] [rbp-18h]
int v6; // [rsp+1Ch] [rbp-14h]
int v7; // [rsp+20h] [rbp-10h]
int v8; // [rsp+24h] [rbp-Ch]
_DWORD *v9; // [rsp+28h] [rbp-8h]
v8 = strlen(a1);
v9 = malloc(12LL * v8);
v5 = 0;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001010c0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
MOVSXD RDX,EAX
MOV RAX,RDX
ADD RAX,RAX
ADD RAX,RDX
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001... | void * func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
void *pvVar4;
int local_20;
int local_1c;
int local_18;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
pvVar4 = malloc((long)iVar2 * 0xc);
local_1c = 0;
for (local_20 = 0; local_20 < iVar2; local_20 = local_20 + 1)... |
5,161 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
int count;
char value;
} Element;
typedef struct {
int is_pair;
union {
char single;
Element pair;
} data;
} EncodedValue;
| EncodedValue* func0(char* alist, int *return_size) {
int alist_len = strlen(alist);
EncodedValue *result = (EncodedValue*) malloc(sizeof(EncodedValue) * alist_len);
int i = 0;
int res_idx = 0;
while (i < alist_len) {
char current = alist[i];
int count = 1;
while (i ... | int main() {
int size;
EncodedValue *test1 = func0("11234451", &size);
assert(size == 6);
assert(test1[0].is_pair && test1[0].data.pair.count == 2 && test1[0].data.pair.value == '1');
assert(!test1[1].is_pair && test1[1].data.single == '2');
assert(!test1[2].is_pair && test1[2].data.sing... | O1 | c | func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbx
mov %rsi,%r13
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rbp
movslq %ebp,%rax
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10d0 <malloc... | func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13, rsi
call _strlen
mov r12, rax
mov ebp, eax
cdqe
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
test r12d, r12d
jle short loc_1293
mov r9, rax
mov r10d, 0
mov edx, 0
jmp ... | long long func0(long long a1, _DWORD *a2)
{
int v4; // r12d
long long result; // rax
long long v6; // r9
int v7; // r10d
int v8; // edx
char v9; // di
int v10; // esi
_BYTE *v11; // rcx
int v12; // r8d
int v13; // edx
v4 = strlen();
result = malloc(12LL * v4);
if ( v4 <= 0 )
{
v7 = 0;
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13,RSI
CALL 0x001010c0
MOV R12,RAX
MOV EBP,EAX
CDQE
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010f0
TEST R12D,R12D
JLE 0x00101293
MOV R9,RAX
MOV R10D,0x0
MOV EDX,0x0
JMP 0x0010124d
LAB_0010122b:
CMP EDX,0x1
JLE 0x00101284
MOV dword ptr ... | void func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int4 *puVar4;
char *pcVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
puVar4 = (int4 *)malloc((long)iVar2 * 0xc);
if (iVar2 < 1) {
iVar10 = 0;
}
... |
5,162 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
int count;
char value;
} Element;
typedef struct {
int is_pair;
union {
char single;
Element pair;
} data;
} EncodedValue;
| EncodedValue* func0(char* alist, int *return_size) {
int alist_len = strlen(alist);
EncodedValue *result = (EncodedValue*) malloc(sizeof(EncodedValue) * alist_len);
int i = 0;
int res_idx = 0;
while (i < alist_len) {
char current = alist[i];
int count = 1;
while (i ... | int main() {
int size;
EncodedValue *test1 = func0("11234451", &size);
assert(size == 6);
assert(test1[0].is_pair && test1[0].data.pair.count == 2 && test1[0].data.pair.value == '1');
assert(!test1[1].is_pair && test1[1].data.single == '2');
assert(!test1[2].is_pair && test1[2].data.sing... | O2 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10c0 <strlen@plt>
mov %rax,%r12
mov %eax,%ebp
cltq
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %r12d,%r12d
jle 1666 <func0+0xc6>
mov %rax,%r10
xor %r11d,... | func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov r12, rax
mov ebp, eax
cdqe
lea rdi, [rax+rax*2]
shl rdi, 2
call _malloc
test r12d, r12d
jle loc_165E
mov r9, rax
xor r10d, r10d
xor edx, edx
xchg a... | long long func0(long long a1, _DWORD *a2)
{
int v4; // r12d
long long result; // rax
long long v6; // r9
int v7; // r10d
int v8; // edx
int v9; // esi
char v10; // di
_BYTE *v11; // rcx
int v12; // r8d
int v13; // edx
v4 = strlen();
result = malloc(12LL * v4);
if ( v4 <= 0 )
{
*a2 = 0;... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x001010c0
MOV R12,RAX
MOV EBP,EAX
CDQE
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010f0
TEST R12D,R12D
JLE 0x0010165e
MOV R9,RAX
XOR R10D,R10D
XOR EDX,EDX
NOP
LAB_001015e0:
MOVSXD RCX,EDX
LEA ESI,[RDX + 0x1]
MOVZX EDI,byte p... | void func0(char *param_1,int *param_2)
{
int iVar1;
char cVar2;
int iVar3;
size_t sVar4;
int4 *puVar5;
char *pcVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
sVar4 = strlen(param_1);
iVar3 = (int)sVar4;
puVar5 = (int4 *)malloc((long)iVar3 * 0xc);
if (iVar3 < 1) {
*p... |
5,163 | func0 |
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdlib.h>
typedef struct {
int count;
char value;
} Element;
typedef struct {
int is_pair;
union {
char single;
Element pair;
} data;
} EncodedValue;
| EncodedValue* func0(char* alist, int *return_size) {
int alist_len = strlen(alist);
EncodedValue *result = (EncodedValue*) malloc(sizeof(EncodedValue) * alist_len);
int i = 0;
int res_idx = 0;
while (i < alist_len) {
char current = alist[i];
int count = 1;
while (i ... | int main() {
int size;
EncodedValue *test1 = func0("11234451", &size);
assert(size == 6);
assert(test1[0].is_pair && test1[0].data.pair.count == 2 && test1[0].data.pair.value == '1');
assert(!test1[1].is_pair && test1[1].data.single == '2');
assert(!test1[2].is_pair && test1[2].data.sing... | O3 | c | func0:
endbr64
push %r13
mov %rsi,%r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x8,%rsp
callq 10c0 <strlen@plt>
mov %rax,%r12
mov %eax,%ebp
cltq
lea (%rax,%rax,2),%rdi
shl $0x2,%rdi
callq 10f0 <malloc@plt>
test %r12d,%r12d
jle 1666 <func0+0xc6>
mov %rax,%r10
xor %r11d,... | func0:
endbr64
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 8
call _strlen
mov r12, rax
mov ebp, eax
cdqe
lea rdi, [rax+rax*2]
shl rdi, 2; size
call _malloc
test r12d, r12d
jle loc_167B
mov r9, rax
xor r10d, r10d
xor esi, esi
xch... | char * func0(const char *a1, _DWORD *a2)
{
int v4; // r12d
char *result; // rax
char *v6; // r9
int v7; // r10d
int v8; // esi
char v9; // di
long long v10; // rdx
int v11; // ecx
int v12; // r8d
v4 = strlen(a1);
result = (char *)malloc(12LL * v4);
if ( v4 <= 0 )
{
*a2 = 0;
}
else
{... | func0:
ENDBR64
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x8
CALL 0x001010c0
MOV R12,RAX
MOV EBP,EAX
CDQE
LEA RDI,[RAX + RAX*0x2]
SHL RDI,0x2
CALL 0x001010f0
TEST R12D,R12D
JLE 0x0010167b
MOV R9,RAX
XOR R10D,R10D
XOR ESI,ESI
NOP
LAB_001015e0:
MOVSXD RDX,ESI
MOVZX EDI,byte ptr [RBX + RDX*0x1]
L... | void func0(char *param_1,int *param_2)
{
char cVar1;
int iVar2;
size_t sVar3;
int4 *puVar4;
int iVar5;
long lVar6;
int iVar7;
int iVar8;
int iVar9;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
puVar4 = (int4 *)malloc((long)iVar2 * 0xc);
if (iVar2 < 1) {
*param_2 = 0;
return;
}
... |
5,164 | func0 |
#include <assert.h>
| int func0(int s) {
int maxvalue = 0;
int i, j, k;
for (i = 1; i < s - 1; i++) {
for (j = 1; j < s; j++) {
k = s - i - j;
if (i * j * k > maxvalue) {
maxvalue = i * j * k;
}
}
}
return maxvalue;
}
| int main() {
assert(func0(8) == 18);
assert(func0(4) == 2);
assert(func0(1) == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 11a9 <func0+0x60>
movl $0x1,-0x8(%rbp)
jmp 119d <func0+0x54>
mov -0x14(%rbp),%eax
sub -0xc(%rbp),%eax
sub -0x8(%rbp),%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%eax
imul -0x8(%rbp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_11A9
loc_1164:
mov [rbp+var_8], 1
jmp short loc_119D
loc_116D:
mov eax, [rbp+var_14]
sub eax, [rbp+var_C]
sub eax, [rbp+var_8]
mov [rbp+var_4], eax
mov eax, ... | long long func0(int a1)
{
int v2; // [rsp+4h] [rbp-10h]
int i; // [rsp+8h] [rbp-Ch]
int j; // [rsp+Ch] [rbp-8h]
int v5; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i < a1 - 1; ++i )
{
for ( j = 1; j < a1; ++j )
{
v5 = a1 - i - j;
if ( v2 < v5 * j * i )
v2 = v5 * j * i;
}
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x001011a9
LAB_00101164:
MOV dword ptr [RBP + -0x8],0x1
JMP 0x0010119d
LAB_0010116d:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,dword ptr [RBP + -0xc]
SUB EAX,dword ptr [RBP + -0x8]
MOV dw... | int func0(int param_1)
{
int iVar1;
int4 local_18;
int4 local_14;
int4 local_10;
local_18 = 0;
for (local_14 = 1; local_14 < param_1 + -1; local_14 = local_14 + 1) {
for (local_10 = 1; local_10 < param_1; local_10 = local_10 + 1) {
iVar1 = (param_1 - local_14) - local_10;
if (local_18 < ... |
5,165 | func0 |
#include <assert.h>
| int func0(int s) {
int maxvalue = 0;
int i, j, k;
for (i = 1; i < s - 1; i++) {
for (j = 1; j < s; j++) {
k = s - i - j;
if (i * j * k > maxvalue) {
maxvalue = i * j * k;
}
}
}
return maxvalue;
}
| int main() {
assert(func0(8) == 18);
assert(func0(4) == 2);
assert(func0(1) == 0);
return 0;
}
| O1 | c | func0:
endbr64
cmp $0x2,%edi
jle 11a2 <func0+0x59>
push %rbx
lea -0x1(%rdi),%r11d
mov %r11d,%ebx
mov $0xffffffff,%r8d
mov $0x1,%r10d
mov $0x0,%ecx
jmp 118f <func0+0x46>
mov %edx,%esi
imul %eax,%esi
cmp %esi,%ecx
cmovl %esi,%ecx
add %r9d,%edx
sub $0x1,%eax
cmp %r8d,%eax
jne ... | func0:
endbr64
cmp edi, 2
jle short loc_119E
lea r11d, [rdi-1]
mov r8d, 0FFFFFFFFh
mov r10d, 1
mov ecx, 0
jmp short loc_118B
loc_1169:
mov esi, edx
imul esi, eax
cmp ecx, esi
cmovl ecx, esi
add edx, r9d
sub eax, 1
cmp eax, r8d
jnz short loc_1169
loc_117E:
add ... | long long func0(int a1)
{
int v1; // r11d
int v2; // r8d
int v3; // r10d
int v4; // ecx
int v5; // edx
int v6; // eax
if ( a1 <= 2 )
{
return 0;
}
else
{
v1 = a1 - 1;
v2 = -1;
v3 = 1;
v4 = 0;
do
{
v6 = v1 - v3;
v5 = v3;
do
{
if ( v4 < v... | func0:
ENDBR64
CMP EDI,0x2
JLE 0x0010119e
LEA R11D,[RDI + -0x1]
MOV R8D,0xffffffff
MOV R10D,0x1
MOV ECX,0x0
JMP 0x0010118b
LAB_00101169:
MOV ESI,EDX
IMUL ESI,EAX
CMP ECX,ESI
CMOVL ECX,ESI
ADD EDX,R9D
SUB EAX,0x1
CMP EAX,R8D
JNZ 0x00101169
LAB_0010117e:
ADD R10D,0x1
SUB R8D,0x1
CMP R10D,R11D
JZ 0x001011a3
LAB_0010118b:
... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_1 < 3) {
iVar2 = 0;
}
else {
iVar4 = -1;
iVar5 = 1;
iVar2 = 0;
do {
iVar1 = (param_1 + -1) - iVar5;
iVar3 = iVar5;
if (1 < param_1) {
do {
if (iVar2 < iVa... |
5,166 | func0 |
#include <assert.h>
| int func0(int s) {
int maxvalue = 0;
int i, j, k;
for (i = 1; i < s - 1; i++) {
for (j = 1; j < s; j++) {
k = s - i - j;
if (i * j * k > maxvalue) {
maxvalue = i * j * k;
}
}
}
return maxvalue;
}
| int main() {
assert(func0(8) == 18);
assert(func0(4) == 2);
assert(func0(1) == 0);
return 0;
}
| O2 | c | func0:
endbr64
cmp $0x2,%edi
jle 1226 <func0+0x56>
lea -0x1(%rdi),%r10d
mov $0xffffffff,%r9d
mov $0x1,%esi
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %r10d,%eax
mov %esi,%edx
sub %esi,%eax
cmp $0x1,%edi
jle 1216 <func0+0x46>
nopl 0x0(%rax)
mov %edx,%ecx
imul %eax,%ecx
cmp %ecx,... | func0:
endbr64
lea r10d, [rdi-1]
cmp r10d, 1
jle short loc_1246
mov r9d, 0FFFFFFFFh
mov esi, 1
xor r8d, r8d
nop dword ptr [rax+00h]
loc_1210:
mov eax, r10d
mov edx, esi
sub eax, esi
cmp edi, 1
jle short loc_1236
nop dword ptr [rax+00h]
loc_1220:
mov ecx, edx
imul ... | long long func0(int a1)
{
int v1; // r10d
int v2; // r9d
int v3; // esi
int v4; // r8d
int v5; // edx
int v6; // eax
v1 = a1 - 1;
if ( a1 - 1 <= 1 )
return 0LL;
v2 = -1;
v3 = 1;
v4 = 0;
do
{
v5 = v3;
v6 = v1 - v3;
if ( a1 > 1 )
{
do
{
if ( v4 < v6 * v5... | func0:
ENDBR64
LEA R10D,[RDI + -0x1]
CMP R10D,0x1
JLE 0x00101246
MOV R9D,0xffffffff
MOV ESI,0x1
XOR R8D,R8D
NOP dword ptr [RAX]
LAB_00101210:
MOV EAX,R10D
MOV EDX,ESI
SUB EAX,ESI
CMP EDI,0x1
JLE 0x00101236
NOP dword ptr [RAX]
LAB_00101220:
MOV ECX,EDX
IMUL ECX,EAX
CMP R8D,ECX
CMOVL R8D,ECX
SUB EAX,0x1
ADD EDX,ESI
CMP E... | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
iVar6 = param_1 + -1;
if (1 < iVar6) {
iVar5 = -1;
iVar3 = 1;
iVar4 = 0;
do {
iVar1 = iVar6 - iVar3;
iVar2 = iVar3;
if (1 < param_1) {
do {
if (iVar4 < iVar2... |
5,167 | func0 |
#include <assert.h>
| int func0(int s) {
int maxvalue = 0;
int i, j, k;
for (i = 1; i < s - 1; i++) {
for (j = 1; j < s; j++) {
k = s - i - j;
if (i * j * k > maxvalue) {
maxvalue = i * j * k;
}
}
}
return maxvalue;
}
| int main() {
assert(func0(8) == 18);
assert(func0(4) == 2);
assert(func0(1) == 0);
return 0;
}
| O3 | c | func0:
endbr64
cmp $0x2,%edi
jle 1400 <func0+0x2c0>
lea -0x1(%rdi),%r9d
movdqa 0xec7(%rip),%xmm7
push %r14
xor %eax,%eax
mov %r9d,%r10d
mov %r9d,%r8d
push %r12
lea -0x2(%rdi),%r11d
and $0xfffffffc,%r10d
push %rbp
shr $0x2,%r8d
mov $0x1,%ecx
push %rbx
lea 0x1(%r10),%ebx
nopl 0x... | func0:
endbr64
cmp edi, 2
jle loc_12DB
lea eax, [rdi-3]
lea esi, [rdi-2]
cmp eax, 2
jbe loc_12E0
movd xmm7, edi
mov ecx, esi
movdqa xmm4, cs:xmmword_2010
xor edx, edx
pshufd xmm9, xmm7, 0
movdqa xmm7, cs:xmmword_2020
shr ecx, 2
pxor xmm2, xmm2
movdqa xmm8, cs:xmmword_2030
n... | long long func0(signed int a1)
{
unsigned int v1; // esi
__m128i si128; // xmm4
int v3; // edx
__m128i v4; // xmm9
__m128i v5; // xmm7
__m128i v6; // xmm2
__m128i v7; // xmm8
__m128i v8; // xmm3
int v9; // eax
__m128i v10; // xmm6
__m128i v11; // xmm1
__m128i v12; // xmm5
__m128i v13; // xmm0... | func0:
ENDBR64
CMP EDI,0x2
JLE 0x001012db
LEA EAX,[RDI + -0x3]
LEA ESI,[RDI + -0x2]
CMP EAX,0x2
JBE 0x001012e0
MOVD XMM7,EDI
MOV ECX,ESI
MOVDQA XMM4,xmmword ptr [0x00102010]
XOR EDX,EDX
PSHUFD XMM9,XMM7,0x0
MOVDQA XMM7,xmmword ptr [0x00102020]
SHR ECX,0x2
PXOR XMM2,XMM2
MOVDQA XMM8,xmmword ptr [0x00102030]
NOP word ptr... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
uint func0(int param_1)
{
uint uVar1;
int iVar2;
int iVar3;
int iVar4;
uint uVar5;
int iVar6;
uint uVar7;
uint uVar8;
int auVar9 [16];
int auVar10 [16];
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
... |
5,168 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
#include <stdlib.h>
| char** func0(const char* text, int* count) {
regex_t regex;
regmatch_t matches[1];
static char* words[10];
char pattern[] = "\\b[a-zA-Z]{5}\\b";
int word_count = 0;
char str[strlen(text) + 1];
strcpy(str, text);
regcomp(®ex, pattern, REG_EXTENDED);
char *p = str;
... | int main() {
int count;
char** result;
result = func0("Please move back to strem", &count);
assert(count == 1 && strcmp(result[0], "strem") == 0);
result = func0("4K Ultra HD streaming player", &count);
assert(count == 1 && strcmp(result[0], "Ultra") == 0);
result = func0("Strea... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0xb8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
mov %rsp,%rax
mov %rax,%rbx
movabs $0x2d417a2d615b625c,%rax
movabs $0x625c7d357b5d... | func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+s], rdi
mov [rbp+var_C0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, rsp
mov rbx, rax
mov rax, 2D417A2D615B625Ch
mov rdx, 625C7D357B5D5Ah
mov qword ptr [rbp+pattern], rax
mov ... | _QWORD * func0(char *a1, _DWORD *a2)
{
size_t v2; // rax
unsigned long long v3; // rax
void *v4; // rsp
int v5; // eax
_DWORD *v7; // [rsp+8h] [rbp-C0h] BYREF
char *s; // [rsp+10h] [rbp-B8h]
int v9; // [rsp+1Ch] [rbp-ACh]
regmatch_t v10; // [rsp+20h] [rbp-A8h]
char *string; // [rsp+28h] [rbp-A0h]
si... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RDI
MOV qword ptr [RBP + -0xc0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,RSP
MOV RBX,RAX
MOV RAX,0x2d417a2d615b625c
MOV RDX,0x625c7d357b5d5a
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP... | int1 * func0(char *param_1,int *param_2)
{
long lVar1;
int iVar2;
ulong uVar3;
char *pcVar4;
char *__src;
int **ppiVar5;
long in_FS_OFFSET;
int *local_c8;
char *local_c0;
int local_b4;
int local_b0;
int local_ac;
char *local_a8;
size_t local_a0;
char *local_98;
char *local_90;
regex_t... |
5,169 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
#include <stdlib.h>
| char** func0(const char* text, int* count) {
regex_t regex;
regmatch_t matches[1];
static char* words[10];
char pattern[] = "\\b[a-zA-Z]{5}\\b";
int word_count = 0;
char str[strlen(text) + 1];
strcpy(str, text);
regcomp(®ex, pattern, REG_EXTENDED);
char *p = str;
... | int main() {
int count;
char** result;
result = func0("Please move back to strem", &count);
assert(count == 1 && strcmp(result[0], "strem") == 0);
result = func0("4K Ultra HD streaming player", &count);
assert(count == 1 && strcmp(result[0], "Ultra") == 0);
result = func0("Strea... | O1 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
push %rbx
sub $0x88,%rsp
mov %rdi,%rdx
mov %rsi,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movabs $0x2d417a2d615b625c,%rbx
movabs $0x625c7d357b5d5a,%rsi
mov %rbx,-0x50(%rbp)
mov %r... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
mov rax, 2D417A2D615B625Ch
mov rdx, 625C7D357B5D5Ah
mov [rbp+var_50], rax
mov ... | _QWORD * func0(long long a1, _DWORD *a2)
{
long long v2; // rax
__int16 v3; // cx
signed long long v4; // rax
void *v5; // rsp
long long v6; // r15
int v7; // ebx
int v8; // r14d
int v9; // r13d
long long v10; // r12
long long v11; // rsi
_DWORD **v12; // rbx
long long v14; // [rsp+0h] [rbp-B8h]... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV RAX,0x2d417a2d615b625c
MOV RDX,0x625c7d357b5d5a
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x48... | int8 * func0(char *param_1,int4 *param_2)
{
long lVar1;
char *pcVar2;
regoff_t rVar3;
regoff_t rVar4;
int iVar5;
size_t sVar6;
ulong uVar7;
char *__dest;
int4 **ppuVar8;
char *__src;
long lVar9;
long in_FS_OFFSET;
int4 *local_b8;
char *local_b0;
regex_t local_a8;
regmatch_t local_60;
... |
5,170 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
#include <stdlib.h>
| char** func0(const char* text, int* count) {
regex_t regex;
regmatch_t matches[1];
static char* words[10];
char pattern[] = "\\b[a-zA-Z]{5}\\b";
int word_count = 0;
char str[strlen(text) + 1];
strcpy(str, text);
regcomp(®ex, pattern, REG_EXTENDED);
char *p = str;
... | int main() {
int count;
char** result;
result = func0("Please move back to strem", &count);
assert(count == 1 && strcmp(result[0], "strem") == 0);
result = func0("4K Ultra HD streaming player", &count);
assert(count == 1 && strcmp(result[0], "Ultra") == 0);
result = func0("Strea... | O2 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x98,%rsp
mov %rsi,-0xb8(%rbp)
movdqa 0xd86(%rip),%xmm0
mov %rsp,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movaps %xmm0,-0x50(%rbp)
callq 10f0 <strlen@plt>
lea... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12, rdi
push rbx
sub rsp, 98h
mov [rbp+var_B8], rsi
movdqa xmm0, cs:xmmword_2120
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movaps [rbp+var_50], xmm0
call _strlen
mov rsi, rsp
lea... | _QWORD * func0(long long a1, _DWORD *a2)
{
long long v2; // rax
long long *v3; // rsi
signed long long v4; // rdx
void *v5; // rsp
_BYTE *v6; // rbx
long long v7; // r12
int v8; // r14d
long long v9; // r15
long long v10; // rax
long long v11; // rcx
_BYTE v14[4088]; // [rsp+8h] [rbp-10C0h] BYREF
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0xb8],RSI
MOVDQA XMM0,xmmword ptr [0x00102120]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x50],XMM0
CALL 0x00101100
MOV RSI,RSP
LEA RCX... | int8 * func0(char *param_1,int4 *param_2)
{
long lVar1;
int1 *puVar2;
regoff_t rVar3;
int iVar4;
size_t sVar5;
char *pcVar6;
ulong uVar7;
char *__string;
int1 *puVar8;
long lVar10;
long in_FS_OFFSET;
int1 auStack_c8 [8];
int4 *local_c0;
regmatch_t *local_b8;
int local_ac;
regex_t local_... |
5,171 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <regex.h>
#include <stdlib.h>
| char** func0(const char* text, int* count) {
regex_t regex;
regmatch_t matches[1];
static char* words[10];
char pattern[] = "\\b[a-zA-Z]{5}\\b";
int word_count = 0;
char str[strlen(text) + 1];
strcpy(str, text);
regcomp(®ex, pattern, REG_EXTENDED);
char *p = str;
... | int main() {
int count;
char** result;
result = func0("Please move back to strem", &count);
assert(count == 1 && strcmp(result[0], "strem") == 0);
result = func0("4K Ultra HD streaming player", &count);
assert(count == 1 && strcmp(result[0], "Ultra") == 0);
result = func0("Strea... | O3 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbx
sub $0x98,%rsp
mov %rsi,-0xb8(%rbp)
movdqa 0xd86(%rip),%xmm0
mov %rsp,%rbx
mov %fs:0x28,%rax
mov %rax,-0x38(%rbp)
xor %eax,%eax
movaps %xmm0,-0x50(%rbp)
callq 10f0 <strlen@plt>
lea... | func0:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
mov r12, rdi
push rbx
sub rsp, 98h
mov [rbp+var_C0], rsi
movdqa xmm0, cs:xmmword_2120
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, eax
movaps xmmword ptr [rbp+pattern], xmm0
call _strlen
mov ... | _QWORD * func0(const char *a1, _DWORD *a2)
{
size_t v2; // rax
_BYTE *v3; // rcx
signed long long v4; // rdx
void *v5; // rsp
const char *v6; // rbx
long long v7; // r12
int v8; // r15d
long long v9; // r14
size_t v10; // r13
void *v11; // rax
long long v12; // rax
_BYTE v15[4088]; // [rsp+8h] [... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RBP + -0xc0],RSI
MOVDQA XMM0,xmmword ptr [0x00102120]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RBP + -0x50],XMM0
CALL 0x001010f0
MOV RCX,RSP
LEA RSI... | int8 * func0(char *param_1,int4 *param_2)
{
long lVar1;
int4 **ppuVar2;
regoff_t rVar3;
int iVar4;
size_t sVar5;
void *pvVar6;
long lVar7;
ulong uVar8;
char *__string;
int4 **ppuVar9;
long lVar11;
long in_FS_OFFSET;
int4 *local_c8;
regmatch_t *local_c0;
regex_t *local_b8;
int local_ac;
... |
5,172 | func0 |
#include <assert.h>
| int func0(int n) {
int sumofsquares = 0;
int squareofsum = 0;
for (int num = 1; num <= n; num++) {
sumofsquares += num * num;
squareofsum += num;
}
squareofsum = squareofsum * squareofsum;
return squareofsum - sumofsquares;
}
| int main() {
assert(func0(12) == 5434);
assert(func0(20) == 41230);
assert(func0(54) == 2151270);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
jmp 117e <func0+0x35>
mov -0x4(%rbp),%eax
imul %eax,%eax
add %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 0
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_117E
loc_116B:
mov eax, [rbp+var_4]
imul eax, eax
add [rbp+var_C], eax
mov eax, [rbp+var_4]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_117E... | long long func0(int a1)
{
int v2; // [rsp+8h] [rbp-Ch]
int v3; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
v3 = 0;
for ( i = 1; i <= a1; ++i )
{
v2 += i * i;
v3 += i;
}
return (unsigned int)(v3 * v3 - v2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010117e
LAB_0010116b:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
ADD dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x... | int func0(int param_1)
{
int4 local_14;
int4 local_10;
int4 local_c;
local_14 = 0;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_14 = local_14 + local_c * local_c;
local_10 = local_10 + local_c;
}
return local_10 * local_10 - local_14;
} |
5,173 | func0 |
#include <assert.h>
| int func0(int n) {
int sumofsquares = 0;
int squareofsum = 0;
for (int num = 1; num <= n; num++) {
sumofsquares += num * num;
squareofsum += num;
}
squareofsum = squareofsum * squareofsum;
return squareofsum - sumofsquares;
}
| int main() {
assert(func0(12) == 5434);
assert(func0(20) == 41230);
assert(func0(54) == 2151270);
return 0;
}
| O1 | c | func0:
endbr64
test %edi,%edi
jle 1179 <func0+0x30>
add $0x1,%edi
mov $0x1,%edx
mov $0x0,%eax
mov $0x0,%ecx
mov %edx,%esi
imul %edx,%esi
add %esi,%ecx
add %edx,%eax
add $0x1,%edx
cmp %edi,%edx
jne 1163 <func0+0x1a>
imul %eax,%eax
sub %ecx,%eax
retq
mov $0x0,%eax
mov $0x0,... | func0:
endbr64
test edi, edi
jle short loc_1179
add edi, 1
mov edx, 1
mov eax, 0
mov ecx, 0
loc_1163:
mov esi, edx
imul esi, edx
add ecx, esi
add eax, edx
add edx, 1
cmp edx, edi
jnz short loc_1163
loc_1173:
imul eax, eax
sub eax, ecx
retn
loc_1179:
mov eax, ... | long long func0(int a1)
{
int v1; // edi
int v2; // edx
int v3; // eax
int v4; // ecx
if ( a1 <= 0 )
{
v3 = 0;
v4 = 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
v4 = 0;
do
{
v4 += v2 * v2;
v3 += v2++;
}
while ( v2 != v1 );
}
return (unsigned int)(v... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101179
ADD EDI,0x1
MOV EDX,0x1
MOV EAX,0x0
MOV ECX,0x0
LAB_00101163:
MOV ESI,EDX
IMUL ESI,EDX
ADD ECX,ESI
ADD EAX,EDX
ADD EDX,0x1
CMP EDX,EDI
JNZ 0x00101163
LAB_00101173:
IMUL EAX,EAX
SUB EAX,ECX
RET
LAB_00101179:
MOV EAX,0x0
MOV ECX,0x0
JMP 0x00101173 | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
iVar1 = 0;
iVar2 = 0;
}
else {
iVar3 = 1;
iVar1 = 0;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar3 * iVar3;
iVar1 = iVar1 + iVar3;
iVar3 = iVar3 + 1;
} while (iVar3 != param_1 + 1);
}
r... |
5,174 | func0 |
#include <assert.h>
| int func0(int n) {
int sumofsquares = 0;
int squareofsum = 0;
for (int num = 1; num <= n; num++) {
sumofsquares += num * num;
squareofsum += num;
}
squareofsum = squareofsum * squareofsum;
return squareofsum - sumofsquares;
}
| int main() {
assert(func0(12) == 5434);
assert(func0(20) == 41230);
assert(func0(54) == 2151270);
return 0;
}
| O2 | c | func0:
endbr64
test %edi,%edi
jle 1170 <func0+0x30>
add $0x1,%edi
mov $0x1,%edx
xor %eax,%eax
xor %ecx,%ecx
nopl 0x0(%rax)
mov %edx,%esi
add %edx,%eax
imul %edx,%esi
add $0x1,%edx
add %esi,%ecx
cmp %edx,%edi
jne 1158 <func0+0x18>
imul %eax,%eax
sub %ecx,%eax
retq
xchg %ax,%... | func0:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov edx, 1
xor eax, eax
xor ecx, ecx
nop dword ptr [rax+00h]
loc_1158:
mov esi, edx
add eax, edx
imul esi, edx
add edx, 1
add ecx, esi
cmp edi, edx
jnz short loc_1158
imul eax, eax
sub eax, ecx
retn
l... | long long func0(int a1)
{
int v1; // edi
int v2; // edx
int v3; // eax
int v4; // ecx
int v5; // esi
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
v4 = 0;
do
{
v3 += v2;
v5 = v2 * v2;
++v2;
v4 += v5;
}
while ( v1 != v2 );
return (unsigned int)(v3 * v3 - v4);... | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EDX,0x1
XOR EAX,EAX
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_00101158:
MOV ESI,EDX
ADD EAX,EDX
IMUL ESI,EDX
ADD EDX,0x1
ADD ECX,ESI
CMP EDI,EDX
JNZ 0x00101158
IMUL EAX,EAX
SUB EAX,ECX
RET
LAB_00101170:
XOR EAX,EAX
RET | int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
if (0 < param_1) {
iVar3 = 1;
iVar1 = 0;
iVar2 = 0;
do {
iVar1 = iVar1 + iVar3;
iVar4 = iVar3 * iVar3;
iVar3 = iVar3 + 1;
iVar2 = iVar2 + iVar4;
} while (param_1 + 1 != iVar3);
return iVar1... |
5,175 | func0 |
#include <assert.h>
| int func0(int n) {
int sumofsquares = 0;
int squareofsum = 0;
for (int num = 1; num <= n; num++) {
sumofsquares += num * num;
squareofsum += num;
}
squareofsum = squareofsum * squareofsum;
return squareofsum - sumofsquares;
}
| int main() {
assert(func0(12) == 5434);
assert(func0(20) == 41230);
assert(func0(54) == 2151270);
return 0;
}
| O3 | c | func0:
endbr64
test %edi,%edi
jle 1350 <func0+0x210>
lea -0x1(%rdi),%eax
cmp $0xf,%eax
jbe 1353 <func0+0x213>
mov %edi,%edx
pxor %xmm4,%xmm4
movdqa 0xeaa(%rip),%xmm5
xor %eax,%eax
movdqa 0xeb0(%rip),%xmm6
shr $0x2,%edx
movdqa %xmm4,%xmm3
nopw 0x0(%rax,%rax,1)
movdqa %xmm5,%xmm2
add $0x1,%e... | func0:
endbr64
mov ecx, edi
test edi, edi
jle loc_12F8
lea eax, [rdi-1]
cmp eax, 0Bh
jbe loc_12FB
mov edx, edi
pxor xmm4, xmm4
movdqa xmm5, cs:xmmword_2010
xor eax, eax
movdqa xmm6, cs:xmmword_2020
shr edx, 2
movdqa xmm3, xmm4
nop dword ptr [rax+00000000h]
loc_1180:
movdqa ... | long long func0(int a1)
{
__m128i v2; // xmm4
__m128i si128; // xmm5
int v4; // eax
__m128i v5; // xmm6
__m128i v6; // xmm3
__m128i v7; // xmm2
__m128i v8; // xmm0
__m128i v9; // xmm4
unsigned int v10; // esi
int v11; // eax
__m128i v12; // xmm3
int v13; // edx
unsigned int v14; // edi
int ... | func0:
ENDBR64
MOV ECX,EDI
TEST EDI,EDI
JLE 0x001012f8
LEA EAX,[RDI + -0x1]
CMP EAX,0xb
JBE 0x001012fb
MOV EDX,EDI
PXOR XMM4,XMM4
MOVDQA XMM5,xmmword ptr [0x00102010]
XOR EAX,EAX
MOVDQA XMM6,xmmword ptr [0x00102020]
SHR EDX,0x2
MOVDQA XMM3,XMM4
NOP dword ptr [RAX]
LAB_00101180:
MOVDQA XMM2,XMM5
ADD EAX,0x1
PADDD XMM5,X... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint param_1)
{
uint uVar1;
int iVar2;
ulong uVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int auVar12 [16];
int auVar13 [16];
int iVar14;
uin... |
5,176 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char *s) {
static char res[1000];
int l = strlen(s);
int pos = 0;
for (int i = 1; i <= l; i++) {
pos += sprintf(&res[pos], "%d", i);
}
for (int i = l - 1; i > 0; i--) {
pos += sprintf(&res[pos], "%d", i);
}
res[pos] = '\0';
ret... | int main() {
assert(strcmp(func0("111111"), "12345654321") == 0);
assert(strcmp(func0("1111"), "1234321") == 0);
assert(strcmp(func0("13333122222"), "123456789101110987654321") == 0);
return 0;
}
| O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x1,-0xc(%rbp)
jmp 1208 <func0+0x5f>
mov -0x10(%rbp),%eax
cltq
lea 0x2e5c(%rip),%rdx
lea (%rax,%rdx,1... | func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+s], rdi
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_10], 0
mov [rbp+var_C], 1
jmp short loc_120B
loc_11D8:
mov eax, [rbp+var_10]
cdqe
lea rdx, res_1
lea rcx, [rax+rdx]
mov... | char * func0(const char *a1)
{
int v2; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
int j; // [rsp+18h] [rbp-8h]
int v5; // [rsp+1Ch] [rbp-4h]
v5 = strlen(a1);
v2 = 0;
for ( i = 1; i <= v5; ++i )
v2 += sprintf(&res_1[v2], "%d", i);
for ( j = v5 - 1; j > 0; --j )
v2 += sprintf(&res_1[v2],... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x18],RDI
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101080
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010120b
LAB_001011d8:
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[0x104040]
... | int1 * func0(char *param_1)
{
int iVar1;
size_t sVar2;
int local_18;
uint local_14;
uint local_10;
sVar2 = strlen(param_1);
local_10 = (uint)sVar2;
local_18 = 0;
for (local_14 = 1; (int)local_14 <= (int)local_10; local_14 = local_14 + 1) {
iVar1 = sprintf(res_1 + local_18,"%d",(ulong)local_14)... |
5,177 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char *s) {
static char res[1000];
int l = strlen(s);
int pos = 0;
for (int i = 1; i <= l; i++) {
pos += sprintf(&res[pos], "%d", i);
}
for (int i = l - 1; i > 0; i--) {
pos += sprintf(&res[pos], "%d", i);
}
res[pos] = '\0';
ret... | int main() {
assert(strcmp(func0("111111"), "12345654321") == 0);
assert(strcmp(func0("1111"), "1234321") == 0);
assert(strcmp(func0("13333122222"), "123456789101110987654321") == 0);
return 0;
}
| O1 | c | func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
test %ebp,%ebp
jle 122b <func0+0xc2>
lea 0x1(%rbp),%r14d
mov $0x1,%r12d
mov $0x0,%ebx
lea 0x2e98(%rip),%r13
movslq %eb... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
mov rbp, rax
test eax, eax
jle loc_1270
lea r15d, [rax+1]
mov r12d, 1
mov ebx, 0
lea r14, res_1
lea r13, unk_2004
loc_11E8:
movsxd rdi, ebx
add rdi, r14
mov r8d, ... | _BYTE *func0()
{
int v0; // eax
int v1; // ebp
int v2; // r15d
unsigned int v3; // r12d
int v4; // ebx
int v5; // ebp
_BYTE *result; // rax
v0 = strlen();
v1 = v0;
if ( v0 <= 0 )
{
v4 = 0;
}
else
{
v2 = v0 + 1;
v3 = 1;
v4 = 0;
do
v4 += __sprintf_chk(&res_1[v4], 1LL... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101080
MOV RBP,RAX
TEST EAX,EAX
JLE 0x00101270
LEA R15D,[RAX + 0x1]
MOV R12D,0x1
MOV EBX,0x0
LEA R14,[0x104040]
LEA R13,[0x102004]
LAB_001011e8:
MOVSXD RDI,EBX
ADD RDI,R14
MOV R8D,R12D
MOV RCX,R13
MOV RDX,-0x1
MOV ESI,0x1
MOV EAX,... | void func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int iVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar4 = (int)sVar2;
if (iVar4 < 1) {
iVar3 = 0;
}
else {
iVar5 = 1;
iVar3 = 0;
do {
iVar1 = __sprintf_chk(res_1 + iVar3,1,0xffffffffffffffff,&DAT_00102004,iVar5);
... |
5,178 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char *s) {
static char res[1000];
int l = strlen(s);
int pos = 0;
for (int i = 1; i <= l; i++) {
pos += sprintf(&res[pos], "%d", i);
}
for (int i = l - 1; i > 0; i--) {
pos += sprintf(&res[pos], "%d", i);
}
res[pos] = '\0';
ret... | int main() {
assert(strcmp(func0("111111"), "12345654321") == 0);
assert(strcmp(func0("1111"), "1234321") == 0);
assert(strcmp(func0("13333122222"), "123456789101110987654321") == 0);
return 0;
}
| O2 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%rbp
test %eax,%eax
jle 1338 <func0+0xc8>
lea 0x1(%rax),%r15d
mov $0x1,%r12d
xor %ebx,%ebx
lea 0x2d9b(%rip),%r13
lea 0xd58(%rip),%r14
nopl 0x0(%rax)
movslq %... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
mov rbp, rax
test eax, eax
jle loc_1348
lea r15d, [rax+1]
mov r12d, 1
xor ebx, ebx
lea r13, res_1
lea r14, unk_2004
nop dword ptr [rax+00h]
loc_12C0:
movsxd rdi, ebx
... | _BYTE *func0()
{
int v0; // eax
int v1; // ebp
int v2; // r15d
unsigned int v3; // r12d
int v4; // ebx
long long v5; // r8
int v6; // ebp
_BYTE *result; // rax
v0 = strlen();
v1 = v0;
if ( v0 <= 0 )
{
v4 = 0;
}
else
{
v2 = v0 + 1;
v3 = 1;
v4 = 0;
do
{
v5 = v3... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101080
MOV RBP,RAX
TEST EAX,EAX
JLE 0x00101348
LEA R15D,[RAX + 0x1]
MOV R12D,0x1
XOR EBX,EBX
LEA R13,[0x104040]
LEA R14,[0x102004]
NOP dword ptr [RAX]
LAB_001012c0:
MOVSXD RDI,EBX
MOV R8D,R12D
MOV RCX,R14
MOV RDX,-0x1
ADD RDI,R13
... | int1 * func0(char *param_1)
{
int iVar1;
size_t sVar2;
int iVar3;
int iVar4;
int iVar5;
sVar2 = strlen(param_1);
iVar4 = (int)sVar2;
if (iVar4 < 1) {
iVar3 = 0;
}
else {
iVar3 = 0;
iVar1 = 1;
do {
iVar5 = iVar1 + 1;
iVar1 = __sprintf_chk(res_1 + iVar3,1,0xffffffffffff... |
5,179 | func0 |
#include <stdio.h>
#include <string.h>
#include <assert.h>
| char* func0(const char *s) {
static char res[1000];
int l = strlen(s);
int pos = 0;
for (int i = 1; i <= l; i++) {
pos += sprintf(&res[pos], "%d", i);
}
for (int i = l - 1; i > 0; i--) {
pos += sprintf(&res[pos], "%d", i);
}
res[pos] = '\0';
ret... | int main() {
assert(strcmp(func0("111111"), "12345654321") == 0);
assert(strcmp(func0("1111"), "1234321") == 0);
assert(strcmp(func0("13333122222"), "123456789101110987654321") == 0);
return 0;
}
| O3 | c | func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
mov %rax,%rbp
test %eax,%eax
jle 1338 <func0+0xc8>
lea 0x1(%rax),%r15d
mov $0x1,%r12d
xor %ebx,%ebx
lea 0x2d9b(%rip),%r13
lea 0xd58(%rip),%r14
nopl 0x0(%rax)
movslq %... | func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
call _strlen
test eax, eax
jle loc_1350
mov r13, rax
lea r14d, [rax+1]
mov r15d, 1
xor r12d, r12d
lea rbx, res_1
lea rbp, unk_2004
nop dword ptr [rax]
loc_12C0:
movsxd rdi, r12d
m... | _BYTE * func0(const char *a1)
{
int v1; // eax
int v2; // r13d
int v3; // r14d
unsigned int v4; // r15d
int v5; // r12d
long long v6; // rdx
long long v7; // r8
unsigned int i; // r13d
long long v9; // rdx
_BYTE *result; // rax
v1 = strlen(a1);
if ( v1 <= 0 )
{
v5 = 0;
}
else
{
... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
CALL 0x00101080
TEST EAX,EAX
JLE 0x00101350
MOV R13,RAX
LEA R14D,[RAX + 0x1]
MOV R15D,0x1
XOR R12D,R12D
LEA RBX,[0x104040]
LEA RBP,[0x102004]
NOP dword ptr [RAX]
LAB_001012c0:
MOVSXD RDI,R12D
MOV EDX,0x3e8
MOV R8D,R15D
MOV RCX,RBP
CMP RDI,... | int1 * func0(char *param_1)
{
int iVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
int iVar7;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
if (iVar1 < 1) {
iVar6 = 0;
}
else {
iVar6 = 0;
iVar2 = 1;
do {
uVar5 = (ulong)iVar6;
uVar4 = 1000;
... |
5,180 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int* func0(int list1[], int size, int *resultSize) {
int min_val = INT_MAX;
static int min_positions[100]; // static buffer to store positions
int count = 0;
// Find minimum value
for (int i = 0; i < size; i++) {
if (list1[i] < min_val) {
min_val = list1[i];
}
... | int main() {
int resultSize;
int* result;
int list1[] = {12,33,23,10,67,89,45,667,23,12,11,10,54};
int list2[] = {1,2,2,2,4,4,4,5,5,5,5};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
result = func0(list1, sizeof(list1)/sizeof(list1[0]), &resultSize);
assert(resultSize == 2 && result[... | O0 | c | func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
movl $0x7fffffff,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11eb <func0+0x62>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (... | func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_10], 7FFFFFFFh
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11EB
loc_11B3:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add ... | _DWORD * func0(long long a1, int a2, _DWORD *a3)
{
int v3; // eax
int v5; // [rsp+18h] [rbp-10h]
int v6; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 0x7FFFFFFF;
v6 = 0;
for ( i = 0; i < a2; ++i )
{
if ( v5 > *(_DWORD *)(4LL * i + a1) )
v5 = *(_DWORD ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x10],0x7fffffff
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011eb
LAB_001011b3:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV ... | int1 * func0(long param_1,int param_2,int *param_3)
{
int local_18;
int local_14;
int local_10;
int local_c;
local_18 = 0x7fffffff;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if (*(int *)(param_1 + (long)local_10 * 4) < local_18) {
local_18 = *(int *)(par... |
5,181 | func0 |
#include <stdio.h>
#include <assert.h>
#include <limits.h>
| int* func0(int list1[], int size, int *resultSize) {
int min_val = INT_MAX;
static int min_positions[100]; // static buffer to store positions
int count = 0;
// Find minimum value
for (int i = 0; i < size; i++) {
if (list1[i] < min_val) {
min_val = list1[i];
}
... | int main() {
int resultSize;
int* result;
int list1[] = {12,33,23,10,67,89,45,667,23,12,11,10,54};
int list2[] = {1,2,2,2,4,4,4,5,5,5,5};
int list3[] = {2,1,5,6,8,3,4,9,10,11,8,12};
result = func0(list1, sizeof(list1)/sizeof(list1[0]), &resultSize);
assert(resultSize == 2 && result[... | O1 | c | func0:
endbr64
test %esi,%esi
jle 11e4 <func0+0x5b>
mov %rdi,%rax
lea -0x1(%rsi),%r9d
lea 0x4(%rdi,%r9,4),%r8
mov $0x7fffffff,%ecx
mov (%rax),%esi
cmp %esi,%ecx
cmovg %esi,%ecx
add $0x4,%rax
cmp %r8,%rax
jne 11a2 <func0+0x19>
mov $0x0,%eax
mov $0x0,%r8d
lea 0x2e7c(%rip),%r10
jm... | func0:
endbr64
mov r8, rdi
test esi, esi
jle short loc_11E4
mov rax, rdi
lea ecx, [rsi-1]
lea r9, [rdi+rcx*4+4]
mov ecx, 7FFFFFFFh
loc_11A4:
mov edi, [rax]
cmp ecx, edi
cmovg ecx, edi
add rax, 4
cmp rax, r9
jnz short loc_11A4
mov esi, esi
mov eax, 0
mov edi, ... | _DWORD * func0(int *a1, int a2, _DWORD *a3)
{
int *v4; // rax
int v5; // ecx
long long v6; // rax
int v7; // edi
if ( a2 <= 0 )
{
v7 = 0;
}
else
{
v4 = a1;
v5 = 0x7FFFFFFF;
do
{
if ( v5 > *v4 )
v5 = *v4;
++v4;
}
while ( v4 != &a1[a2 - 1 + 1] );
v6 =... | func0:
ENDBR64
MOV R8,RDI
TEST ESI,ESI
JLE 0x001011e4
MOV RAX,RDI
LEA ECX,[RSI + -0x1]
LEA R9,[RDI + RCX*0x4 + 0x4]
MOV ECX,0x7fffffff
LAB_001011a4:
MOV EDI,dword ptr [RAX]
CMP ECX,EDI
CMOVG ECX,EDI
ADD RAX,0x4
CMP RAX,R9
JNZ 0x001011a4
MOV ESI,ESI
MOV EAX,0x0
MOV EDI,0x0
LEA R10,[0x104040]
JMP 0x001011d2
LAB_001011c9:... | int4 * func0(int *param_1,uint param_2,int *param_3)
{
int *piVar1;
ulong uVar2;
int iVar3;
int iVar4;
if ((int)param_2 < 1) {
iVar4 = 0;
}
else {
iVar3 = 0x7fffffff;
piVar1 = param_1;
do {
if (*piVar1 < iVar3) {
iVar3 = *piVar1;
}
piVar1 = piVar1 + 1;
} w... |
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.