index
int64 0
66.5k
| func_name
stringlengths 2
5.36k
| func_dep
stringlengths 16
2.19k
| func
stringlengths 8
55.3k
| test
stringlengths 0
7.07k
| opt
stringclasses 4
values | language
stringclasses 2
values | asm
stringlengths 0
45.4k
| ida_asm
stringlengths 0
44.7k
| ida_pseudo
stringlengths 0
44.3k
| ghidra_asm
stringlengths 0
49.1k
| ghidra_pseudo
stringlengths 0
64.7k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
1,094 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const int[]){}, 0) == true);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
je 1350 <func0+0x10>
jmp 12e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0_part_0:
cmp esi, 1
jle short loc_12F0
lea ecx, [rsi-2]
mov edx, [rdi]
lea rax, [rdi+4]
lea r9, [rdi+rcx*4+8]
xor ecx, ecx
nop dword ptr [rax]
loc_12B8:
mov r8d, edx
mov edx, [rax]
cmp r8d, edx
setnle r8b
add rax, 4
movzx r8d, r8b
add ecx, r8d
cmp rax, r9
jnz short loc_12B8
loc_12D4:
movsxd rsi, esi
mov eax, [rdi]
cmp [rdi+rsi*4-4], eax
setnle al
movzx eax, al
add ecx, eax
cmp ecx, 1
setle al
retn
loc_12F0:
xor ecx, ecx
jmp short loc_12D4
|
bool func0_part_0(int *a1, int a2)
{
int v2; // edx
int *v3; // rax
int v4; // ecx
int v5; // r8d
if ( a2 <= 1 )
{
v4 = 0;
}
else
{
v2 = *a1;
v3 = a1 + 1;
v4 = 0;
do
{
v5 = v2;
v2 = *v3++;
v4 += v5 > v2;
}
while ( v3 != &a1[a2 - 2 + 2] );
}
return (a1[a2 - 1] > *a1) + v4 <= 1;
}
|
func0.part.0:
CMP ESI,0x1
JLE 0x001012f0
LEA ECX,[RSI + -0x2]
MOV EDX,dword ptr [RDI]
LEA RAX,[RDI + 0x4]
LEA R9,[RDI + RCX*0x4 + 0x8]
XOR ECX,ECX
NOP dword ptr [RAX]
LAB_001012b8:
MOV R8D,EDX
MOV EDX,dword ptr [RAX]
CMP R8D,EDX
SETG R8B
ADD RAX,0x4
MOVZX R8D,R8B
ADD ECX,R8D
CMP RAX,R9
JNZ 0x001012b8
LAB_001012d4:
MOVSXD RSI,ESI
MOV EAX,dword ptr [RDI]
CMP dword ptr [RDI + RSI*0x4 + -0x4],EAX
SETG AL
MOVZX EAX,AL
ADD ECX,EAX
CMP ECX,0x1
SETLE AL
RET
LAB_001012f0:
XOR ECX,ECX
JMP 0x001012d4
|
bool func0_part_0(int *param_1,int param_2)
{
int iVar1;
int *piVar2;
int iVar3;
int iVar4;
if (param_2 < 2) {
iVar3 = 0;
}
else {
piVar2 = param_1 + 1;
iVar3 = 0;
iVar4 = *param_1;
do {
iVar1 = *piVar2;
piVar2 = piVar2 + 1;
iVar3 = iVar3 + (uint)(iVar1 < iVar4);
iVar4 = iVar1;
} while (piVar2 != param_1 + (ulong)(param_2 - 2) + 2);
}
return (int)(iVar3 + (uint)(*param_1 < param_1[(long)param_2 + -1])) < 2;
}
|
1,095 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(int *arr, int size) {
int num = 0;
if (size == 0) return true;
for (int i = 1; i < size; i++)
if (arr[i] < arr[i - 1]) num += 1;
if (arr[size - 1] > arr[0]) num += 1;
if (num < 2) return true;
return false;
}
|
#include <assert.h>
#include <stdbool.h>
int main() {
assert(func0((const int[]){3, 4, 5, 1, 2}, 5) == true);
assert(func0((const int[]){3, 5, 10, 1, 2}, 5) == true);
assert(func0((const int[]){4, 3, 1, 2}, 4) == false);
assert(func0((const int[]){3, 5, 4, 1, 2}, 5) == false);
assert(func0((const int[]){}, 0) == true);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov $0x1,%eax
test %esi,%esi
je 15bb <func0+0x17b>
cmp $0x1,%esi
jle 15c8 <func0+0x188>
lea -0x2(%rsi),%eax
lea -0x1(%rsi),%r8d
cmp $0x2,%eax
jbe 15cc <func0+0x18c>
mov %r8d,%edx
mov %rdi,%rax
pxor %xmm1,%xmm1
shr $0x2,%edx
shl $0x4,%rdx
add %rdi,%rdx
xchg %ax,%ax
movdqu (%rax),%xmm0
movdqu 0x4(%rax),%xmm2
add $0x10,%rax
pcmpgtd %xmm2,%xmm0
psubd %xmm0,%xmm1
cmp %rdx,%rax
jne 1480 <func0+0x40>
movdqa %xmm1,%xmm0
mov %r8d,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
lea 0x1(%rdx),%ecx
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
cmp %edx,%r8d
je 15a5 <func0+0x165>
movslq %ecx,%rdx
lea 0x1(%rcx),%r10d
shl $0x2,%rdx
lea (%rdi,%rdx,1),%r9
cmp %r8d,%r10d
jge 15d8 <func0+0x198>
cmp %ecx,%esi
jle 15d8 <func0+0x198>
mov (%r9),%r10d
cmp %r10d,-0x4(%r9)
setg %r9b
movzbl %r9b,%r9d
add %r9d,%eax
mov 0x4(%rdi,%rdx,1),%r9d
xor %edx,%edx
cmp %r9d,%r10d
lea 0x3(%rcx),%r10d
setg %dl
add %edx,%eax
lea 0x2(%rcx),%edx
cmp %r10d,%r8d
jle 1569 <func0+0x129>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r10d
cmp %r10d,%r9d
setg %r9b
movzbl %r9b,%r9d
add %r9d,%eax
mov 0x4(%rdi,%rdx,4),%r9d
xor %edx,%edx
cmp %r9d,%r10d
lea 0x5(%rcx),%r10d
setg %dl
add %edx,%eax
lea 0x4(%rcx),%edx
cmp %r10d,%r8d
jle 1569 <func0+0x129>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
cmp %r9d,%r8d
setl %r9b
movzbl %r9b,%r9d
add %r9d,%eax
cmp 0x4(%rdi,%rdx,4),%r8d
jle 1566 <func0+0x126>
add $0x1,%eax
lea 0x6(%rcx),%edx
movslq %edx,%rcx
mov -0x4(%rdi,%rcx,4),%r11d
cmp %r11d,(%rdi,%rcx,4)
jl 15c0 <func0+0x180>
lea 0x1(%rdx),%ecx
cmp %ecx,%esi
jle 15a5 <func0+0x165>
movslq %ecx,%rcx
mov -0x4(%rdi,%rcx,4),%r11d
cmp %r11d,(%rdi,%rcx,4)
jge 158f <func0+0x14f>
add $0x1,%eax
add $0x2,%edx
cmp %edx,%esi
jle 15a5 <func0+0x165>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%ecx
cmp %ecx,-0x4(%rdi,%rdx,4)
jle 15a5 <func0+0x165>
add $0x1,%eax
movslq %esi,%rsi
xor %edx,%edx
mov (%rdi),%ecx
cmp %ecx,-0x4(%rdi,%rsi,4)
setg %dl
add %edx,%eax
cmp $0x1,%eax
setle %al
retq
nopl 0x0(%rax)
add $0x1,%eax
jmp 1577 <func0+0x137>
nopl (%rax)
xor %eax,%eax
jmp 15a5 <func0+0x165>
xor %eax,%eax
mov $0x1,%ecx
jmpq 14ca <func0+0x8a>
mov %ecx,%edx
jmp 1569 <func0+0x129>
nopl 0x0(%rax)
|
func0_part_0:
mov rdx, rdi
cmp esi, 1
jle loc_1460
lea eax, [rsi-2]
lea edi, [rsi-1]
cmp eax, 2
jbe loc_1467
mov ecx, edi
mov rax, rdx
pxor xmm1, xmm1
shr ecx, 2
shl rcx, 4
add rcx, rdx
xchg ax, ax
loc_12E0:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm2, xmmword ptr [rax+4]
add rax, 10h
pcmpgtd xmm0, xmm2
psubd xmm1, xmm0
cmp rax, rcx
jnz short loc_12E0
movdqa xmm0, xmm1
mov ecx, edi
psrldq xmm0, 8
and ecx, 0FFFFFFFCh
paddd xmm1, xmm0
add ecx, 1
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
test dil, 3
jz loc_13B3
loc_132A:
movsxd r8, ecx
lea r10d, [rcx+1]
lea r9, ds:0[r8*4]
lea r11, [rdx+r9]
cmp r10d, edi
jge short loc_1378
cmp esi, ecx
jle short loc_1378
mov r8d, [r11]
cmp [r11-4], r8d
jle short loc_1352
add eax, 1
loc_1352:
mov r10d, [rdx+r9+4]
cmp r8d, r10d
setnle r8b
movzx r8d, r8b
add eax, r8d
lea r8d, [rcx+3]
cmp edi, r8d
jg short loc_13D0
add ecx, 2
movsxd r8, ecx
lea r10d, [rcx+1]
loc_1378:
mov r9d, [rdx+r8*4]
lea rdi, ds:0[r8*4]
cmp r9d, [rdx+r8*4-4]
jl loc_1430
loc_138F:
cmp esi, r10d
jle short loc_13B3
cmp r9d, [rdx+rdi+4]
jg loc_1440
loc_139F:
add ecx, 2
cmp esi, ecx
jle short loc_13B3
mov ecx, [rdx+rdi+8]
cmp [rdx+rdi+4], ecx
jle short loc_13B3
add eax, 1
loc_13B3:
movsxd rsi, esi
mov edi, [rdx]
cmp [rdx+rsi*4-4], edi
setnle dl
movzx edx, dl
add eax, edx
cmp eax, 1
setle al
retn
loc_13D0:
mov r8d, [rdx+r9+8]
cmp r10d, r8d
setnle r10b
movzx r10d, r10b
add eax, r10d
mov r10d, [rdx+r9+0Ch]
cmp r8d, r10d
setnle r8b
movzx r8d, r8b
add eax, r8d
lea r8d, [rcx+5]
cmp edi, r8d
jle short loc_1450
mov edi, [rdx+r9+10h]
xor r8d, r8d
cmp edi, r10d
setl r8b
add eax, r8d
cmp [rdx+r9+14h], edi
jge short loc_141B
add eax, 1
loc_141B:
add ecx, 6
movsxd r8, ecx
lea r10d, [rcx+1]
jmp loc_1378
loc_1430:
add eax, 1
jmp loc_138F
loc_1440:
add eax, 1
jmp loc_139F
loc_1450:
add ecx, 4
movsxd r8, ecx
lea r10d, [rcx+1]
jmp loc_1378
loc_1460:
xor eax, eax
jmp loc_13B3
loc_1467:
xor eax, eax
mov ecx, 1
jmp loc_132A
|
bool func0_part_0(_DWORD *a1, int a2)
{
int v3; // edi
_DWORD *v4; // rax
__m128i v5; // xmm1
__m128i v6; // xmm0
__m128i v7; // xmm2
__m128i v8; // xmm1
signed int v9; // ecx
int v10; // eax
long long v11; // r8
int v12; // r10d
long long v13; // r9
_DWORD *v14; // r11
int v15; // r10d
int v16; // r9d
long long v17; // rdi
int v19; // r8d
int v20; // eax
int v21; // r10d
int v22; // edi
if ( a2 <= 1 )
{
v10 = 0;
return (a1[a2 - 1] > *a1) + v10 <= 1;
}
v3 = a2 - 1;
if ( (unsigned int)(a2 - 2) <= 2 )
{
v10 = 0;
v9 = 1;
}
else
{
v4 = a1;
v5 = 0LL;
do
{
v6 = _mm_loadu_si128((const __m128i *)v4);
v7 = _mm_loadu_si128((const __m128i *)(v4 + 1));
v4 += 4;
v5 = _mm_sub_epi32(v5, _mm_cmpgt_epi32(v6, v7));
}
while ( v4 != &a1[4 * ((unsigned int)v3 >> 2)] );
v8 = _mm_add_epi32(v5, _mm_srli_si128(v5, 8));
v9 = (v3 & 0xFFFFFFFC) + 1;
v10 = _mm_cvtsi128_si32(_mm_add_epi32(v8, _mm_srli_si128(v8, 4)));
if ( (v3 & 3) == 0 )
return (a1[a2 - 1] > *a1) + v10 <= 1;
}
v11 = v9;
v12 = v9 + 1;
v13 = v9;
v14 = &a1[v13];
if ( v9 + 1 < v3 && a2 > v9 )
{
if ( *(v14 - 1) > *v14 )
++v10;
v15 = a1[v13 + 1];
v10 += *v14 > v15;
if ( v3 > v9 + 3 )
{
v19 = a1[v13 + 2];
v20 = (v15 > v19) + v10;
v21 = a1[v13 + 3];
v10 = (v19 > v21) + v20;
if ( v3 <= v9 + 5 )
{
v9 += 4;
v11 = v9;
v12 = v9 + 1;
}
else
{
v22 = a1[v13 + 4];
v10 += v22 < v21;
if ( a1[v13 + 5] < v22 )
++v10;
v9 += 6;
v11 = v9;
v12 = v9 + 1;
}
}
else
{
v9 += 2;
v11 = v9;
v12 = v9 + 1;
}
}
v16 = a1[v11];
v17 = v11;
if ( v16 < a1[v11 - 1] )
++v10;
if ( a2 > v12 )
{
if ( v16 > a1[v17 + 1] )
++v10;
if ( a2 > v9 + 2 && a1[v17 + 1] > a1[v17 + 2] )
++v10;
}
return (a1[a2 - 1] > *a1) + v10 <= 1;
}
|
func0.part.0:
MOV RDX,RDI
CMP ESI,0x1
JLE 0x00101460
LEA EAX,[RSI + -0x2]
LEA EDI,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101467
MOV ECX,EDI
MOV RAX,RDX
PXOR XMM1,XMM1
SHR ECX,0x2
SHL RCX,0x4
ADD RCX,RDX
NOP
LAB_001012e0:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM2,xmmword ptr [RAX + 0x4]
ADD RAX,0x10
PCMPGTD XMM0,XMM2
PSUBD XMM1,XMM0
CMP RAX,RCX
JNZ 0x001012e0
MOVDQA XMM0,XMM1
MOV ECX,EDI
PSRLDQ XMM0,0x8
AND ECX,0xfffffffc
PADDD XMM1,XMM0
ADD ECX,0x1
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
TEST DIL,0x3
JZ 0x001013b3
LAB_0010132a:
MOVSXD R8,ECX
LEA R10D,[RCX + 0x1]
LEA R9,[R8*0x4]
LEA R11,[RDX + R9*0x1]
CMP R10D,EDI
JGE 0x00101378
CMP ESI,ECX
JLE 0x00101378
MOV R8D,dword ptr [R11]
CMP dword ptr [R11 + -0x4],R8D
JLE 0x00101352
ADD EAX,0x1
LAB_00101352:
MOV R10D,dword ptr [RDX + R9*0x1 + 0x4]
CMP R8D,R10D
SETG R8B
MOVZX R8D,R8B
ADD EAX,R8D
LEA R8D,[RCX + 0x3]
CMP EDI,R8D
JG 0x001013d0
ADD ECX,0x2
MOVSXD R8,ECX
LEA R10D,[RCX + 0x1]
LAB_00101378:
MOV R9D,dword ptr [RDX + R8*0x4]
LEA RDI,[R8*0x4]
CMP R9D,dword ptr [RDX + R8*0x4 + -0x4]
JL 0x00101430
LAB_0010138f:
CMP ESI,R10D
JLE 0x001013b3
CMP R9D,dword ptr [RDX + RDI*0x1 + 0x4]
JG 0x00101440
LAB_0010139f:
ADD ECX,0x2
CMP ESI,ECX
JLE 0x001013b3
MOV ECX,dword ptr [RDX + RDI*0x1 + 0x8]
CMP dword ptr [RDX + RDI*0x1 + 0x4],ECX
JLE 0x001013b3
ADD EAX,0x1
LAB_001013b3:
MOVSXD RSI,ESI
MOV EDI,dword ptr [RDX]
CMP dword ptr [RDX + RSI*0x4 + -0x4],EDI
SETG DL
MOVZX EDX,DL
ADD EAX,EDX
CMP EAX,0x1
SETLE AL
RET
LAB_001013d0:
MOV R8D,dword ptr [RDX + R9*0x1 + 0x8]
CMP R10D,R8D
SETG R10B
MOVZX R10D,R10B
ADD EAX,R10D
MOV R10D,dword ptr [RDX + R9*0x1 + 0xc]
CMP R8D,R10D
SETG R8B
MOVZX R8D,R8B
ADD EAX,R8D
LEA R8D,[RCX + 0x5]
CMP EDI,R8D
JLE 0x00101450
MOV EDI,dword ptr [RDX + R9*0x1 + 0x10]
XOR R8D,R8D
CMP EDI,R10D
SETL R8B
ADD EAX,R8D
CMP dword ptr [RDX + R9*0x1 + 0x14],EDI
JGE 0x0010141b
ADD EAX,0x1
LAB_0010141b:
ADD ECX,0x6
MOVSXD R8,ECX
LEA R10D,[RCX + 0x1]
JMP 0x00101378
LAB_00101430:
ADD EAX,0x1
JMP 0x0010138f
LAB_00101440:
ADD EAX,0x1
JMP 0x0010139f
LAB_00101450:
ADD ECX,0x4
MOVSXD R8,ECX
LEA R10D,[RCX + 0x1]
JMP 0x00101378
LAB_00101460:
XOR EAX,EAX
JMP 0x001013b3
LAB_00101467:
XOR EAX,EAX
MOV ECX,0x1
JMP 0x0010132a
|
int4 func0_part_0(int *param_1,int param_2)
{
uint uVar1;
int *piVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
int *piVar8;
int *piVar9;
int iVar10;
long lVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
if (param_2 < 2) {
iVar12 = 0;
}
else {
uVar1 = param_2 - 1;
if (param_2 - 2U < 3) {
iVar12 = 0;
iVar10 = 1;
}
else {
iVar12 = 0;
iVar13 = 0;
iVar14 = 0;
iVar15 = 0;
piVar9 = param_1;
do {
iVar10 = *piVar9;
piVar3 = piVar9 + 1;
piVar4 = piVar9 + 2;
piVar5 = piVar9 + 3;
piVar2 = piVar9 + 1;
piVar6 = piVar9 + 2;
piVar7 = piVar9 + 3;
piVar8 = piVar9 + 4;
piVar9 = piVar9 + 4;
iVar12 = iVar12 + (uint)(*piVar2 < iVar10);
iVar13 = iVar13 + (uint)(*piVar6 < *piVar3);
iVar14 = iVar14 + (uint)(*piVar7 < *piVar4);
iVar15 = iVar15 + (uint)(*piVar8 < *piVar5);
} while (piVar9 != param_1 + (ulong)(uVar1 >> 2) * 4);
iVar10 = (uVar1 & 0xfffffffc) + 1;
iVar12 = iVar12 + iVar14 + iVar13 + iVar15;
if ((uVar1 & 3) == 0) goto LAB_001013b3;
}
lVar11 = (long)iVar10;
iVar13 = iVar10 + 1;
iVar14 = iVar10;
if ((iVar13 < (int)uVar1) && (iVar10 < param_2)) {
iVar13 = param_1[lVar11];
if (iVar13 < (param_1 + lVar11)[-1]) {
iVar12 = iVar12 + 1;
}
iVar12 = iVar12 + (uint)(param_1[lVar11 + 1] < iVar13);
if (iVar10 + 3 < (int)uVar1) {
iVar12 = iVar12 + (uint)(param_1[lVar11 + 2] < param_1[lVar11 + 1]) +
(uint)(param_1[lVar11 + 3] < param_1[lVar11 + 2]);
if (iVar10 + 5 < (int)uVar1) {
iVar12 = iVar12 + (uint)(param_1[lVar11 + 4] < param_1[lVar11 + 3]);
if (param_1[lVar11 + 5] < param_1[lVar11 + 4]) {
iVar12 = iVar12 + 1;
}
iVar14 = iVar10 + 6;
lVar11 = (long)iVar14;
iVar13 = iVar10 + 7;
}
else {
iVar14 = iVar10 + 4;
lVar11 = (long)iVar14;
iVar13 = iVar10 + 5;
}
}
else {
iVar14 = iVar10 + 2;
lVar11 = (long)iVar14;
iVar13 = iVar10 + 3;
}
}
if (param_1[lVar11] < param_1[lVar11 + -1]) {
iVar12 = iVar12 + 1;
}
if (iVar13 < param_2) {
if (param_1[lVar11 + 1] < param_1[lVar11]) {
iVar12 = iVar12 + 1;
}
if ((iVar14 + 2 < param_2) && (param_1[lVar11 + 2] < param_1[lVar11 + 1])) {
iVar12 = iVar12 + 1;
}
}
}
LAB_001013b3:
iVar12 = iVar12 + (uint)(*param_1 < param_1[(long)param_2 + -1]);
return CONCAT31((int3)((uint)iVar12 >> 8),iVar12 < 2);
}
|
1,096 |
func0
|
#include <stdio.h>
|
const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2, 1, 4, 3}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 4}, 3), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 3}, 3), "NO") == 0);
assert(strcmp(func0((const int[]){3, 2, 6, 1, 8, 9}, 6, (const int[]){3, 5, 5, 1, 1, 1}, 6), "NO") == 0);
assert(strcmp(func0((const int[]){100, 200}, 2, (const int[]){200, 200}, 2), "YES") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %rdx,-0x28(%rbp)
mov %ecx,-0x20(%rbp)
movl $0x0,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d4 <func0+0x4b>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 11d0 <func0+0x47>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11af <func0+0x26>
movl $0x0,-0x4(%rbp)
jmp 120a <func0+0x81>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
and $0x1,%eax
test %eax,%eax
jne 1206 <func0+0x7d>
addl $0x1,-0xc(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11e5 <func0+0x5c>
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1223 <func0+0x9a>
lea 0xde7(%rip),%rax
jmp 122a <func0+0xa1>
lea 0xde2(%rip),%rax
pop %rbp
retq
|
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_20], ecx
mov [rbp+var_C], 0
mov [rbp+var_8], 0
jmp short loc_11D4
loc_11AF:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_11D0
add [rbp+var_C], 1
loc_11D0:
add [rbp+var_8], 1
loc_11D4:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_1C]
jl short loc_11AF
mov [rbp+var_4], 0
jmp short loc_120A
loc_11E5:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
and eax, 1
test eax, eax
jnz short loc_1206
add [rbp+var_C], 1
loc_1206:
add [rbp+var_4], 1
loc_120A:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_11E5
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_1223
lea rax, s2; "YES"
jmp short loc_122A
loc_1223:
lea rax, aNo; "NO"
loc_122A:
pop rbp
retn
|
const char * func0(long long a1, int a2, long long a3, int a4)
{
int v5; // [rsp+1Ch] [rbp-Ch]
int i; // [rsp+20h] [rbp-8h]
int j; // [rsp+24h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
if ( (*(_DWORD *)(4LL * i + a1) & 1) == 0 )
++v5;
}
for ( j = 0; j < a4; ++j )
{
if ( (*(_DWORD *)(4LL * j + a3) & 1) == 0 )
++v5;
}
if ( v5 < a2 )
return "NO";
else
return "YES";
}
|
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 + -0x20],ECX
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d4
LAB_001011af:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x001011d0
ADD dword ptr [RBP + -0xc],0x1
LAB_001011d0:
ADD dword ptr [RBP + -0x8],0x1
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011af
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010120a
LAB_001011e5:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101206
ADD dword ptr [RBP + -0xc],0x1
LAB_00101206:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010120a:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011e5
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101223
LEA RAX,[0x102008]
JMP 0x0010122a
LAB_00101223:
LEA RAX,[0x10200c]
LAB_0010122a:
POP RBP
RET
|
int * func0(long param_1,int param_2,long param_3,int param_4)
{
int *puVar1;
int local_14;
int local_10;
int local_c;
local_14 = 0;
for (local_10 = 0; local_10 < param_2; local_10 = local_10 + 1) {
if ((*(uint *)(param_1 + (long)local_10 * 4) & 1) == 0) {
local_14 = local_14 + 1;
}
}
for (local_c = 0; local_c < param_4; local_c = local_c + 1) {
if ((*(uint *)(param_3 + (long)local_c * 4) & 1) == 0) {
local_14 = local_14 + 1;
}
}
if (local_14 < param_2) {
puVar1 = &DAT_0010200c;
}
else {
puVar1 = &DAT_00102008;
}
return puVar1;
}
|
1,097 |
func0
|
#include <stdio.h>
|
const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2, 1, 4, 3}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 4}, 3), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 3}, 3), "NO") == 0);
assert(strcmp(func0((const int[]){3, 2, 6, 1, 8, 9}, 6, (const int[]){3, 5, 5, 1, 1, 1}, 6), "NO") == 0);
assert(strcmp(func0((const int[]){100, 200}, 2, (const int[]){200, 200}, 2), "YES") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11cb <func0+0x62>
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x0,%eax
mov (%r8),%edi
and $0x1,%edi
cmp $0x1,%edi
adc $0x0,%eax
add $0x4,%r8
cmp %r9,%r8
jne 1181 <func0+0x18>
test %ecx,%ecx
jle 11b6 <func0+0x4d>
mov $0x0,%edi
mov (%rdx,%rdi,4),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
adc $0x0,%eax
add $0x1,%rdi
cmp %edi,%ecx
jg 119f <func0+0x36>
cmp %eax,%esi
lea 0xe49(%rip),%rax
lea 0xe3e(%rip),%rdx
cmovle %rdx,%rax
retq
mov $0x0,%eax
test %ecx,%ecx
jg 119a <func0+0x31>
lea 0xe29(%rip),%rax
retq
|
func0:
endbr64
test esi, esi
jle short loc_11EA
mov r8, rdi
movsxd rax, esi
lea r9, [rdi+rax*4]
mov eax, 0
loc_11A0:
mov edi, [r8]
and edi, 1
cmp edi, 1
adc eax, 0
add r8, 4
cmp r8, r9
jnz short loc_11A0
test ecx, ecx
jle short loc_11D5
loc_11B9:
mov edi, 0
loc_11BE:
mov r8d, [rdx+rdi*4]
and r8d, 1
cmp r8d, 1
adc eax, 0
add rdi, 1
cmp ecx, edi
jg short loc_11BE
loc_11D5:
cmp esi, eax
lea rax, s2; "YES"
lea rdx, aNo; "NO"
cmovg rax, rdx
retn
loc_11EA:
mov eax, 0
test ecx, ecx
jg short loc_11B9
lea rax, s2; "YES"
retn
|
const char * func0(_DWORD *a1, int a2, long long a3, int a4)
{
_DWORD *v4; // r8
int v5; // eax
long long v6; // rdi
bool v7; // cc
const char *result; // rax
if ( a2 <= 0 )
{
v5 = 0;
if ( a4 <= 0 )
return "YES";
}
else
{
v4 = a1;
v5 = 0;
do
v5 += (*v4++ & 1) == 0;
while ( v4 != &a1[a2] );
if ( a4 <= 0 )
goto LABEL_7;
}
v6 = 0LL;
do
v5 += (*(_DWORD *)(a3 + 4 * v6++) & 1) == 0;
while ( a4 > (int)v6 );
LABEL_7:
v7 = a2 <= v5;
result = "YES";
if ( !v7 )
return "NO";
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011ea
MOV R8,RDI
MOVSXD RAX,ESI
LEA R9,[RDI + RAX*0x4]
MOV EAX,0x0
LAB_001011a0:
MOV EDI,dword ptr [R8]
AND EDI,0x1
CMP EDI,0x1
ADC EAX,0x0
ADD R8,0x4
CMP R8,R9
JNZ 0x001011a0
TEST ECX,ECX
JLE 0x001011d5
LAB_001011b9:
MOV EDI,0x0
LAB_001011be:
MOV R8D,dword ptr [RDX + RDI*0x4]
AND R8D,0x1
CMP R8D,0x1
ADC EAX,0x0
ADD RDI,0x1
CMP ECX,EDI
JG 0x001011be
LAB_001011d5:
CMP ESI,EAX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVG RAX,RDX
RET
LAB_001011ea:
MOV EAX,0x0
TEST ECX,ECX
JG 0x001011b9
LEA RAX,[0x102004]
RET
|
int * func0(uint *param_1,int param_2,long param_3,int param_4)
{
uint *puVar1;
int iVar2;
int *puVar3;
long lVar4;
if (param_2 < 1) {
iVar2 = 0;
if (param_4 < 1) {
return &DAT_00102004;
}
}
else {
puVar1 = param_1 + param_2;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
if (param_4 < 1) goto LAB_001011d5;
}
lVar4 = 0;
do {
iVar2 = iVar2 + (uint)((*(uint *)(param_3 + lVar4 * 4) & 1) == 0);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_4);
LAB_001011d5:
puVar3 = &DAT_00102004;
if (iVar2 < param_2) {
puVar3 = &DAT_00102008;
}
return puVar3;
}
|
1,098 |
func0
|
#include <stdio.h>
|
const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2, 1, 4, 3}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 4}, 3), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 3}, 3), "NO") == 0);
assert(strcmp(func0((const int[]){3, 2, 6, 1, 8, 9}, 6, (const int[]){3, 5, 5, 1, 1, 1}, 6), "NO") == 0);
assert(strcmp(func0((const int[]){100, 200}, 2, (const int[]){200, 200}, 2), "YES") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1518 <func0+0x68>
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rdi),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
adc $0x0,%eax
add $0x4,%rdi
cmp %r9,%rdi
jne 14c8 <func0+0x18>
test %ecx,%ecx
jle 14ff <func0+0x4f>
xor %edi,%edi
nopl (%rax)
mov (%rdx,%rdi,4),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
adc $0x0,%eax
add $0x1,%rdi
cmp %edi,%ecx
jg 14e8 <func0+0x38>
cmp %eax,%esi
lea 0xafc(%rip),%rdx
lea 0xaf8(%rip),%rax
cmovg %rdx,%rax
retq
nopl 0x0(%rax)
xor %eax,%eax
test %ecx,%ecx
jg 14e3 <func0+0x33>
lea 0xae2(%rip),%rax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_14D8
movsxd rax, esi
lea r9, [rdi+rax*4]
xor eax, eax
nop dword ptr [rax+00000000h]
loc_1488:
mov r8d, [rdi]
and r8d, 1
cmp r8d, 1
adc eax, 0
add rdi, 4
cmp rdi, r9
jnz short loc_1488
test ecx, ecx
jle short loc_14BF
loc_14A3:
xor edi, edi
nop dword ptr [rax]
loc_14A8:
mov r8d, [rdx+rdi*4]
and r8d, 1
cmp r8d, 1
adc eax, 0
add rdi, 1
cmp ecx, edi
jg short loc_14A8
loc_14BF:
cmp esi, eax
lea rdx, aNo; "NO"
lea rax, s2; "YES"
cmovg rax, rdx
retn
loc_14D8:
xor eax, eax
test ecx, ecx
jg short loc_14A3
lea rax, s2; "YES"
retn
|
const char * func0(_DWORD *a1, int a2, long long a3, int a4)
{
_DWORD *v4; // r9
int v5; // eax
long long v6; // rdi
bool v7; // cc
const char *result; // rax
if ( a2 <= 0 )
{
v5 = 0;
if ( a4 <= 0 )
return "YES";
}
else
{
v4 = &a1[a2];
v5 = 0;
do
v5 += (*a1++ & 1) == 0;
while ( a1 != v4 );
if ( a4 <= 0 )
goto LABEL_7;
}
v6 = 0LL;
do
v5 += (*(_DWORD *)(a3 + 4 * v6++) & 1) == 0;
while ( a4 > (int)v6 );
LABEL_7:
v7 = a2 <= v5;
result = "YES";
if ( !v7 )
return "NO";
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001014d8
MOVSXD RAX,ESI
LEA R9,[RDI + RAX*0x4]
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101488:
MOV R8D,dword ptr [RDI]
AND R8D,0x1
CMP R8D,0x1
ADC EAX,0x0
ADD RDI,0x4
CMP RDI,R9
JNZ 0x00101488
TEST ECX,ECX
JLE 0x001014bf
LAB_001014a3:
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_001014a8:
MOV R8D,dword ptr [RDX + RDI*0x4]
AND R8D,0x1
CMP R8D,0x1
ADC EAX,0x0
ADD RDI,0x1
CMP ECX,EDI
JG 0x001014a8
LAB_001014bf:
CMP ESI,EAX
LEA RDX,[0x102008]
LEA RAX,[0x102004]
CMOVG RAX,RDX
RET
LAB_001014d8:
XOR EAX,EAX
TEST ECX,ECX
JG 0x001014a3
LEA RAX,[0x102004]
RET
|
int * func0(uint *param_1,int param_2,long param_3,int param_4)
{
uint *puVar1;
int iVar2;
int *puVar3;
long lVar4;
if (param_2 < 1) {
iVar2 = 0;
if (param_4 < 1) {
return &DAT_00102004;
}
}
else {
puVar1 = param_1 + param_2;
iVar2 = 0;
do {
iVar2 = iVar2 + (uint)((*param_1 & 1) == 0);
param_1 = param_1 + 1;
} while (param_1 != puVar1);
if (param_4 < 1) goto LAB_001014bf;
}
lVar4 = 0;
do {
iVar2 = iVar2 + (uint)((*(uint *)(param_3 + lVar4 * 4) & 1) == 0);
lVar4 = lVar4 + 1;
} while ((int)lVar4 < param_4);
LAB_001014bf:
puVar3 = &DAT_00102004;
if (iVar2 < param_2) {
puVar3 = &DAT_00102008;
}
return puVar3;
}
|
1,099 |
func0
|
#include <stdio.h>
|
const char* func0(int *lst1, int size1, int *lst2, int size2) {
int num = 0;
for (int i = 0; i < size1; i++)
if (lst1[i] % 2 == 0) num += 1;
for (int i = 0; i < size2; i++)
if (lst2[i] % 2 == 0) num += 1;
if (num >= size1) return "YES";
return "NO";
}
|
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 2, 3, 4}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){1, 5, 3, 4}, 4), "NO") == 0);
assert(strcmp(func0((const int[]){1, 2, 3, 4}, 4, (const int[]){2, 1, 4, 3}, 4), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 4}, 3), "YES") == 0);
assert(strcmp(func0((const int[]){5, 7, 3}, 3, (const int[]){2, 6, 3}, 3), "NO") == 0);
assert(strcmp(func0((const int[]){3, 2, 6, 1, 8, 9}, 6, (const int[]){3, 5, 5, 1, 1, 1}, 6), "NO") == 0);
assert(strcmp(func0((const int[]){100, 200}, 2, (const int[]){200, 200}, 2), "YES") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1650 <func0+0x1e0>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1662 <func0+0x1f2>
mov %esi,%r8d
pxor %xmm1,%xmm1
movdqa 0xe29(%rip),%xmm2
mov %rdi,%rax
shr $0x2,%r8d
movdqa %xmm1,%xmm3
shl $0x4,%r8
add %rdi,%r8
nopl 0x0(%rax)
movdqu (%rax),%xmm0
add $0x10,%rax
pand %xmm2,%xmm0
pcmpeqd %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %r8,%rax
jne 14b0 <func0+0x40>
movdqa %xmm1,%xmm0
mov %esi,%r8d
psrldq $0x8,%xmm0
and $0xfffffffc,%r8d
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1555 <func0+0xe5>
movslq %r8d,%r9
mov (%rdi,%r9,4),%r9d
and $0x1,%r9d
cmp $0x1,%r9d
lea 0x1(%r8),%r9d
adc $0x0,%eax
cmp %esi,%r9d
jge 1555 <func0+0xe5>
movslq %r9d,%r9
mov (%rdi,%r9,4),%r9d
and $0x1,%r9d
cmp $0x1,%r9d
lea 0x2(%r8),%r9d
adc $0x0,%eax
cmp %r9d,%esi
jle 1555 <func0+0xe5>
movslq %r9d,%r9
mov (%rdi,%r9,4),%r9d
and $0x1,%r9d
cmp $0x1,%r9d
adc $0x0,%eax
add $0x3,%r8d
cmp %r8d,%esi
jle 1555 <func0+0xe5>
movslq %r8d,%r8
mov (%rdi,%r8,4),%edi
and $0x1,%edi
cmp $0x1,%edi
adc $0x0,%eax
test %ecx,%ecx
jle 163b <func0+0x1cb>
test %ecx,%ecx
mov $0x1,%r9d
cmovg %ecx,%r9d
cmp $0x4,%ecx
jle 166c <func0+0x1fc>
mov %r9d,%r8d
pxor %xmm1,%xmm1
movdqa 0xd3f(%rip),%xmm2
mov %rdx,%rdi
shr $0x2,%r8d
movdqa %xmm1,%xmm3
shl $0x4,%r8
add %rdx,%r8
nopl 0x0(%rax,%rax,1)
movdqu (%rdi),%xmm0
add $0x10,%rdi
pand %xmm2,%xmm0
pcmpeqd %xmm3,%xmm0
psubd %xmm0,%xmm1
cmp %r8,%rdi
jne 1598 <func0+0x128>
movdqa %xmm1,%xmm0
psrldq $0x8,%xmm0
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%edi
add %edi,%eax
mov %r9d,%edi
and $0xfffffffc,%edi
and $0x3,%r9d
je 163b <func0+0x1cb>
movslq %edi,%r8
mov (%rdx,%r8,4),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
lea 0x1(%rdi),%r8d
adc $0x0,%eax
cmp %r8d,%ecx
jle 163b <func0+0x1cb>
movslq %r8d,%r8
mov (%rdx,%r8,4),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
lea 0x2(%rdi),%r8d
adc $0x0,%eax
cmp %r8d,%ecx
jle 163b <func0+0x1cb>
movslq %r8d,%r8
mov (%rdx,%r8,4),%r8d
and $0x1,%r8d
cmp $0x1,%r8d
adc $0x0,%eax
add $0x3,%edi
cmp %edi,%ecx
jle 163b <func0+0x1cb>
movslq %edi,%rdi
mov (%rdx,%rdi,4),%edx
and $0x1,%edx
cmp $0x1,%edx
adc $0x0,%eax
cmp %eax,%esi
lea 0x9c0(%rip),%rdx
lea 0x9bc(%rip),%rax
cmovg %rdx,%rax
retq
xor %eax,%eax
test %ecx,%ecx
jg 155d <func0+0xed>
lea 0x9a6(%rip),%rax
retq
xor %r8d,%r8d
xor %eax,%eax
jmpq 14f4 <func0+0x84>
xor %edi,%edi
jmpq 15dd <func0+0x16d>
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
|
func0:
endbr64
mov r9, rdi
mov r8d, ecx
mov rdi, rdx
test esi, esi
jle loc_1610
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1622
mov edx, esi
pxor xmm1, xmm1
movdqa xmm2, cs:xmmword_22A0
mov rax, r9
shr edx, 2
movdqa xmm3, xmm1
shl rdx, 4
add rdx, r9
loc_14B0:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pand xmm0, xmm2
pcmpeqd xmm0, xmm3
psubd xmm1, xmm0
cmp rax, rdx
jnz short loc_14B0
movdqa xmm0, xmm1
mov eax, esi
psrldq xmm0, 8
and eax, 0FFFFFFFCh
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd edx, xmm1
test sil, 3
jz short loc_1534
loc_14F2:
movsxd rcx, eax
lea r10, ds:0[rcx*4]
mov ecx, [r9+rcx*4]
and ecx, 1
cmp ecx, 1
lea ecx, [rax+1]
adc edx, 0
cmp esi, ecx
jle short loc_1534
mov ecx, [r9+r10+4]
and ecx, 1
cmp ecx, 1
adc edx, 0
add eax, 2
cmp esi, eax
jle short loc_1534
mov eax, [r9+r10+8]
and eax, 1
cmp eax, 1
adc edx, 0
loc_1534:
test r8d, r8d
jle loc_15F8
loc_153D:
cmp r8d, 3
jle loc_162B
mov ecx, r8d
pxor xmm1, xmm1
movdqa xmm2, cs:xmmword_22A0
mov rax, rdi
shr ecx, 2
movdqa xmm3, xmm1
shl rcx, 4
add rcx, rdi
nop word ptr [rax+rax+00000000h]
loc_1570:
movdqu xmm0, xmmword ptr [rax]
add rax, 10h
pand xmm0, xmm2
pcmpeqd xmm0, xmm3
psubd xmm1, xmm0
cmp rax, rcx
jnz short loc_1570
movdqa xmm0, xmm1
psrldq xmm0, 8
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
add edx, eax
mov eax, r8d
and eax, 0FFFFFFFCh
test r8b, 3
jz short loc_15F8
loc_15B5:
movsxd rcx, eax
lea r9, ds:0[rcx*4]
mov ecx, [rdi+rcx*4]
and ecx, 1
cmp ecx, 1
lea ecx, [rax+1]
adc edx, 0
cmp r8d, ecx
jle short loc_15F8
mov ecx, [rdi+r9+4]
and ecx, 1
cmp ecx, 1
adc edx, 0
add eax, 2
cmp eax, r8d
jge short loc_15F8
mov eax, [rdi+r9+8]
and eax, 1
cmp eax, 1
adc edx, 0
loc_15F8:
cmp esi, edx
lea rax, s2; "YES"
lea rdx, aNo; "NO"
cmovg rax, rdx
retn
loc_1610:
xor edx, edx
test ecx, ecx
jg loc_153D
lea rax, s2; "YES"
retn
loc_1622:
xor eax, eax
xor edx, edx
jmp loc_14F2
loc_162B:
xor eax, eax
jmp short loc_15B5
|
const char * func0(const __m128i *a1, int a2, const __m128i *a3, int a4)
{
__m128i v6; // xmm1
__m128i si128; // xmm2
const __m128i *v8; // rax
__m128i v9; // xmm0
int v10; // eax
__m128i v11; // xmm1
int v12; // edx
long long v13; // r10
__m128i v14; // xmm1
__m128i v15; // xmm2
const __m128i *v16; // rax
__m128i v17; // xmm0
__m128i v18; // xmm1
signed int v19; // eax
long long v20; // r9
const char *result; // rax
if ( a2 > 0 )
{
if ( (unsigned int)(a2 - 1) <= 2 )
{
v10 = 0;
v12 = 0;
}
else
{
v6 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_22A0);
v8 = a1;
do
{
v9 = _mm_loadu_si128(v8++);
v6 = _mm_sub_epi32(v6, _mm_cmpeq_epi32(_mm_and_si128(v9, si128), (__m128i)0LL));
}
while ( v8 != &a1[(unsigned int)a2 >> 2] );
v10 = a2 & 0x7FFFFFFC;
v11 = _mm_add_epi32(v6, _mm_srli_si128(v6, 8));
v12 = _mm_cvtsi128_si32(_mm_add_epi32(v11, _mm_srli_si128(v11, 4)));
if ( (a2 & 3) == 0 )
goto LABEL_9;
}
v13 = v10;
v12 += (a1->m128i_i32[v13] & 1) == 0;
if ( a2 > v10 + 1 )
{
v12 += (a1->m128i_i32[v13 + 1] & 1) == 0;
if ( a2 > v10 + 2 )
v12 += (a1->m128i_i32[v13 + 2] & 1) == 0;
}
LABEL_9:
if ( a4 <= 0 )
goto LABEL_17;
goto LABEL_10;
}
v12 = 0;
if ( a4 <= 0 )
return "YES";
LABEL_10:
if ( a4 <= 3 )
{
v19 = 0;
goto LABEL_14;
}
v14 = 0LL;
v15 = _mm_load_si128((const __m128i *)&xmmword_22A0);
v16 = a3;
do
{
v17 = _mm_loadu_si128(v16++);
v14 = _mm_sub_epi32(v14, _mm_cmpeq_epi32(_mm_and_si128(v17, v15), (__m128i)0LL));
}
while ( v16 != &a3[(unsigned int)a4 >> 2] );
v18 = _mm_add_epi32(v14, _mm_srli_si128(v14, 8));
v12 += _mm_cvtsi128_si32(_mm_add_epi32(v18, _mm_srli_si128(v18, 4)));
v19 = a4 & 0xFFFFFFFC;
if ( (a4 & 3) != 0 )
{
LABEL_14:
v20 = v19;
v12 += (a3->m128i_i32[v20] & 1) == 0;
if ( a4 > v19 + 1 )
{
v12 += (a3->m128i_i32[v20 + 1] & 1) == 0;
if ( v19 + 2 < a4 )
v12 += (a3->m128i_i32[v20 + 2] & 1) == 0;
}
}
LABEL_17:
result = "YES";
if ( a2 > v12 )
return "NO";
return result;
}
|
func0:
ENDBR64
MOV R9,RDI
MOV R8D,ECX
MOV RDI,RDX
TEST ESI,ESI
JLE 0x00101610
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101622
MOV EDX,ESI
PXOR XMM1,XMM1
MOVDQA XMM2,xmmword ptr [0x001022a0]
MOV RAX,R9
SHR EDX,0x2
MOVDQA XMM3,XMM1
SHL RDX,0x4
ADD RDX,R9
LAB_001014b0:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,XMM2
PCMPEQD XMM0,XMM3
PSUBD XMM1,XMM0
CMP RAX,RDX
JNZ 0x001014b0
MOVDQA XMM0,XMM1
MOV EAX,ESI
PSRLDQ XMM0,0x8
AND EAX,0xfffffffc
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EDX,XMM1
TEST SIL,0x3
JZ 0x00101534
LAB_001014f2:
MOVSXD RCX,EAX
LEA R10,[RCX*0x4]
MOV ECX,dword ptr [R9 + RCX*0x4]
AND ECX,0x1
CMP ECX,0x1
LEA ECX,[RAX + 0x1]
ADC EDX,0x0
CMP ESI,ECX
JLE 0x00101534
MOV ECX,dword ptr [R9 + R10*0x1 + 0x4]
AND ECX,0x1
CMP ECX,0x1
ADC EDX,0x0
ADD EAX,0x2
CMP ESI,EAX
JLE 0x00101534
MOV EAX,dword ptr [R9 + R10*0x1 + 0x8]
AND EAX,0x1
CMP EAX,0x1
ADC EDX,0x0
LAB_00101534:
TEST R8D,R8D
JLE 0x001015f8
LAB_0010153d:
CMP R8D,0x3
JLE 0x0010162b
MOV ECX,R8D
PXOR XMM1,XMM1
MOVDQA XMM2,xmmword ptr [0x001022a0]
MOV RAX,RDI
SHR ECX,0x2
MOVDQA XMM3,XMM1
SHL RCX,0x4
ADD RCX,RDI
NOP word ptr [RAX + RAX*0x1]
LAB_00101570:
MOVDQU XMM0,xmmword ptr [RAX]
ADD RAX,0x10
PAND XMM0,XMM2
PCMPEQD XMM0,XMM3
PSUBD XMM1,XMM0
CMP RAX,RCX
JNZ 0x00101570
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x8
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
ADD EDX,EAX
MOV EAX,R8D
AND EAX,0xfffffffc
TEST R8B,0x3
JZ 0x001015f8
LAB_001015b5:
MOVSXD RCX,EAX
LEA R9,[RCX*0x4]
MOV ECX,dword ptr [RDI + RCX*0x4]
AND ECX,0x1
CMP ECX,0x1
LEA ECX,[RAX + 0x1]
ADC EDX,0x0
CMP R8D,ECX
JLE 0x001015f8
MOV ECX,dword ptr [RDI + R9*0x1 + 0x4]
AND ECX,0x1
CMP ECX,0x1
ADC EDX,0x0
ADD EAX,0x2
CMP EAX,R8D
JGE 0x001015f8
MOV EAX,dword ptr [RDI + R9*0x1 + 0x8]
AND EAX,0x1
CMP EAX,0x1
ADC EDX,0x0
LAB_001015f8:
CMP ESI,EDX
LEA RAX,[0x102004]
LEA RDX,[0x102008]
CMOVG RAX,RDX
RET
LAB_00101610:
XOR EDX,EDX
TEST ECX,ECX
JG 0x0010153d
LEA RAX,[0x102004]
RET
LAB_00101622:
XOR EAX,EAX
XOR EDX,EDX
JMP 0x001014f2
LAB_0010162b:
XOR EAX,EAX
JMP 0x001015b5
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int * func0(uint *param_1,uint param_2,uint *param_3,uint param_4)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
int *puVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
if ((int)param_2 < 1) {
iVar7 = 0;
if ((int)param_4 < 1) {
return &DAT_00102004;
}
}
else {
if (param_2 - 1 < 3) {
uVar4 = 0;
iVar7 = 0;
LAB_001014f2:
iVar7 = iVar7 + (uint)((param_1[(int)uVar4] & 1) == 0);
if (((int)(uVar4 + 1) < (int)param_2) &&
(iVar7 = iVar7 + (uint)((param_1[(long)(int)uVar4 + 1] & 1) == 0),
(int)(uVar4 + 2) < (int)param_2)) {
iVar7 = iVar7 + (uint)((param_1[(long)(int)uVar4 + 2] & 1) == 0);
}
}
else {
iVar7 = 0;
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
puVar5 = param_1;
do {
uVar4 = *puVar5;
puVar1 = puVar5 + 1;
puVar2 = puVar5 + 2;
puVar3 = puVar5 + 3;
puVar5 = puVar5 + 4;
iVar7 = iVar7 + (uint)((uVar4 & (uint)DAT_001022a0) == 0);
iVar8 = iVar8 + (uint)((*puVar1 & DAT_001022a0._4_4_) == 0);
iVar9 = iVar9 + (uint)((*puVar2 & _UNK_001022a8) == 0);
iVar10 = iVar10 + (uint)((*puVar3 & _UNK_001022ac) == 0);
} while (puVar5 != param_1 + (ulong)(param_2 >> 2) * 4);
uVar4 = param_2 & 0xfffffffc;
iVar7 = iVar7 + iVar9 + iVar8 + iVar10;
if ((param_2 & 3) != 0) goto LAB_001014f2;
}
if ((int)param_4 < 1) goto LAB_001015f8;
}
if ((int)param_4 < 4) {
uVar4 = 0;
}
else {
iVar8 = 0;
iVar9 = 0;
iVar10 = 0;
iVar11 = 0;
puVar5 = param_3;
do {
uVar4 = *puVar5;
puVar1 = puVar5 + 1;
puVar2 = puVar5 + 2;
puVar3 = puVar5 + 3;
puVar5 = puVar5 + 4;
iVar8 = iVar8 + (uint)((uVar4 & (uint)DAT_001022a0) == 0);
iVar9 = iVar9 + (uint)((*puVar1 & DAT_001022a0._4_4_) == 0);
iVar10 = iVar10 + (uint)((*puVar2 & _UNK_001022a8) == 0);
iVar11 = iVar11 + (uint)((*puVar3 & _UNK_001022ac) == 0);
} while (puVar5 != param_3 + (ulong)(param_4 >> 2) * 4);
iVar7 = iVar7 + iVar8 + iVar10 + iVar9 + iVar11;
uVar4 = param_4 & 0xfffffffc;
if ((param_4 & 3) == 0) goto LAB_001015f8;
}
iVar7 = iVar7 + (uint)((param_3[(int)uVar4] & 1) == 0);
if (((int)(uVar4 + 1) < (int)param_4) &&
(iVar7 = iVar7 + (uint)((param_3[(long)(int)uVar4 + 1] & 1) == 0),
(int)(uVar4 + 2) < (int)param_4)) {
iVar7 = iVar7 + (uint)((param_3[(long)(int)uVar4 + 2] & 1) == 0);
}
LAB_001015f8:
puVar6 = &DAT_00102004;
if (iVar7 < (int)param_2) {
puVar6 = &DAT_00102008;
}
return puVar6;
}
|
1,100 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
if (local_freq[letter_index] > local_max) {
local_max = local_freq[letter_index];
}
}
ptr++;
}
for (int i = 0; i < 26; i++) {
freq[i] = local_freq[i];
if (local_freq[i] == local_max) {
letters[idx++] = 'a' + i;
}
}
*max_count = local_max;
letters[idx] = '\0';
}
|
#include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i] - 'a'] != freq2[letters1[i] - 'a']) return false;
}
for (int i = 0; letters2[i] != '\0'; i++) {
if (freq2[letters2[i] - 'a'] != freq1[letters2[i] - 'a']) return false;
}
return true;
}
int main() {
int counts1[26], counts2[26];
int max_count1, max_count2;
char letters1[27], letters2[27];
func0("a b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c a b", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c d g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = counts2['b' - 'a'] = counts2['c' - 'a'] = counts2['d' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "abcdg", 1));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("b b b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['b' - 'a'] = 4;
assert(issame(counts1, letters1, max_count1, counts2, "b", 4));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "a", 1));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0xb0,%rsp
mov %rdi,-0x98(%rbp)
mov %rsi,-0xa0(%rbp)
mov %rdx,-0xa8(%rbp)
mov %rcx,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
lea -0x70(%rbp),%rdx
mov $0x0,%eax
mov $0xd,%ecx
mov %rdx,%rdi
rep stos %rax,%es:(%rdi)
movl $0x0,-0x88(%rbp)
mov -0x98(%rbp),%rax
mov %rax,-0x78(%rbp)
movl $0x0,-0x84(%rbp)
jmp 124d <func0+0xc4>
mov -0x78(%rbp),%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 1248 <func0+0xbf>
mov -0x78(%rbp),%rax
movzbl (%rax),%eax
movsbl %al,%eax
sub $0x61,%eax
mov %eax,-0x7c(%rbp)
mov -0x7c(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
lea 0x1(%rax),%edx
mov -0x7c(%rbp),%eax
cltq
mov %edx,-0x70(%rbp,%rax,4)
mov -0x7c(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
cmp %eax,-0x88(%rbp)
jge 1248 <func0+0xbf>
mov -0x7c(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
mov %eax,-0x88(%rbp)
addq $0x1,-0x78(%rbp)
mov -0x78(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 11f8 <func0+0x6f>
movl $0x0,-0x80(%rbp)
jmp 12be <func0+0x135>
mov -0x80(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0xa0(%rbp),%rax
add %rax,%rdx
mov -0x80(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
mov %eax,(%rdx)
mov -0x80(%rbp),%eax
cltq
mov -0x70(%rbp,%rax,4),%eax
cmp %eax,-0x88(%rbp)
jne 12ba <func0+0x131>
mov -0x80(%rbp),%eax
lea 0x61(%rax),%ecx
mov -0x84(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x84(%rbp)
movslq %eax,%rdx
mov -0xb0(%rbp),%rax
add %rdx,%rax
mov %ecx,%edx
mov %dl,(%rax)
addl $0x1,-0x80(%rbp)
cmpl $0x19,-0x80(%rbp)
jle 1261 <func0+0xd8>
mov -0xa8(%rbp),%rax
mov -0x88(%rbp),%edx
mov %edx,(%rax)
mov -0x84(%rbp),%eax
movslq %eax,%rdx
mov -0xb0(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
xor %fs:0x28,%rax
je 12fe <func0+0x175>
callq 1070 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_98], rdi
mov [rbp+var_A0], rsi
mov [rbp+var_A8], rdx
mov [rbp+var_B0], rcx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
lea rdx, [rbp+var_70]
mov eax, 0
mov ecx, 0Dh
mov rdi, rdx
rep stosq
mov [rbp+var_88], 0
mov rax, [rbp+var_98]
mov [rbp+var_78], rax
mov [rbp+var_84], 0
jmp short loc_124D
loc_11F8:
mov rax, [rbp+var_78]
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_1248
mov rax, [rbp+var_78]
movzx eax, byte ptr [rax]
movsx eax, al
sub eax, 61h ; 'a'
mov [rbp+var_7C], eax
mov eax, [rbp+var_7C]
cdqe
mov eax, [rbp+rax*4+var_70]
lea edx, [rax+1]
mov eax, [rbp+var_7C]
cdqe
mov [rbp+rax*4+var_70], edx
mov eax, [rbp+var_7C]
cdqe
mov eax, [rbp+rax*4+var_70]
cmp [rbp+var_88], eax
jge short loc_1248
mov eax, [rbp+var_7C]
cdqe
mov eax, [rbp+rax*4+var_70]
mov [rbp+var_88], eax
loc_1248:
add [rbp+var_78], 1
loc_124D:
mov rax, [rbp+var_78]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_11F8
mov [rbp+var_80], 0
jmp short loc_12BE
loc_1261:
mov eax, [rbp+var_80]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_A0]
add rdx, rax
mov eax, [rbp+var_80]
cdqe
mov eax, [rbp+rax*4+var_70]
mov [rdx], eax
mov eax, [rbp+var_80]
cdqe
mov eax, [rbp+rax*4+var_70]
cmp [rbp+var_88], eax
jnz short loc_12BA
mov eax, [rbp+var_80]
lea ecx, [rax+61h]
mov eax, [rbp+var_84]
lea edx, [rax+1]
mov [rbp+var_84], edx
movsxd rdx, eax
mov rax, [rbp+var_B0]
add rax, rdx
mov edx, ecx
mov [rax], dl
loc_12BA:
add [rbp+var_80], 1
loc_12BE:
cmp [rbp+var_80], 19h
jle short loc_1261
mov rax, [rbp+var_A8]
mov edx, [rbp+var_88]
mov [rax], edx
mov eax, [rbp+var_84]
movsxd rdx, eax
mov rax, [rbp+var_B0]
add rax, rdx
mov byte ptr [rax], 0
nop
mov rax, [rbp+var_8]
sub rax, fs:28h
jz short locret_12FE
call ___stack_chk_fail
locret_12FE:
leave
retn
|
unsigned long long func0(_BYTE *a1, long long a2, _DWORD *a3, long long a4)
{
int v4; // eax
int v6; // [rsp+28h] [rbp-88h]
int v7; // [rsp+2Ch] [rbp-84h]
int i; // [rsp+30h] [rbp-80h]
int v9; // [rsp+34h] [rbp-7Ch]
_DWORD v11[26]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v12; // [rsp+A8h] [rbp-8h]
v12 = __readfsqword(0x28u);
memset(v11, 0, sizeof(v11));
v6 = 0;
v7 = 0;
while ( *a1 )
{
if ( *a1 != 32 )
{
v9 = (char)*a1 - 97;
if ( v6 < ++v11[v9] )
v6 = v11[v9];
}
++a1;
}
for ( i = 0; i <= 25; ++i )
{
*(_DWORD *)(a2 + 4LL * i) = v11[i];
if ( v6 == v11[i] )
{
v4 = v7++;
*(_BYTE *)(v4 + a4) = i + 97;
}
}
*a3 = v6;
*(_BYTE *)(v7 + a4) = 0;
return v12 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x98],RDI
MOV qword ptr [RBP + -0xa0],RSI
MOV qword ptr [RBP + -0xa8],RDX
MOV qword ptr [RBP + -0xb0],RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
LEA RDX,[RBP + -0x70]
MOV EAX,0x0
MOV ECX,0xd
MOV RDI,RDX
STOSQ.REP RDI
MOV dword ptr [RBP + -0x88],0x0
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x78],RAX
MOV dword ptr [RBP + -0x84],0x0
JMP 0x0010124d
LAB_001011f8:
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x00101248
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
SUB EAX,0x61
MOV dword ptr [RBP + -0x7c],EAX
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
MOV dword ptr [RBP + RAX*0x4 + -0x70],EDX
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
CMP dword ptr [RBP + -0x88],EAX
JGE 0x00101248
MOV EAX,dword ptr [RBP + -0x7c]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
MOV dword ptr [RBP + -0x88],EAX
LAB_00101248:
ADD qword ptr [RBP + -0x78],0x1
LAB_0010124d:
MOV RAX,qword ptr [RBP + -0x78]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001011f8
MOV dword ptr [RBP + -0x80],0x0
JMP 0x001012be
LAB_00101261:
MOV EAX,dword ptr [RBP + -0x80]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0xa0]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x80]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x80]
CDQE
MOV EAX,dword ptr [RBP + RAX*0x4 + -0x70]
CMP dword ptr [RBP + -0x88],EAX
JNZ 0x001012ba
MOV EAX,dword ptr [RBP + -0x80]
LEA ECX,[RAX + 0x61]
MOV EAX,dword ptr [RBP + -0x84]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x84],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xb0]
ADD RAX,RDX
MOV EDX,ECX
MOV byte ptr [RAX],DL
LAB_001012ba:
ADD dword ptr [RBP + -0x80],0x1
LAB_001012be:
CMP dword ptr [RBP + -0x80],0x19
JLE 0x00101261
MOV RAX,qword ptr [RBP + -0xa8]
MOV EDX,dword ptr [RBP + -0x88]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x84]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xb0]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
NOP
MOV RAX,qword ptr [RBP + -0x8]
SUB RAX,qword ptr FS:[0x28]
JZ 0x001012fe
CALL 0x00101070
LAB_001012fe:
LEAVE
RET
|
void func0(char *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
long lVar2;
int *piVar3;
long in_FS_OFFSET;
int local_90;
int local_8c;
int local_88;
char *local_80;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar3 = local_78;
for (lVar2 = 0xd; lVar2 != 0; lVar2 = lVar2 + -1) {
piVar3[0] = 0;
piVar3[1] = 0;
piVar3 = piVar3 + 2;
}
local_90 = 0;
local_8c = 0;
for (local_80 = param_1; *local_80 != '\0'; local_80 = local_80 + 1) {
if (*local_80 != ' ') {
iVar1 = *local_80 + -0x61;
local_78[iVar1] = local_78[iVar1] + 1;
if (local_90 < local_78[iVar1]) {
local_90 = local_78[iVar1];
}
}
}
for (local_88 = 0; local_88 < 0x1a; local_88 = local_88 + 1) {
*(int *)((long)local_88 * 4 + param_2) = local_78[local_88];
if (local_90 == local_78[local_88]) {
*(char *)(param_4 + local_8c) = (char)local_88 + 'a';
local_8c = local_8c + 1;
}
}
*param_3 = local_90;
*(int *)(param_4 + local_8c) = 0;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,101 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
if (local_freq[letter_index] > local_max) {
local_max = local_freq[letter_index];
}
}
ptr++;
}
for (int i = 0; i < 26; i++) {
freq[i] = local_freq[i];
if (local_freq[i] == local_max) {
letters[idx++] = 'a' + i;
}
}
*max_count = local_max;
letters[idx] = '\0';
}
|
#include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i] - 'a'] != freq2[letters1[i] - 'a']) return false;
}
for (int i = 0; letters2[i] != '\0'; i++) {
if (freq2[letters2[i] - 'a'] != freq1[letters2[i] - 'a']) return false;
}
return true;
}
int main() {
int counts1[26], counts2[26];
int max_count1, max_count2;
char letters1[27], letters2[27];
func0("a b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c a b", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c d g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = counts2['b' - 'a'] = counts2['c' - 'a'] = counts2['d' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "abcdg", 1));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("b b b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['b' - 'a'] = 4;
assert(issame(counts1, letters1, max_count1, counts2, "b", 4));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "a", 1));
return 0;
}
|
O1
|
c
|
func0:
endbr64
sub $0x78,%rsp
mov %rdi,%r8
mov %rcx,%r9
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%rdi
mov $0xd,%ecx
rep stos %rax,%es:(%rdi)
movzbl (%r8),%eax
test %al,%al
je 11c9 <func0+0x60>
mov $0x0,%edi
jmp 11c3 <func0+0x5a>
movsbl %al,%eax
sub $0x61,%eax
cltq
mov (%rsp,%rax,4),%ecx
add $0x1,%ecx
mov %ecx,(%rsp,%rax,4)
cmp %ecx,%edi
cmovl %ecx,%edi
add $0x1,%r8
movzbl (%r8),%eax
test %al,%al
je 11ce <func0+0x65>
cmp $0x20,%al
jne 11a1 <func0+0x38>
jmp 11b7 <func0+0x4e>
mov $0x0,%edi
mov $0x0,%eax
mov $0x0,%r8d
jmp 11e5 <func0+0x7c>
add $0x1,%rax
cmp $0x1a,%rax
je 1200 <func0+0x97>
mov (%rsp,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
cmp %edi,%ecx
jne 11db <func0+0x72>
movslq %r8d,%rcx
lea 0x61(%rax),%r10d
mov %r10b,(%r9,%rcx,1)
lea 0x1(%r8),%r8d
jmp 11db <func0+0x72>
mov %edi,(%rdx)
movslq %r8d,%r8
movb $0x0,(%r9,%r8,1)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 121f <func0+0xb6>
add $0x78,%rsp
retq
callq 1060 <__stack_chk_fail@plt>
|
func0:
endbr64
sub rsp, 78h
mov r11, rdi
mov r8, rsi
mov r10, rdx
mov r9, rcx
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov rdi, rsp
mov ecx, 0Dh
rep stosq
movzx eax, byte ptr [r11]
test al, al
jnz short loc_11D3
mov ecx, 0
loc_11A5:
mov eax, 0
mov esi, 0
jmp short loc_11E3
loc_11B1:
movsx eax, al
sub eax, 61h ; 'a'
cdqe
mov edi, [rsp+rax*4+78h+var_78]
lea edx, [rdi+1]
mov [rsp+rax*4+78h+var_78], edx
cmp ecx, edx
cmovl ecx, edx
loc_11C7:
add r11, 1
movzx eax, byte ptr [r11]
test al, al
jz short loc_11A5
loc_11D3:
cmp al, 20h ; ' '
jnz short loc_11B1
jmp short loc_11C7
loc_11D9:
add rax, 1
cmp rax, 1Ah
jz short loc_11FD
loc_11E3:
mov edx, [rsp+rax*4+78h+var_78]
mov [r8+rax*4], edx
cmp edx, ecx
jnz short loc_11D9
movsxd rdx, esi
lea edi, [rax+61h]
mov [r9+rdx], dil
lea esi, [rsi+1]
jmp short loc_11D9
loc_11FD:
mov [r10], ecx
movsxd rsi, esi
mov byte ptr [r9+rsi], 0
mov rax, [rsp+78h+var_10]
sub rax, fs:28h
jnz short loc_121D
add rsp, 78h
retn
loc_121D:
call ___stack_chk_fail
|
unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r11
int v8; // ecx
char v9; // al
long long v10; // rax
int v11; // esi
long long v12; // rax
int v13; // edx
int v14; // edx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v17; // [rsp+68h] [rbp-10h]
v4 = a1;
v17 = __readfsqword(0x28u);
memset(v16, 0, sizeof(v16));
v8 = 0;
v9 = *a1;
if ( *a1 )
{
do
{
if ( v9 != 32 )
{
v12 = v9 - 97;
v13 = v16[v12] + 1;
v16[v12] = v13;
if ( v8 < v13 )
v8 = v13;
}
v9 = *++v4;
}
while ( *v4 );
}
else
{
v8 = 0;
}
v10 = 0LL;
v11 = 0;
do
{
v14 = v16[v10];
*(_DWORD *)(a2 + 4 * v10) = v14;
if ( v14 == v8 )
*(_BYTE *)(a4 + v11++) = v10 + 97;
++v10;
}
while ( v10 != 26 );
*a3 = v8;
*(_BYTE *)(a4 + v11) = 0;
return v17 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x78
MOV R11,RDI
MOV R8,RSI
MOV R10,RDX
MOV R9,RCX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV RDI,RSP
MOV ECX,0xd
STOSQ.REP RDI
MOVZX EAX,byte ptr [R11]
TEST AL,AL
JNZ 0x001011d3
MOV ECX,0x0
LAB_001011a5:
MOV EAX,0x0
MOV ESI,0x0
JMP 0x001011e3
LAB_001011b1:
MOVSX EAX,AL
SUB EAX,0x61
CDQE
MOV EDI,dword ptr [RSP + RAX*0x4]
LEA EDX,[RDI + 0x1]
MOV dword ptr [RSP + RAX*0x4],EDX
CMP ECX,EDX
CMOVL ECX,EDX
LAB_001011c7:
ADD R11,0x1
MOVZX EAX,byte ptr [R11]
TEST AL,AL
JZ 0x001011a5
LAB_001011d3:
CMP AL,0x20
JNZ 0x001011b1
JMP 0x001011c7
LAB_001011d9:
ADD RAX,0x1
CMP RAX,0x1a
JZ 0x001011fd
LAB_001011e3:
MOV EDX,dword ptr [RSP + RAX*0x4]
MOV dword ptr [R8 + RAX*0x4],EDX
CMP EDX,ECX
JNZ 0x001011d9
MOVSXD RDX,ESI
LEA EDI,[RAX + 0x61]
MOV byte ptr [R9 + RDX*0x1],DIL
LEA ESI,[RSI + 0x1]
JMP 0x001011d9
LAB_001011fd:
MOV dword ptr [R10],ECX
MOVSXD RSI,ESI
MOV byte ptr [R9 + RSI*0x1],0x0
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010121d
ADD RSP,0x78
RET
LAB_0010121d:
CALL 0x00101060
|
void func0(char *param_1,long param_2,int *param_3,long param_4)
{
int iVar1;
char cVar2;
int iVar3;
long lVar4;
int iVar5;
int *piVar6;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar6 = local_78;
for (lVar4 = 0xd; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)piVar6 = 0;
piVar6 = (int *)((long)piVar6 + 8);
}
cVar2 = *param_1;
iVar3 = 0;
if (cVar2 == '\0') {
iVar3 = 0;
}
else {
do {
if (cVar2 != ' ') {
iVar5 = local_78[cVar2 + -0x61] + 1;
local_78[cVar2 + -0x61] = iVar5;
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
}
param_1 = param_1 + 1;
cVar2 = *param_1;
} while (cVar2 != '\0');
}
lVar4 = 0;
iVar5 = 0;
do {
iVar1 = local_78[lVar4];
*(int *)(param_2 + lVar4 * 4) = iVar1;
if (iVar1 == iVar3) {
*(char *)(param_4 + iVar5) = (char)lVar4 + 'a';
iVar5 = iVar5 + 1;
}
lVar4 = lVar4 + 1;
} while (lVar4 != 0x1a);
*param_3 = iVar3;
*(int *)(param_4 + iVar5) = 0;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,102 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
if (local_freq[letter_index] > local_max) {
local_max = local_freq[letter_index];
}
}
ptr++;
}
for (int i = 0; i < 26; i++) {
freq[i] = local_freq[i];
if (local_freq[i] == local_max) {
letters[idx++] = 'a' + i;
}
}
*max_count = local_max;
letters[idx] = '\0';
}
|
#include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i] - 'a'] != freq2[letters1[i] - 'a']) return false;
}
for (int i = 0; letters2[i] != '\0'; i++) {
if (freq2[letters2[i] - 'a'] != freq1[letters2[i] - 'a']) return false;
}
return true;
}
int main() {
int counts1[26], counts2[26];
int max_count1, max_count2;
char letters1[27], letters2[27];
func0("a b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c a b", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c d g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = counts2['b' - 'a'] = counts2['c' - 'a'] = counts2['d' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "abcdg", 1));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("b b b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['b' - 'a'] = 4;
assert(issame(counts1, letters1, max_count1, counts2, "b", 4));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "a", 1));
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%r8
mov %rcx,%r9
mov $0xd,%ecx
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%r10
mov %r10,%rdi
rep stos %rax,%es:(%rdi)
movsbl (%r8),%eax
test %al,%al
je 161d <func0+0xbd>
xor %r11d,%r11d
nopl 0x0(%rax)
cmp $0x20,%al
je 15b9 <func0+0x59>
sub $0x61,%eax
cltq
mov (%rsp,%rax,4),%ebx
lea 0x1(%rbx),%ecx
cmp %ecx,%r11d
mov %ecx,(%rsp,%rax,4)
cmovl %ecx,%r11d
movsbl 0x1(%r8),%eax
add $0x1,%r8
test %al,%al
jne 15a0 <func0+0x40>
mov (%rsp),%ecx
xor %eax,%eax
xor %ebx,%ebx
xor %r8d,%r8d
jmp 15dc <func0+0x7c>
nopw 0x0(%rax,%rax,1)
mov (%r10,%rax,4),%ecx
mov %ecx,(%rsi,%rax,4)
lea (%r9,%r8,1),%rdi
cmp %ecx,%r11d
jne 15f7 <func0+0x97>
add $0x1,%ebx
lea 0x61(%rax),%ecx
movslq %ebx,%r8
mov %cl,(%rdi)
lea (%r9,%r8,1),%rdi
add $0x1,%rax
cmp $0x1a,%rax
jne 15d8 <func0+0x78>
mov %r11d,(%rdx)
movb $0x0,(%rdi)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1624 <func0+0xc4>
add $0x70,%rsp
pop %rbx
retq
xor %ecx,%ecx
xor %r11d,%r11d
jmp 15c9 <func0+0x69>
callq 1060 <__stack_chk_fail@plt>
nopl 0x0(%rax)
|
func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Dh
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov r8, rsp
mov r11, rdx
mov rdi, r8
rep stosq
movsx eax, byte ptr [r9]
test al, al
jz short loc_1623
nop word ptr [rax+rax+00000000h]
loc_15B0:
cmp al, 20h ; ' '
jz short loc_15C7
sub eax, 61h ; 'a'
cdqe
mov edi, [rsp+rax*4+78h+var_78]
lea edx, [rdi+1]
cmp ecx, edx
mov [rsp+rax*4+78h+var_78], edx
cmovl ecx, edx
loc_15C7:
movsx eax, byte ptr [r9+1]
add r9, 1
test al, al
jnz short loc_15B0
loc_15D4:
xor eax, eax
xor edi, edi
nop dword ptr [rax+rax+00000000h]
loc_15E0:
mov edx, [r8+rax*4]
mov [rsi+rax*4], edx
cmp edx, ecx
jnz short loc_15F9
movsxd rdx, edi
lea r9d, [rax+61h]
add edi, 1
mov [r10+rdx], r9b
loc_15F9:
add rax, 1
cmp rax, 1Ah
jnz short loc_15E0
movsxd rdi, edi
mov [r11], ecx
mov byte ptr [r10+rdi], 0
mov rax, [rsp+78h+var_10]
sub rax, fs:28h
jnz short loc_1627
add rsp, 78h
retn
loc_1623:
xor ecx, ecx
jmp short loc_15D4
loc_1627:
call ___stack_chk_fail
|
unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r9
int v7; // ecx
int v8; // eax
long long v9; // rax
int v10; // edx
long long v11; // rax
int v12; // edi
int v13; // edx
long long v14; // rdx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v17; // [rsp+68h] [rbp-10h]
v4 = a1;
v17 = __readfsqword(0x28u);
memset(v16, 0, sizeof(v16));
v7 = 0;
v8 = (char)*a1;
if ( *a1 )
{
do
{
if ( (_BYTE)v8 != 32 )
{
v9 = v8 - 97;
v10 = v16[v9] + 1;
v16[v9] = v10;
if ( v7 < v10 )
v7 = v10;
}
v8 = (char)*++v4;
}
while ( (_BYTE)v8 );
}
else
{
v7 = 0;
}
v11 = 0LL;
v12 = 0;
do
{
v13 = v16[v11];
*(_DWORD *)(a2 + 4 * v11) = v13;
if ( v13 == v7 )
{
v14 = v12++;
*(_BYTE *)(a4 + v14) = v11 + 97;
}
++v11;
}
while ( v11 != 26 );
*a3 = v7;
*(_BYTE *)(a4 + v12) = 0;
return v17 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xd
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV R8,RSP
MOV R11,RDX
MOV RDI,R8
STOSQ.REP RDI
MOVSX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x00101623
NOP word ptr [RAX + RAX*0x1]
LAB_001015b0:
CMP AL,0x20
JZ 0x001015c7
SUB EAX,0x61
CDQE
MOV EDI,dword ptr [RSP + RAX*0x4]
LEA EDX,[RDI + 0x1]
CMP ECX,EDX
MOV dword ptr [RSP + RAX*0x4],EDX
CMOVL ECX,EDX
LAB_001015c7:
MOVSX EAX,byte ptr [R9 + 0x1]
ADD R9,0x1
TEST AL,AL
JNZ 0x001015b0
LAB_001015d4:
XOR EAX,EAX
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001015e0:
MOV EDX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
CMP EDX,ECX
JNZ 0x001015f9
MOVSXD RDX,EDI
LEA R9D,[RAX + 0x61]
ADD EDI,0x1
MOV byte ptr [R10 + RDX*0x1],R9B
LAB_001015f9:
ADD RAX,0x1
CMP RAX,0x1a
JNZ 0x001015e0
MOVSXD RDI,EDI
MOV dword ptr [R11],ECX
MOV byte ptr [R10 + RDI*0x1],0x0
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101627
ADD RSP,0x78
RET
LAB_00101623:
XOR ECX,ECX
JMP 0x001015d4
LAB_00101627:
CALL 0x00101060
|
void func0(char *param_1,long param_2,int *param_3,long param_4)
{
char cVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
int *piVar7;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = local_78;
for (lVar4 = 0xd; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)piVar7 = 0;
piVar7 = (int *)((long)piVar7 + 8);
}
cVar1 = *param_1;
if (cVar1 == '\0') {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
if (cVar1 != ' ') {
iVar5 = local_78[cVar1 + -0x61] + 1;
local_78[cVar1 + -0x61] = iVar5;
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
}
cVar1 = param_1[1];
param_1 = param_1 + 1;
} while (cVar1 != '\0');
}
lVar4 = 0;
iVar5 = 0;
do {
iVar2 = local_78[lVar4];
*(int *)(param_2 + lVar4 * 4) = iVar2;
if (iVar2 == iVar3) {
lVar6 = (long)iVar5;
iVar5 = iVar5 + 1;
*(char *)(param_4 + lVar6) = (char)lVar4 + 'a';
}
lVar4 = lVar4 + 1;
} while (lVar4 != 0x1a);
*param_3 = iVar3;
*(int *)(param_4 + iVar5) = 0;
if (local_10 == *(long *)(in_FS_OFFSET + 0x28)) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,103 |
func0
|
#include <stdio.h>
#include <string.h>
|
void func0(const char* test, int* freq, int* max_count, char* letters) {
int local_freq[26] = {0}; // for 'a' to 'z'
int local_max = 0;
const char* ptr = test;
int idx = 0;
while (*ptr) {
if (*ptr != ' ') {
int letter_index = *ptr - 'a';
local_freq[letter_index]++;
if (local_freq[letter_index] > local_max) {
local_max = local_freq[letter_index];
}
}
ptr++;
}
for (int i = 0; i < 26; i++) {
freq[i] = local_freq[i];
if (local_freq[i] == local_max) {
letters[idx++] = 'a' + i;
}
}
*max_count = local_max;
letters[idx] = '\0';
}
|
#include <assert.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>
bool issame(int* freq1, const char* letters1, int max_count1, int* freq2, const char* letters2, int max_count2) {
if (max_count1 != max_count2) return false;
for (int i = 0; letters1[i] != '\0'; i++) {
if (freq1[letters1[i] - 'a'] != freq2[letters1[i] - 'a']) return false;
}
for (int i = 0; letters2[i] != '\0'; i++) {
if (freq2[letters2[i] - 'a'] != freq1[letters2[i] - 'a']) return false;
}
return true;
}
int main() {
int counts1[26], counts2[26];
int max_count1, max_count2;
char letters1[27], letters2[27];
func0("a b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c a b", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 2;
counts2['b' - 'a'] = 2;
assert(issame(counts1, letters1, max_count1, counts2, "ab", 2));
func0("a b c d g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = counts2['b' - 'a'] = counts2['c' - 'a'] = counts2['d' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "abcdg", 1));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("b b b b a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['b' - 'a'] = 4;
assert(issame(counts1, letters1, max_count1, counts2, "b", 4));
func0("r t g", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['r' - 'a'] = counts2['t' - 'a'] = counts2['g' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "rtg", 1));
func0("a", counts1, &max_count1, letters1);
memset(counts2, 0, sizeof(counts2));
counts2['a' - 'a'] = 1;
assert(issame(counts1, letters1, max_count1, counts2, "a", 1));
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%r8
mov %rcx,%r9
mov $0xd,%ecx
xor %r11d,%r11d
sub $0x70,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov %rsp,%r10
mov %r10,%rdi
rep stos %rax,%es:(%rdi)
movsbl (%r8),%eax
test %al,%al
je 15b6 <func0+0x66>
nopl 0x0(%rax,%rax,1)
cmp $0x20,%al
je 1608 <func0+0xb8>
sub $0x61,%eax
cltq
mov (%rsp,%rax,4),%ebx
lea 0x1(%rbx),%ecx
cmp %ecx,%r11d
mov %ecx,(%rsp,%rax,4)
cmovl %ecx,%r11d
movsbl 0x1(%r8),%eax
add $0x1,%r8
test %al,%al
jne 1590 <func0+0x40>
xor %eax,%eax
xor %ebx,%ebx
xor %r8d,%r8d
nopl (%rax)
mov (%r10,%rax,4),%ecx
lea (%r9,%r8,1),%rdi
mov %ecx,(%rsi,%rax,4)
cmp %r11d,%ecx
jne 15df <func0+0x8f>
add $0x1,%ebx
lea 0x61(%rax),%ecx
movslq %ebx,%r8
mov %cl,(%rdi)
lea (%r9,%r8,1),%rdi
add $0x1,%rax
cmp $0x1a,%rax
jne 15c0 <func0+0x70>
mov %r11d,(%rdx)
movb $0x0,(%rdi)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 161b <func0+0xcb>
add $0x70,%rsp
pop %rbx
retq
nopl (%rax)
movsbl 0x1(%r8),%eax
add $0x1,%r8
test %al,%al
jne 1590 <func0+0x40>
jmp 15b6 <func0+0x66>
callq 1060 <__stack_chk_fail@plt>
|
func0:
endbr64
sub rsp, 78h
mov r9, rdi
mov r10, rcx
mov ecx, 0Dh
mov rax, fs:28h
mov [rsp+78h+var_10], rax
xor eax, eax
mov r8, rsp
mov r11, rdx
mov rdi, r8
rep stosq
movsx eax, byte ptr [r9]
test al, al
jz loc_163B
nop dword ptr [rax+rax+00h]
loc_15B0:
cmp al, 20h ; ' '
jz short loc_1628
sub eax, 61h ; 'a'
cdqe
mov edi, [rsp+rax*4+78h+var_78]
lea edx, [rdi+1]
cmp ecx, edx
mov [rsp+rax*4+78h+var_78], edx
cmovl ecx, edx
movsx eax, byte ptr [r9+1]
add r9, 1
test al, al
jnz short loc_15B0
loc_15D4:
xor eax, eax
xor edi, edi
nop dword ptr [rax+rax+00000000h]
loc_15E0:
mov edx, [r8+rax*4]
mov [rsi+rax*4], edx
cmp edx, ecx
jnz short loc_15F9
movsxd rdx, edi
lea r9d, [rax+61h]
add edi, 1
mov [r10+rdx], r9b
loc_15F9:
add rax, 1
cmp rax, 1Ah
jnz short loc_15E0
movsxd rdi, edi
mov [r11], ecx
mov byte ptr [r10+rdi], 0
mov rax, [rsp+78h+var_10]
sub rax, fs:28h
jnz short loc_163F
add rsp, 78h
retn
loc_1628:
movsx eax, byte ptr [r9+1]
add r9, 1
test al, al
jnz loc_15B0
jmp short loc_15D4
loc_163B:
xor ecx, ecx
jmp short loc_15D4
loc_163F:
call ___stack_chk_fail
|
unsigned long long func0(_BYTE *a1, long long a2, int *a3, long long a4)
{
_BYTE *v4; // r9
int v7; // ecx
int v8; // eax
long long v9; // rax
int v10; // edx
long long v11; // rax
int v12; // edi
int v13; // edx
long long v14; // rdx
_DWORD v16[26]; // [rsp+0h] [rbp-78h] BYREF
unsigned long long v17; // [rsp+68h] [rbp-10h]
v4 = a1;
v17 = __readfsqword(0x28u);
memset(v16, 0, sizeof(v16));
v7 = 0;
v8 = (char)*a1;
if ( *a1 )
{
do
{
while ( (_BYTE)v8 == 32 )
{
v8 = (char)*++v4;
if ( !(_BYTE)v8 )
goto LABEL_6;
}
v9 = v8 - 97;
v10 = v16[v9] + 1;
v16[v9] = v10;
if ( v7 < v10 )
v7 = v10;
v8 = (char)*++v4;
}
while ( (_BYTE)v8 );
}
else
{
v7 = 0;
}
LABEL_6:
v11 = 0LL;
v12 = 0;
do
{
v13 = v16[v11];
*(_DWORD *)(a2 + 4 * v11) = v13;
if ( v13 == v7 )
{
v14 = v12++;
*(_BYTE *)(a4 + v14) = v11 + 97;
}
++v11;
}
while ( v11 != 26 );
*a3 = v7;
*(_BYTE *)(a4 + v12) = 0;
return v17 - __readfsqword(0x28u);
}
|
func0:
ENDBR64
SUB RSP,0x78
MOV R9,RDI
MOV R10,RCX
MOV ECX,0xd
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
MOV R8,RSP
MOV R11,RDX
MOV RDI,R8
STOSQ.REP RDI
MOVSX EAX,byte ptr [R9]
TEST AL,AL
JZ 0x0010163b
NOP dword ptr [RAX + RAX*0x1]
LAB_001015b0:
CMP AL,0x20
JZ 0x00101628
SUB EAX,0x61
CDQE
MOV EDI,dword ptr [RSP + RAX*0x4]
LEA EDX,[RDI + 0x1]
CMP ECX,EDX
MOV dword ptr [RSP + RAX*0x4],EDX
CMOVL ECX,EDX
MOVSX EAX,byte ptr [R9 + 0x1]
ADD R9,0x1
TEST AL,AL
JNZ 0x001015b0
LAB_001015d4:
XOR EAX,EAX
XOR EDI,EDI
NOP dword ptr [RAX + RAX*0x1]
LAB_001015e0:
MOV EDX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [RSI + RAX*0x4],EDX
CMP EDX,ECX
JNZ 0x001015f9
MOVSXD RDX,EDI
LEA R9D,[RAX + 0x61]
ADD EDI,0x1
MOV byte ptr [R10 + RDX*0x1],R9B
LAB_001015f9:
ADD RAX,0x1
CMP RAX,0x1a
JNZ 0x001015e0
MOVSXD RDI,EDI
MOV dword ptr [R11],ECX
MOV byte ptr [R10 + RDI*0x1],0x0
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010163f
ADD RSP,0x78
RET
LAB_00101628:
MOVSX EAX,byte ptr [R9 + 0x1]
ADD R9,0x1
TEST AL,AL
JNZ 0x001015b0
JMP 0x001015d4
LAB_0010163b:
XOR ECX,ECX
JMP 0x001015d4
LAB_0010163f:
CALL 0x00101060
|
void func0(char *param_1,long param_2,int *param_3,long param_4)
{
char *pcVar1;
int iVar2;
int iVar3;
long lVar4;
int iVar5;
long lVar6;
int *piVar7;
long in_FS_OFFSET;
int local_78 [26];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
piVar7 = local_78;
for (lVar4 = 0xd; lVar4 != 0; lVar4 = lVar4 + -1) {
*(int8 *)piVar7 = 0;
piVar7 = (int *)((long)piVar7 + 8);
}
iVar2 = (int)*param_1;
if (*param_1 == '\0') {
iVar3 = 0;
}
else {
iVar3 = 0;
do {
while ((char)iVar2 == ' ') {
pcVar1 = param_1 + 1;
iVar2 = (int)*pcVar1;
param_1 = param_1 + 1;
if (*pcVar1 == '\0') goto LAB_001015d4;
}
iVar5 = local_78[iVar2 + -0x61] + 1;
local_78[iVar2 + -0x61] = iVar5;
if (iVar3 < iVar5) {
iVar3 = iVar5;
}
pcVar1 = param_1 + 1;
iVar2 = (int)*pcVar1;
param_1 = param_1 + 1;
} while (*pcVar1 != '\0');
}
LAB_001015d4:
lVar4 = 0;
iVar2 = 0;
do {
iVar5 = local_78[lVar4];
*(int *)(param_2 + lVar4 * 4) = iVar5;
if (iVar5 == iVar3) {
lVar6 = (long)iVar2;
iVar2 = iVar2 + 1;
*(char *)(param_4 + lVar6) = (char)lVar4 + 'a';
}
lVar4 = lVar4 + 1;
} while (lVar4 != 0x1a);
*param_3 = iVar3;
*(int *)(param_4 + iVar2) = 0;
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
1,104 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *temp) {
found = true;
break;
}
temp++;
}
if (!found) {
n[ni++] = s[i];
}
}
n[ni] = '\0';
int n_len = strlen(n);
bool is_palindrome = true;
for (int i = 0; i < n_len / 2; i++) {
if (n[i] != n[n_len - 1 - i]) {
is_palindrome = false;
break;
}
}
strcpy(result, n);
strcpy(palindrome, is_palindrome ? "True" : "False");
free(n);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdedcba", "ab", result, palindrome);
assert(strcmp(result, "cdedc") == 0 && strcmp(palindrome, "True") == 0);
func0("dwik", "w", result, palindrome);
assert(strcmp(result, "dik") == 0 && strcmp(palindrome, "False") == 0);
func0("a", "a", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "v", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("vabba", "v", result, palindrome);
assert(strcmp(result, "abba") == 0 && strcmp(palindrome, "True") == 0);
func0("mamma", "mia", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %rcx,-0x50(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
add $0x1,%eax
cltq
mov %rax,%rdi
callq 1110 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x24(%rbp)
movl $0x0,-0x20(%rbp)
jmp 12cc <func0+0xc3>
mov -0x40(%rbp),%rax
mov %rax,-0x10(%rbp)
movb $0x0,-0x26(%rbp)
jmp 128c <func0+0x83>
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp %al,%dl
jne 1287 <func0+0x7e>
movb $0x1,-0x26(%rbp)
jmp 1297 <func0+0x8e>
addq $0x1,-0x10(%rbp)
mov -0x10(%rbp),%rax
movzbl (%rax),%eax
test %al,%al
jne 1266 <func0+0x5d>
movzbl -0x26(%rbp),%eax
xor $0x1,%eax
test %al,%al
je 12c8 <func0+0xbf>
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x24(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x24(%rbp)
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
addl $0x1,-0x20(%rbp)
mov -0x20(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1258 <func0+0x4f>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 10d0 <strlen@plt>
mov %eax,-0x14(%rbp)
movb $0x1,-0x25(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 1344 <func0+0x13b>
mov -0x1c(%rbp),%eax
movslq %eax,%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%edx
mov -0x14(%rbp),%eax
sub $0x1,%eax
sub -0x1c(%rbp),%eax
movslq %eax,%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
movzbl (%rax),%eax
cmp %al,%dl
je 1340 <func0+0x137>
movb $0x0,-0x25(%rbp)
jmp 1355 <func0+0x14c>
addl $0x1,-0x1c(%rbp)
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
cmp %eax,-0x1c(%rbp)
jl 1310 <func0+0x107>
mov -0x8(%rbp),%rdx
mov -0x48(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10c0 <strcpy@plt>
cmpb $0x0,-0x25(%rbp)
je 1377 <func0+0x16e>
lea 0xc93(%rip),%rax
jmp 137e <func0+0x175>
lea 0xc8f(%rip),%rax
mov -0x50(%rbp),%rdx
mov %rax,%rsi
mov %rdx,%rdi
callq 10c0 <strcpy@plt>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 10b0 <free@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+s], rdi
mov [rbp+var_40], rsi
mov [rbp+dest], rdx
mov [rbp+var_50], rcx
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
add eax, 1
cdqe
mov rdi, rax; size
call _malloc
mov [rbp+src], rax
mov [rbp+var_24], 0
mov [rbp+var_20], 0
jmp short loc_12CC
loc_1258:
mov rax, [rbp+var_40]
mov [rbp+var_10], rax
mov [rbp+var_26], 0
jmp short loc_128C
loc_1266:
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx edx, byte ptr [rax]
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
cmp dl, al
jnz short loc_1287
mov [rbp+var_26], 1
jmp short loc_1297
loc_1287:
add [rbp+var_10], 1
loc_128C:
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1266
loc_1297:
movzx eax, [rbp+var_26]
xor eax, 1
test al, al
jz short loc_12C8
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_24]
lea edx, [rax+1]
mov [rbp+var_24], edx
movsxd rdx, eax
mov rax, [rbp+src]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
loc_12C8:
add [rbp+var_20], 1
loc_12CC:
mov eax, [rbp+var_20]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1258
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+src]
add rax, rdx
mov byte ptr [rax], 0
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
mov [rbp+var_14], eax
mov [rbp+var_25], 1
mov [rbp+var_1C], 0
jmp short loc_1344
loc_1310:
mov eax, [rbp+var_1C]
movsxd rdx, eax
mov rax, [rbp+src]
add rax, rdx
movzx edx, byte ptr [rax]
mov eax, [rbp+var_14]
sub eax, 1
sub eax, [rbp+var_1C]
movsxd rcx, eax
mov rax, [rbp+src]
add rax, rcx
movzx eax, byte ptr [rax]
cmp dl, al
jz short loc_1340
mov [rbp+var_25], 0
jmp short loc_1355
loc_1340:
add [rbp+var_1C], 1
loc_1344:
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
cmp [rbp+var_1C], eax
jl short loc_1310
loc_1355:
mov rdx, [rbp+src]
mov rax, [rbp+dest]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
cmp [rbp+var_25], 0
jz short loc_1377
lea rax, src; "True"
jmp short loc_137E
loc_1377:
lea rax, aFalse; "False"
loc_137E:
mov rdx, [rbp+var_50]
mov rsi, rax; src
mov rdi, rdx; dest
call _strcpy
mov rax, [rbp+src]
mov rdi, rax; ptr
call _free
nop
leave
retn
|
void func0(const char *a1, _BYTE *a2, char *a3, char *a4)
{
int v4; // eax
const char *v5; // rax
char v8; // [rsp+2Ah] [rbp-26h]
char v9; // [rsp+2Bh] [rbp-25h]
int v10; // [rsp+2Ch] [rbp-24h]
int i; // [rsp+30h] [rbp-20h]
int j; // [rsp+34h] [rbp-1Ch]
int v13; // [rsp+38h] [rbp-18h]
int v14; // [rsp+3Ch] [rbp-14h]
_BYTE *v15; // [rsp+40h] [rbp-10h]
char *src; // [rsp+48h] [rbp-8h]
v13 = strlen(a1);
src = (char *)malloc(v13 + 1);
v10 = 0;
for ( i = 0; a1[i]; ++i )
{
v15 = a2;
v8 = 0;
while ( *v15 )
{
if ( a1[i] == *v15 )
{
v8 = 1;
break;
}
++v15;
}
if ( v8 != 1 )
{
v4 = v10++;
src[v4] = a1[i];
}
}
src[v10] = 0;
v14 = strlen(src);
v9 = 1;
for ( j = 0; j < v14 / 2; ++j )
{
if ( src[j] != src[v14 - 1 - j] )
{
v9 = 0;
break;
}
}
strcpy(a3, src);
if ( v9 )
v5 = "True";
else
v5 = "False";
strcpy(a4, v5);
free(src);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV qword ptr [RBP + -0x50],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
CDQE
MOV RDI,RAX
CALL 0x00101110
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24],0x0
MOV dword ptr [RBP + -0x20],0x0
JMP 0x001012cc
LAB_00101258:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x26],0x0
JMP 0x0010128c
LAB_00101266:
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JNZ 0x00101287
MOV byte ptr [RBP + -0x26],0x1
JMP 0x00101297
LAB_00101287:
ADD qword ptr [RBP + -0x10],0x1
LAB_0010128c:
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101266
LAB_00101297:
MOVZX EAX,byte ptr [RBP + -0x26]
XOR EAX,0x1
TEST AL,AL
JZ 0x001012c8
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x24]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x24],EDX
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
LAB_001012c8:
ADD dword ptr [RBP + -0x20],0x1
LAB_001012cc:
MOV EAX,dword ptr [RBP + -0x20]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101258
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010d0
MOV dword ptr [RBP + -0x14],EAX
MOV byte ptr [RBP + -0x25],0x1
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101344
LAB_00101310:
MOV EAX,dword ptr [RBP + -0x1c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOVZX EDX,byte ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
SUB EAX,dword ptr [RBP + -0x1c]
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOVZX EAX,byte ptr [RAX]
CMP DL,AL
JZ 0x00101340
MOV byte ptr [RBP + -0x25],0x0
JMP 0x00101355
LAB_00101340:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101344:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JL 0x00101310
LAB_00101355:
MOV RDX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010c0
CMP byte ptr [RBP + -0x25],0x0
JZ 0x00101377
LEA RAX,[0x102008]
JMP 0x0010137e
LAB_00101377:
LEA RAX,[0x10200d]
LAB_0010137e:
MOV RDX,qword ptr [RBP + -0x50]
MOV RSI,RAX
MOV RDI,RDX
CALL 0x001010c0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x001010b0
NOP
LEAVE
RET
|
void func0(char *param_1,char *param_2,char *param_3,char *param_4)
{
bool bVar1;
size_t sVar2;
char *__s;
char *__src;
int local_2c;
int local_28;
int local_24;
char *local_18;
sVar2 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar2 + 1));
local_2c = 0;
for (local_28 = 0; param_1[local_28] != '\0'; local_28 = local_28 + 1) {
bVar1 = false;
for (local_18 = param_2; *local_18 != '\0'; local_18 = local_18 + 1) {
if (param_1[local_28] == *local_18) {
bVar1 = true;
break;
}
}
if (!bVar1) {
__s[local_2c] = param_1[local_28];
local_2c = local_2c + 1;
}
}
__s[local_2c] = '\0';
sVar2 = strlen(__s);
bVar1 = true;
local_24 = 0;
do {
if ((int)sVar2 / 2 <= local_24) {
LAB_00101355:
strcpy(param_3,__s);
if (bVar1) {
__src = "True";
}
else {
__src = "False";
}
strcpy(param_4,__src);
free(__s);
return;
}
if (__s[local_24] != __s[((int)sVar2 + -1) - local_24]) {
bVar1 = false;
goto LAB_00101355;
}
local_24 = local_24 + 1;
} while( true );
}
|
1,105 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *temp) {
found = true;
break;
}
temp++;
}
if (!found) {
n[ni++] = s[i];
}
}
n[ni] = '\0';
int n_len = strlen(n);
bool is_palindrome = true;
for (int i = 0; i < n_len / 2; i++) {
if (n[i] != n[n_len - 1 - i]) {
is_palindrome = false;
break;
}
}
strcpy(result, n);
strcpy(palindrome, is_palindrome ? "True" : "False");
free(n);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdedcba", "ab", result, palindrome);
assert(strcmp(result, "cdedc") == 0 && strcmp(palindrome, "True") == 0);
func0("dwik", "w", result, palindrome);
assert(strcmp(result, "dik") == 0 && strcmp(palindrome, "False") == 0);
func0("a", "a", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "v", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("vabba", "v", result, palindrome);
assert(strcmp(result, "abba") == 0 && strcmp(palindrome, "True") == 0);
func0("mamma", "mia", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r14
mov %rsi,%rbp
mov %rdx,%r13
mov %rcx,%r12
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %ecx,%eax
not %eax
movslq %eax,%rdi
callq 10d0 <malloc@plt>
mov %rax,%rbx
movzbl (%r14),%ecx
test %cl,%cl
je 121c <func0+0x53>
movzbl 0x0(%rbp),%r8d
lea 0x1(%r14),%rsi
mov $0x0,%edi
mov %r8d,%r9d
jmpq 12ca <func0+0x101>
mov $0x0,%edi
movslq %edi,%rdi
movb $0x0,(%rbx,%rdi,1)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
mov %rbx,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
sub $0x1,%rax
mov %eax,%ecx
shr $0x1f,%ecx
add %eax,%ecx
sar %ecx
cmp $0x1,%eax
jle 1272 <func0+0xa9>
cltq
lea -0x1(%rbx,%rax,1),%rdx
mov $0x0,%eax
movzbl (%rdx),%esi
cmp %sil,(%rbx,%rax,1)
jne 129d <func0+0xd4>
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%ecx
jg 125d <func0+0x94>
mov %rbx,%rsi
mov %r13,%rdi
callq 10a0 <strcpy@plt>
lea 0xd86(%rip),%rsi
mov %r12,%rdi
callq 10a0 <strcpy@plt>
mov %rbx,%rdi
callq 1090 <free@plt>
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
mov %rbx,%rsi
mov %r13,%rdi
callq 10a0 <strcpy@plt>
lea 0xd55(%rip),%rsi
jmp 1284 <func0+0xbb>
movslq %edi,%rax
mov %cl,(%rbx,%rax,1)
lea 0x1(%rdi),%edi
add $0x1,%rsi
movzbl -0x1(%rsi),%ecx
test %cl,%cl
je 1221 <func0+0x58>
mov %rbp,%rdx
mov %r9d,%eax
test %r8b,%r8b
je 12b1 <func0+0xe8>
cmp %cl,%al
je 12ba <func0+0xf1>
add $0x1,%rdx
movzbl (%rdx),%eax
test %al,%al
jne 12d5 <func0+0x10c>
jmp 12b1 <func0+0xe8>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r14, rdi
mov rbp, rsi
mov r13, rdx
mov r12, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
mov rbx, rax
movzx ecx, byte ptr [r14]
test cl, cl
jz short loc_127D
movzx edi, byte ptr [rbp+0]
lea rsi, [r14+1]
mov r8d, 0
jmp short loc_1262
loc_124C:
movsxd rax, r8d
mov [rbx+rax], cl
lea r8d, [r8+1]
loc_1256:
add rsi, 1
movzx ecx, byte ptr [rsi-1]
test cl, cl
jz short loc_1283
loc_1262:
mov rdx, rbp
mov eax, edi
test dil, dil
jz short loc_124C
loc_126C:
cmp al, cl
jz short loc_1256
add rdx, 1
movzx eax, byte ptr [rdx]
test al, al
jnz short loc_126C
jmp short loc_124C
loc_127D:
mov r8d, 0
loc_1283:
movsxd r8, r8d
mov byte ptr [rbx+r8], 0
mov rdi, rbx; s
call _strlen
mov ecx, eax
shr ecx, 1Fh
add ecx, eax
sar ecx, 1
cmp eax, 1
jle short loc_12D6
cdqe
lea rdx, [rbx+rax-1]
mov eax, 0
loc_12AD:
movzx esi, byte ptr [rdx]
cmp [rbx+rax], sil
jnz short loc_12EA
add rax, 1
sub rdx, 1
cmp ecx, eax
jg short loc_12AD
mov rsi, rbx; src
mov rdi, r13; dest
call _strcpy
lea rsi, aTrue; "True"
jmp short loc_12FC
loc_12D6:
mov rsi, rbx; src
mov rdi, r13; dest
call _strcpy
lea rsi, aTrue; "True"
jmp short loc_12FC
loc_12EA:
mov rsi, rbx; src
mov rdi, r13; dest
call _strcpy
lea rsi, src; "False"
loc_12FC:
mov rdi, r12; dest
call _strcpy
mov rdi, rbx; ptr
call _free
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
|
void func0(const char *a1, _BYTE *a2, char *a3, char *a4)
{
int v8; // eax
char *v9; // rbx
char v10; // cl
char v11; // di
char *v12; // rsi
int v13; // r8d
_BYTE *v14; // rdx
char v15; // al
int v16; // eax
int v17; // ecx
char *v18; // rdx
long long v19; // rax
const char *v20; // rsi
v8 = strlen(a1);
v9 = (char *)malloc(v8 + 1);
v10 = *a1;
if ( *a1 )
{
v11 = *a2;
v12 = (char *)(a1 + 1);
v13 = 0;
do
{
v14 = a2;
v15 = v11;
if ( v11 )
{
while ( v15 != v10 )
{
v15 = *++v14;
if ( !*v14 )
goto LABEL_3;
}
}
else
{
LABEL_3:
v9[v13++] = v10;
}
v10 = *v12++;
}
while ( v10 );
}
else
{
v13 = 0;
}
v9[v13] = 0;
v16 = strlen(v9);
v17 = v16 / 2;
if ( v16 <= 1 )
{
LABEL_14:
strcpy(a3, v9);
v20 = "True";
}
else
{
v18 = &v9[v16 - 1];
v19 = 0LL;
while ( v9[v19] == *v18 )
{
++v19;
--v18;
if ( v17 <= (int)v19 )
goto LABEL_14;
}
strcpy(a3, v9);
v20 = "False";
}
strcpy(a4, v20);
free(v9);
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R14,RDI
MOV RBP,RSI
MOV R13,RDX
MOV R12,RCX
CALL 0x001010d0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101110
MOV RBX,RAX
MOVZX ECX,byte ptr [R14]
TEST CL,CL
JZ 0x0010127d
MOVZX EDI,byte ptr [RBP]
LEA RSI,[R14 + 0x1]
MOV R8D,0x0
JMP 0x00101262
LAB_0010124c:
MOVSXD RAX,R8D
MOV byte ptr [RBX + RAX*0x1],CL
LEA R8D,[R8 + 0x1]
LAB_00101256:
ADD RSI,0x1
MOVZX ECX,byte ptr [RSI + -0x1]
TEST CL,CL
JZ 0x00101283
LAB_00101262:
MOV RDX,RBP
MOV EAX,EDI
TEST DIL,DIL
JZ 0x0010124c
LAB_0010126c:
CMP AL,CL
JZ 0x00101256
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX]
TEST AL,AL
JNZ 0x0010126c
JMP 0x0010124c
LAB_0010127d:
MOV R8D,0x0
LAB_00101283:
MOVSXD R8,R8D
MOV byte ptr [RBX + R8*0x1],0x0
MOV RDI,RBX
CALL 0x001010d0
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,EAX
SAR ECX,0x1
CMP EAX,0x1
JLE 0x001012d6
CDQE
LEA RDX,[RBX + RAX*0x1 + -0x1]
MOV EAX,0x0
LAB_001012ad:
MOVZX ESI,byte ptr [RDX]
CMP byte ptr [RBX + RAX*0x1],SIL
JNZ 0x001012ea
ADD RAX,0x1
SUB RDX,0x1
CMP ECX,EAX
JG 0x001012ad
MOV RSI,RBX
MOV RDI,R13
CALL 0x001010c0
LEA RSI,[0x102004]
JMP 0x001012fc
LAB_001012d6:
MOV RSI,RBX
MOV RDI,R13
CALL 0x001010c0
LEA RSI,[0x102004]
JMP 0x001012fc
LAB_001012ea:
MOV RSI,RBX
MOV RDI,R13
CALL 0x001010c0
LEA RSI,[0x102009]
LAB_001012fc:
MOV RDI,R12
CALL 0x001010c0
MOV RDI,RBX
CALL 0x001010b0
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
|
void func0(char *param_1,char *param_2,char *param_3,char *param_4)
{
char cVar1;
char cVar2;
int iVar3;
size_t sVar4;
char *__s;
long lVar5;
char cVar6;
char *pcVar7;
char *pcVar8;
sVar4 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar4 + 1));
cVar6 = *param_1;
if (cVar6 == '\0') {
iVar3 = 0;
}
else {
cVar1 = *param_2;
iVar3 = 0;
cVar2 = cVar1;
pcVar7 = param_2;
pcVar8 = param_1 + 1;
joined_r0x0010126a:
do {
if (cVar2 == '\0') {
__s[iVar3] = cVar6;
iVar3 = iVar3 + 1;
}
else if (cVar2 != cVar6) {
cVar2 = pcVar7[1];
pcVar7 = pcVar7 + 1;
goto joined_r0x0010126a;
}
cVar6 = *pcVar8;
cVar2 = cVar1;
pcVar7 = param_2;
pcVar8 = pcVar8 + 1;
} while (cVar6 != '\0');
}
__s[iVar3] = '\0';
sVar4 = strlen(__s);
iVar3 = (int)sVar4;
if (iVar3 < 2) {
strcpy(param_3,__s);
pcVar7 = "True";
}
else {
pcVar7 = __s + (long)iVar3 + -1;
lVar5 = 0;
do {
if (__s[lVar5] != *pcVar7) {
strcpy(param_3,__s);
pcVar7 = "False";
goto LAB_001012fc;
}
lVar5 = lVar5 + 1;
pcVar7 = pcVar7 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar4 >> 0x1f) & 1) + iVar3) >> 1);
strcpy(param_3,__s);
pcVar7 = "True";
}
LAB_001012fc:
strcpy(param_4,pcVar7);
free(__s);
return;
}
|
1,106 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *temp) {
found = true;
break;
}
temp++;
}
if (!found) {
n[ni++] = s[i];
}
}
n[ni] = '\0';
int n_len = strlen(n);
bool is_palindrome = true;
for (int i = 0; i < n_len / 2; i++) {
if (n[i] != n[n_len - 1 - i]) {
is_palindrome = false;
break;
}
}
strcpy(result, n);
strcpy(palindrome, is_palindrome ? "True" : "False");
free(n);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdedcba", "ab", result, palindrome);
assert(strcmp(result, "cdedc") == 0 && strcmp(palindrome, "True") == 0);
func0("dwik", "w", result, palindrome);
assert(strcmp(result, "dik") == 0 && strcmp(palindrome, "False") == 0);
func0("a", "a", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "v", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("vabba", "v", result, palindrome);
assert(strcmp(result, "abba") == 0 && strcmp(palindrome, "True") == 0);
func0("mamma", "mia", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
callq 10d0 <strlen@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1110 <malloc@plt>
movzbl (%rbx),%ecx
mov %rax,%r13
test %cl,%cl
je 15f5 <func0+0x75>
movzbl (%r14),%r9d
lea 0x1(%rbx),%rdi
xor %r8d,%r8d
nopl (%rax)
mov %r14,%rdx
mov %r9d,%eax
test %r9b,%r9b
jne 15e0 <func0+0x60>
jmpq 1698 <func0+0x118>
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
je 1698 <func0+0x118>
cmp %al,%cl
jne 15d0 <func0+0x50>
movzbl (%rdi),%ecx
add $0x1,%rdi
test %cl,%cl
jne 15c0 <func0+0x40>
movslq %r8d,%rax
add %r13,%rax
movb $0x0,(%rax)
mov %r13,%rcx
mov (%rcx),%edx
add $0x4,%rcx
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 15fb <func0+0x7b>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rcx),%rdx
cmove %rdx,%rcx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rcx
sub %r13,%rcx
mov %ecx,%esi
shr $0x1f,%esi
add %ecx,%esi
sar %esi
cmp $0x1,%ecx
jle 16b9 <func0+0x139>
lea -0x1(%rcx),%edx
xor %eax,%eax
movslq %edx,%rdx
add %r13,%rdx
jmp 165c <func0+0xdc>
nopl (%rax)
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%esi
jle 16b9 <func0+0x139>
movzbl (%rdx),%ebx
cmp %bl,0x0(%r13,%rax,1)
je 1650 <func0+0xd0>
mov %r13,%rsi
lea 0x1(%rcx),%rdx
mov %r12,%rdi
callq 1100 <memcpy@plt>
lea 0x988(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <strcpy@plt>
pop %rbx
mov %r13,%rdi
pop %rbp
pop %r12
pop %r13
pop %r14
jmpq 10b0 <free@plt>
nopl 0x0(%rax)
movslq %r8d,%rax
add $0x1,%rdi
add $0x1,%r8d
mov %cl,0x0(%r13,%rax,1)
movzbl -0x1(%rdi),%ecx
test %cl,%cl
jne 15c0 <func0+0x40>
jmpq 15ef <func0+0x6f>
mov %r13,%rsi
lea 0x1(%rcx),%rdx
mov %r12,%rdi
callq 1100 <memcpy@plt>
lea 0x93b(%rip),%rsi
jmp 167c <func0+0xfc>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
movzx ecx, byte ptr [r13+0]
mov r12, rax
test cl, cl
jz short loc_1605
movzx r8d, byte ptr [r14]
lea rsi, [r13+1]
xor edi, edi
xchg ax, ax
loc_15D0:
mov rdx, r14
mov eax, r8d
test r8b, r8b
jnz short loc_15F0
jmp loc_1678
loc_15E0:
movzx eax, byte ptr [rdx+1]
add rdx, 1
test al, al
jz loc_1678
loc_15F0:
cmp al, cl
jnz short loc_15E0
movzx ecx, byte ptr [rsi]
add rsi, 1
test cl, cl
jnz short loc_15D0
loc_15FF:
movsxd rax, edi
add rax, r12
loc_1605:
mov byte ptr [rax], 0
mov rdi, r12; s
call _strlen
mov esi, eax
shr esi, 1Fh
add esi, eax
sar esi, 1
cmp eax, 1
jle short loc_1697
lea ecx, [rax-1]
xor edx, edx
movsxd rcx, ecx
add rcx, r12
jmp short loc_163C
loc_1630:
add rdx, 1
sub rcx, 1
cmp esi, edx
jle short loc_1697
loc_163C:
movzx edi, byte ptr [rcx]
cmp [r12+rdx], dil
jz short loc_1630
mov rsi, r12; src
lea rdx, [rax+1]; n
mov rdi, rbp; dest
call _memcpy
lea rsi, src; "False"
loc_165B:
mov rdi, rbx; dest
call _strcpy
pop rbx
mov rdi, r12; ptr
pop rbp
pop r12
pop r13
pop r14
jmp _free
loc_1678:
movsxd rax, edi
add rsi, 1
add edi, 1
mov [r12+rax], cl
movzx ecx, byte ptr [rsi-1]
test cl, cl
jnz loc_15D0
jmp loc_15FF
loc_1697:
mov rsi, r12; src
lea rdx, [rax+1]; n
mov rdi, rbp; dest
call _memcpy
lea rsi, aTrue; "True"
jmp short loc_165B
|
void func0(const char *a1, _BYTE *a2, void *a3, char *a4)
{
int v7; // eax
char *v8; // rax
char v9; // cl
char *v10; // r12
char v11; // r8
char *v12; // rsi
int v13; // edi
_BYTE *v14; // rdx
char v15; // al
size_t v16; // rax
long long v17; // rdx
char *v18; // rcx
const char *v19; // rsi
long long v20; // rax
v7 = strlen(a1);
v8 = (char *)malloc(v7 + 1);
v9 = *a1;
v10 = v8;
if ( *a1 )
{
v11 = *a2;
v12 = (char *)(a1 + 1);
v13 = 0;
do
{
while ( 1 )
{
v14 = a2;
v15 = v11;
if ( v11 )
break;
LABEL_15:
v20 = v13;
++v12;
++v13;
v10[v20] = v9;
v9 = *(v12 - 1);
if ( !v9 )
goto LABEL_8;
}
while ( v15 != v9 )
{
v15 = *++v14;
if ( !v15 )
goto LABEL_15;
}
v9 = *v12++;
}
while ( v9 );
LABEL_8:
v8 = &v10[v13];
}
*v8 = 0;
v16 = strlen(v10);
if ( (int)v16 <= 1 )
{
LABEL_17:
memcpy(a3, v10, v16 + 1);
v19 = "True";
}
else
{
v17 = 0LL;
v18 = &v10[(int)v16 - 1];
while ( v10[v17] == *v18 )
{
++v17;
--v18;
if ( (int)v16 / 2 <= (int)v17 )
goto LABEL_17;
}
memcpy(a3, v10, v16 + 1);
v19 = "False";
}
strcpy(a4, v19);
free(v10);
}
|
func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101130
MOVZX ECX,byte ptr [R13]
MOV R12,RAX
TEST CL,CL
JZ 0x00101605
MOVZX R8D,byte ptr [R14]
LEA RSI,[R13 + 0x1]
XOR EDI,EDI
NOP
LAB_001015d0:
MOV RDX,R14
MOV EAX,R8D
TEST R8B,R8B
JNZ 0x001015f0
JMP 0x00101678
LAB_001015e0:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JZ 0x00101678
LAB_001015f0:
CMP AL,CL
JNZ 0x001015e0
MOVZX ECX,byte ptr [RSI]
ADD RSI,0x1
TEST CL,CL
JNZ 0x001015d0
LAB_001015ff:
MOVSXD RAX,EDI
ADD RAX,R12
LAB_00101605:
MOV byte ptr [RAX],0x0
MOV RDI,R12
CALL 0x001010e0
MOV ESI,EAX
SHR ESI,0x1f
ADD ESI,EAX
SAR ESI,0x1
CMP EAX,0x1
JLE 0x00101697
LEA ECX,[RAX + -0x1]
XOR EDX,EDX
MOVSXD RCX,ECX
ADD RCX,R12
JMP 0x0010163c
LAB_00101630:
ADD RDX,0x1
SUB RCX,0x1
CMP ESI,EDX
JLE 0x00101697
LAB_0010163c:
MOVZX EDI,byte ptr [RCX]
CMP byte ptr [R12 + RDX*0x1],DIL
JZ 0x00101630
MOV RSI,R12
LEA RDX,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101120
LEA RSI,[0x102009]
LAB_0010165b:
MOV RDI,RBX
CALL 0x001010d0
POP RBX
MOV RDI,R12
POP RBP
POP R12
POP R13
POP R14
JMP 0x001010c0
LAB_00101678:
MOVSXD RAX,EDI
ADD RSI,0x1
ADD EDI,0x1
MOV byte ptr [R12 + RAX*0x1],CL
MOVZX ECX,byte ptr [RSI + -0x1]
TEST CL,CL
JNZ 0x001015d0
JMP 0x001015ff
LAB_00101697:
MOV RSI,R12
LEA RDX,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101120
LEA RSI,[0x102004]
JMP 0x0010165b
|
void func0(char *param_1,char *param_2,void *param_3,char *param_4)
{
char cVar1;
char cVar2;
size_t sVar3;
char *__s;
char *pcVar4;
long lVar5;
char cVar6;
char *pcVar7;
int iVar8;
sVar3 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar3 + 1));
cVar6 = *param_1;
pcVar4 = __s;
if (cVar6 != '\0') {
cVar1 = *param_2;
iVar8 = 0;
cVar2 = cVar1;
pcVar4 = param_2;
pcVar7 = param_1 + 1;
do {
while( true ) {
while (cVar2 == '\0') {
lVar5 = (long)iVar8;
iVar8 = iVar8 + 1;
__s[lVar5] = cVar6;
cVar6 = *pcVar7;
cVar2 = cVar1;
pcVar4 = param_2;
pcVar7 = pcVar7 + 1;
if (cVar6 == '\0') goto LAB_001015ff;
}
if (cVar2 == cVar6) break;
cVar2 = pcVar4[1];
pcVar4 = pcVar4 + 1;
}
cVar6 = *pcVar7;
pcVar7 = pcVar7 + 1;
cVar2 = cVar1;
pcVar4 = param_2;
} while (cVar6 != '\0');
LAB_001015ff:
pcVar4 = __s + iVar8;
}
*pcVar4 = '\0';
sVar3 = strlen(__s);
iVar8 = (int)sVar3;
if (1 < iVar8) {
lVar5 = 0;
pcVar4 = __s + (iVar8 + -1);
do {
if (__s[lVar5] != *pcVar4) {
memcpy(param_3,__s,sVar3 + 1);
pcVar4 = "False";
goto LAB_0010165b;
}
lVar5 = lVar5 + 1;
pcVar4 = pcVar4 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar8) >> 1);
}
memcpy(param_3,__s,sVar3 + 1);
pcVar4 = "True";
LAB_0010165b:
strcpy(param_4,pcVar4);
free(__s);
return;
}
|
1,107 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
|
void func0(const char *s, const char *c, char *result, char *palindrome) {
int len = strlen(s);
char *n = malloc((len + 1) * sizeof(char));
int ni = 0;
for (int i = 0; s[i] != '\0'; i++) {
const char *temp = c;
bool found = false;
while (*temp != '\0') {
if (s[i] == *temp) {
found = true;
break;
}
temp++;
}
if (!found) {
n[ni++] = s[i];
}
}
n[ni] = '\0';
int n_len = strlen(n);
bool is_palindrome = true;
for (int i = 0; i < n_len / 2; i++) {
if (n[i] != n[n_len - 1 - i]) {
is_palindrome = false;
break;
}
}
strcpy(result, n);
strcpy(palindrome, is_palindrome ? "True" : "False");
free(n);
}
|
#include <assert.h>
#include <string.h>
int main() {
char result[100];
char palindrome[6];
func0("abcde", "ae", result, palindrome);
assert(strcmp(result, "bcd") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdef", "b", result, palindrome);
assert(strcmp(result, "acdef") == 0 && strcmp(palindrome, "False") == 0);
func0("abcdedcba", "ab", result, palindrome);
assert(strcmp(result, "cdedc") == 0 && strcmp(palindrome, "True") == 0);
func0("dwik", "w", result, palindrome);
assert(strcmp(result, "dik") == 0 && strcmp(palindrome, "False") == 0);
func0("a", "a", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("abcdedcba", "v", result, palindrome);
assert(strcmp(result, "abcdedcba") == 0 && strcmp(palindrome, "True") == 0);
func0("vabba", "v", result, palindrome);
assert(strcmp(result, "abba") == 0 && strcmp(palindrome, "True") == 0);
func0("mamma", "mia", result, palindrome);
assert(strcmp(result, "") == 0 && strcmp(palindrome, "True") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdx,%r12
push %rbp
mov %rcx,%rbp
push %rbx
mov %rdi,%rbx
callq 10d0 <strlen@plt>
lea 0x1(%rax),%edi
movslq %edi,%rdi
callq 1110 <malloc@plt>
movzbl (%rbx),%ecx
mov %rax,%r13
test %cl,%cl
je 15f5 <func0+0x75>
movzbl (%r14),%r9d
lea 0x1(%rbx),%rdi
xor %r8d,%r8d
nopl (%rax)
mov %r14,%rdx
mov %r9d,%eax
test %r9b,%r9b
jne 15e0 <func0+0x60>
jmpq 1698 <func0+0x118>
movzbl 0x1(%rdx),%eax
add $0x1,%rdx
test %al,%al
je 1698 <func0+0x118>
cmp %al,%cl
jne 15d0 <func0+0x50>
movzbl (%rdi),%ecx
add $0x1,%rdi
test %cl,%cl
jne 15c0 <func0+0x40>
movslq %r8d,%rax
add %r13,%rax
movb $0x0,(%rax)
mov %r13,%rcx
mov (%rcx),%edx
add $0x4,%rcx
lea -0x1010101(%rdx),%eax
not %edx
and %edx,%eax
and $0x80808080,%eax
je 15fb <func0+0x7b>
mov %eax,%edx
shr $0x10,%edx
test $0x8080,%eax
cmove %edx,%eax
lea 0x2(%rcx),%rdx
cmove %rdx,%rcx
mov %eax,%ebx
add %al,%bl
sbb $0x3,%rcx
sub %r13,%rcx
mov %ecx,%esi
shr $0x1f,%esi
add %ecx,%esi
sar %esi
cmp $0x1,%ecx
jle 16b9 <func0+0x139>
lea -0x1(%rcx),%edx
xor %eax,%eax
movslq %edx,%rdx
add %r13,%rdx
jmp 165c <func0+0xdc>
nopl (%rax)
add $0x1,%rax
sub $0x1,%rdx
cmp %eax,%esi
jle 16b9 <func0+0x139>
movzbl (%rdx),%ebx
cmp %bl,0x0(%r13,%rax,1)
je 1650 <func0+0xd0>
mov %r13,%rsi
lea 0x1(%rcx),%rdx
mov %r12,%rdi
callq 1100 <memcpy@plt>
lea 0x988(%rip),%rsi
mov %rbp,%rdi
callq 10c0 <strcpy@plt>
pop %rbx
mov %r13,%rdi
pop %rbp
pop %r12
pop %r13
pop %r14
jmpq 10b0 <free@plt>
nopl 0x0(%rax)
movslq %r8d,%rax
add $0x1,%rdi
add $0x1,%r8d
mov %cl,0x0(%r13,%rax,1)
movzbl -0x1(%rdi),%ecx
test %cl,%cl
jne 15c0 <func0+0x40>
jmpq 15ef <func0+0x6f>
mov %r13,%rsi
lea 0x1(%rcx),%rdx
mov %r12,%rdi
callq 1100 <memcpy@plt>
lea 0x93b(%rip),%rsi
jmp 167c <func0+0xfc>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r14
mov r14, rsi
push r13
mov r13, rdi
push r12
push rbp
mov rbp, rdx
push rbx
mov rbx, rcx
call _strlen
lea edi, [rax+1]
movsxd rdi, edi; size
call _malloc
movzx ecx, byte ptr [r13+0]
mov r12, rax
test cl, cl
jz short loc_1605
movzx r8d, byte ptr [r14]
lea rsi, [r13+1]
xor edi, edi
xchg ax, ax
loc_15D0:
mov rdx, r14
mov eax, r8d
test r8b, r8b
jnz short loc_15F0
jmp loc_1678
loc_15E0:
movzx eax, byte ptr [rdx+1]
add rdx, 1
test al, al
jz loc_1678
loc_15F0:
cmp al, cl
jnz short loc_15E0
movzx ecx, byte ptr [rsi]
add rsi, 1
test cl, cl
jnz short loc_15D0
loc_15FF:
movsxd rax, edi
add rax, r12
loc_1605:
mov byte ptr [rax], 0
mov rdi, r12; s
call _strlen
mov esi, eax
shr esi, 1Fh
add esi, eax
sar esi, 1
cmp eax, 1
jle short loc_1697
lea ecx, [rax-1]
xor edx, edx
movsxd rcx, ecx
add rcx, r12
jmp short loc_163C
loc_1630:
add rdx, 1
sub rcx, 1
cmp esi, edx
jle short loc_1697
loc_163C:
movzx edi, byte ptr [rcx]
cmp [r12+rdx], dil
jz short loc_1630
mov rsi, r12; src
lea rdx, [rax+1]; n
mov rdi, rbp; dest
call _memcpy
lea rsi, src; "False"
loc_165B:
mov rdi, rbx; dest
call _strcpy
pop rbx
mov rdi, r12; ptr
pop rbp
pop r12
pop r13
pop r14
jmp _free
loc_1678:
movsxd rax, edi
add rsi, 1
add edi, 1
mov [r12+rax], cl
movzx ecx, byte ptr [rsi-1]
test cl, cl
jnz loc_15D0
jmp loc_15FF
loc_1697:
mov rsi, r12; src
lea rdx, [rax+1]; n
mov rdi, rbp; dest
call _memcpy
lea rsi, aTrue; "True"
jmp short loc_165B
|
void func0(const char *a1, _BYTE *a2, void *a3, char *a4)
{
int v7; // eax
char *v8; // rax
char v9; // cl
char *v10; // r12
char v11; // r8
char *v12; // rsi
int v13; // edi
_BYTE *v14; // rdx
char v15; // al
size_t v16; // rax
long long v17; // rdx
char *v18; // rcx
const char *v19; // rsi
long long v20; // rax
v7 = strlen(a1);
v8 = (char *)malloc(v7 + 1);
v9 = *a1;
v10 = v8;
if ( *a1 )
{
v11 = *a2;
v12 = (char *)(a1 + 1);
v13 = 0;
do
{
while ( 1 )
{
v14 = a2;
v15 = v11;
if ( v11 )
break;
LABEL_15:
v20 = v13;
++v12;
++v13;
v10[v20] = v9;
v9 = *(v12 - 1);
if ( !v9 )
goto LABEL_8;
}
while ( v15 != v9 )
{
v15 = *++v14;
if ( !v15 )
goto LABEL_15;
}
v9 = *v12++;
}
while ( v9 );
LABEL_8:
v8 = &v10[v13];
}
*v8 = 0;
v16 = strlen(v10);
if ( (int)v16 <= 1 )
{
LABEL_17:
memcpy(a3, v10, v16 + 1);
v19 = "True";
}
else
{
v17 = 0LL;
v18 = &v10[(int)v16 - 1];
while ( v10[v17] == *v18 )
{
++v17;
--v18;
if ( (int)v16 / 2 <= (int)v17 )
goto LABEL_17;
}
memcpy(a3, v10, v16 + 1);
v19 = "False";
}
strcpy(a4, v19);
free(v10);
}
|
func0:
ENDBR64
PUSH R14
MOV R14,RSI
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV RBX,RCX
CALL 0x001010e0
LEA EDI,[RAX + 0x1]
MOVSXD RDI,EDI
CALL 0x00101130
MOVZX ECX,byte ptr [R13]
MOV R12,RAX
TEST CL,CL
JZ 0x00101605
MOVZX R8D,byte ptr [R14]
LEA RSI,[R13 + 0x1]
XOR EDI,EDI
NOP
LAB_001015d0:
MOV RDX,R14
MOV EAX,R8D
TEST R8B,R8B
JNZ 0x001015f0
JMP 0x00101678
LAB_001015e0:
MOVZX EAX,byte ptr [RDX + 0x1]
ADD RDX,0x1
TEST AL,AL
JZ 0x00101678
LAB_001015f0:
CMP AL,CL
JNZ 0x001015e0
MOVZX ECX,byte ptr [RSI]
ADD RSI,0x1
TEST CL,CL
JNZ 0x001015d0
LAB_001015ff:
MOVSXD RAX,EDI
ADD RAX,R12
LAB_00101605:
MOV byte ptr [RAX],0x0
MOV RDI,R12
CALL 0x001010e0
MOV ESI,EAX
SHR ESI,0x1f
ADD ESI,EAX
SAR ESI,0x1
CMP EAX,0x1
JLE 0x00101697
LEA ECX,[RAX + -0x1]
XOR EDX,EDX
MOVSXD RCX,ECX
ADD RCX,R12
JMP 0x0010163c
LAB_00101630:
ADD RDX,0x1
SUB RCX,0x1
CMP ESI,EDX
JLE 0x00101697
LAB_0010163c:
MOVZX EDI,byte ptr [RCX]
CMP byte ptr [R12 + RDX*0x1],DIL
JZ 0x00101630
MOV RSI,R12
LEA RDX,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101120
LEA RSI,[0x102009]
LAB_0010165b:
MOV RDI,RBX
CALL 0x001010d0
POP RBX
MOV RDI,R12
POP RBP
POP R12
POP R13
POP R14
JMP 0x001010c0
LAB_00101678:
MOVSXD RAX,EDI
ADD RSI,0x1
ADD EDI,0x1
MOV byte ptr [R12 + RAX*0x1],CL
MOVZX ECX,byte ptr [RSI + -0x1]
TEST CL,CL
JNZ 0x001015d0
JMP 0x001015ff
LAB_00101697:
MOV RSI,R12
LEA RDX,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101120
LEA RSI,[0x102004]
JMP 0x0010165b
|
void func0(char *param_1,char *param_2,void *param_3,char *param_4)
{
char cVar1;
char cVar2;
size_t sVar3;
char *__s;
char *pcVar4;
long lVar5;
char cVar6;
char *pcVar7;
int iVar8;
sVar3 = strlen(param_1);
__s = (char *)malloc((long)((int)sVar3 + 1));
cVar6 = *param_1;
pcVar4 = __s;
if (cVar6 != '\0') {
cVar1 = *param_2;
iVar8 = 0;
cVar2 = cVar1;
pcVar4 = param_2;
pcVar7 = param_1 + 1;
do {
while( true ) {
while (cVar2 == '\0') {
lVar5 = (long)iVar8;
iVar8 = iVar8 + 1;
__s[lVar5] = cVar6;
cVar6 = *pcVar7;
cVar2 = cVar1;
pcVar4 = param_2;
pcVar7 = pcVar7 + 1;
if (cVar6 == '\0') goto LAB_001015ff;
}
if (cVar2 == cVar6) break;
cVar2 = pcVar4[1];
pcVar4 = pcVar4 + 1;
}
cVar6 = *pcVar7;
pcVar7 = pcVar7 + 1;
cVar2 = cVar1;
pcVar4 = param_2;
} while (cVar6 != '\0');
LAB_001015ff:
pcVar4 = __s + iVar8;
}
*pcVar4 = '\0';
sVar3 = strlen(__s);
iVar8 = (int)sVar3;
if (1 < iVar8) {
lVar5 = 0;
pcVar4 = __s + (iVar8 + -1);
do {
if (__s[lVar5] != *pcVar4) {
memcpy(param_3,__s,sVar3 + 1);
pcVar4 = "False";
goto LAB_0010165b;
}
lVar5 = lVar5 + 1;
pcVar4 = pcVar4 + -1;
} while ((int)lVar5 < (int)(((uint)(sVar3 >> 0x1f) & 1) + iVar8) >> 1);
}
memcpy(param_3,__s,sVar3 + 1);
pcVar4 = "True";
LAB_0010165b:
strcpy(param_4,pcVar4);
free(__s);
return;
}
|
1,108 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
out[i] = malloc(100); // Assuming the string will not be longer than 99 characters.
sprintf(out[i], "the number of odd elements %d in the string %d of the %d input.", sum, sum, sum);
}
return out;
}
|
#include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number of odd elements 4 in the string 4 of the 4 input."};
char **result1 = func0(input1, 1);
assert(issame(result1, expected1, 1));
char *input2[] = {"3", "11111111"};
char *expected2[] = {
"the number of odd elements 1 in the string 1 of the 1 input.",
"the number of odd elements 8 in the string 8 of the 8 input."
};
char **result2 = func0(input2, 2);
assert(issame(result2, expected2, 2));
char *input3[] = {"271", "137", "314"};
char *expected3[] = {
"the number of odd elements 2 in the string 2 of the 2 input.",
"the number of odd elements 3 in the string 3 of the 3 input.",
"the number of odd elements 2 in the string 2 of the 2 input."
};
char **result3 = func0(input3, 3);
assert(issame(result3, expected3, 3));
// Free the allocated memory
for (int i = 0; i < 1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov -0x3c(%rbp),%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 10e0 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x24(%rbp)
jmpq 134a <func0+0x161>
movl $0x0,-0x20(%rbp)
movl $0x0,-0x1c(%rbp)
jmpq 12c3 <func0+0xda>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 12bf <func0+0xd6>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jg 12bf <func0+0xd6>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
lea -0x30(%rax),%edx
mov %edx,%eax
sar $0x1f,%eax
shr $0x1f,%eax
add %eax,%edx
and $0x1,%edx
sub %eax,%edx
mov %edx,%eax
cmp $0x1,%eax
jne 12bf <func0+0xd6>
addl $0x1,-0x20(%rbp)
addl $0x1,-0x1c(%rbp)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x1c(%rbp),%eax
cltq
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1231 <func0+0x48>
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
lea (%rdx,%rax,1),%rbx
mov $0x64,%edi
callq 10e0 <malloc@plt>
mov %rax,(%rbx)
mov -0x24(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x20(%rbp),%esi
mov -0x20(%rbp),%ecx
mov -0x20(%rbp),%edx
mov %esi,%r8d
lea 0xccf(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 10f0 <sprintf@plt>
addl $0x1,-0x24(%rbp)
mov -0x24(%rbp),%eax
cmp -0x3c(%rbp),%eax
jl 121e <func0+0x35>
mov -0x18(%rbp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov eax, [rbp+var_3C]
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_18], rax
mov [rbp+var_24], 0
jmp loc_134A
loc_121E:
mov [rbp+var_20], 0
mov [rbp+var_1C], 0
jmp loc_12C3
loc_1231:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_12BF
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jg short loc_12BF
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
lea edx, [rax-30h]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_12BF
add [rbp+var_20], 1
loc_12BF:
add [rbp+var_1C], 1
loc_12C3:
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_38]
add rax, rdx
mov rdx, [rax]
mov eax, [rbp+var_1C]
cdqe
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_1231
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
lea rbx, [rdx+rax]
mov edi, 64h ; 'd'; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_24]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov esi, [rbp+var_20]
mov ecx, [rbp+var_20]
mov edx, [rbp+var_20]
mov r8d, esi
lea rsi, format; "the number of odd elements %d in the st"...
mov rdi, rax; s
mov eax, 0
call _sprintf
add [rbp+var_24], 1
loc_134A:
mov eax, [rbp+var_24]
cmp eax, [rbp+var_3C]
jl loc_121E
mov rax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn
|
_QWORD * func0(long long a1, int a2)
{
int i; // [rsp+1Ch] [rbp-24h]
int v4; // [rsp+20h] [rbp-20h]
int j; // [rsp+24h] [rbp-1Ch]
_QWORD *v6; // [rsp+28h] [rbp-18h]
v6 = malloc(8LL * a2);
for ( i = 0; i < a2; ++i )
{
v4 = 0;
for ( j = 0; *(_BYTE *)(*(_QWORD *)(8LL * i + a1) + j); ++j )
{
if ( *(char *)(*(_QWORD *)(8LL * i + a1) + j) > 47
&& *(char *)(*(_QWORD *)(8LL * i + a1) + j) <= 57
&& (*(char *)(*(_QWORD *)(8LL * i + a1) + j) - 48) % 2 == 1 )
{
++v4;
}
}
v6[i] = malloc(0x64uLL);
sprintf((char *)v6[i], "the number of odd elements %d in the string %d of the %d input.", v4, v4, v4);
}
return v6;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x001010e0
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010134a
LAB_0010121e:
MOV dword ptr [RBP + -0x20],0x0
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x001012c3
LAB_00101231:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x001012bf
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JG 0x001012bf
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
LEA EDX,[RAX + -0x30]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x001012bf
ADD dword ptr [RBP + -0x20],0x1
LAB_001012bf:
ADD dword ptr [RBP + -0x1c],0x1
LAB_001012c3:
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101231
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
LEA RBX,[RDX + RAX*0x1]
MOV EDI,0x64
CALL 0x001010e0
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x24]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV ESI,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x20]
MOV EDX,dword ptr [RBP + -0x20]
MOV R8D,ESI
LEA RSI,[0x102008]
MOV RDI,RAX
MOV EAX,0x0
CALL 0x001010f0
ADD dword ptr [RBP + -0x24],0x1
LAB_0010134a:
MOV EAX,dword ptr [RBP + -0x24]
CMP EAX,dword ptr [RBP + -0x3c]
JL 0x0010121e
MOV RAX,qword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2)
{
void *pvVar1;
void *pvVar2;
int local_2c;
uint local_28;
int local_24;
pvVar1 = malloc((long)param_2 << 3);
for (local_2c = 0; local_2c < param_2; local_2c = local_2c + 1) {
local_28 = 0;
for (local_24 = 0; *(char *)((long)local_24 + *(long *)(param_1 + (long)local_2c * 8)) != '\0';
local_24 = local_24 + 1) {
if ((('/' < *(char *)((long)local_24 + *(long *)(param_1 + (long)local_2c * 8))) &&
(*(char *)((long)local_24 + *(long *)(param_1 + (long)local_2c * 8)) < ':')) &&
((*(char *)((long)local_24 + *(long *)(param_1 + (long)local_2c * 8)) + -0x30) % 2 == 1)) {
local_28 = local_28 + 1;
}
}
pvVar2 = malloc(100);
*(void **)((long)local_2c * 8 + (long)pvVar1) = pvVar2;
sprintf(*(char **)((long)pvVar1 + (long)local_2c * 8),
"the number of odd elements %d in the string %d of the %d input.",(ulong)local_28,
(ulong)local_28,(ulong)local_28);
}
return pvVar1;
}
|
1,109 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
out[i] = malloc(100); // Assuming the string will not be longer than 99 characters.
sprintf(out[i], "the number of odd elements %d in the string %d of the %d input.", sum, sum, sum);
}
return out;
}
|
#include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number of odd elements 4 in the string 4 of the 4 input."};
char **result1 = func0(input1, 1);
assert(issame(result1, expected1, 1));
char *input2[] = {"3", "11111111"};
char *expected2[] = {
"the number of odd elements 1 in the string 1 of the 1 input.",
"the number of odd elements 8 in the string 8 of the 8 input."
};
char **result2 = func0(input2, 2);
assert(issame(result2, expected2, 2));
char *input3[] = {"271", "137", "314"};
char *expected3[] = {
"the number of odd elements 2 in the string 2 of the 2 input.",
"the number of odd elements 3 in the string 3 of the 3 input.",
"the number of odd elements 2 in the string 2 of the 2 input."
};
char **result3 = func0(input3, 3);
assert(issame(result3, expected3, 3));
// Free the allocated memory
for (int i = 0; i < 1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%r13
mov %esi,%ebx
movslq %esi,%rdi
shl $0x3,%rdi
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebx,%ebx
jle 12b6 <func0+0xcd>
lea -0x1(%rbx),%r15d
mov $0x0,%ebp
lea 0xde1(%rip),%r14
jmp 129f <func0+0xb6>
add $0x1,%rdx
movzbl -0x1(%rdx),%eax
test %al,%al
je 125c <func0+0x73>
lea -0x30(%rax),%ecx
cmp $0x9,%cl
ja 1229 <func0+0x40>
movsbl %al,%eax
sub $0x30,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
cmp $0x1,%eax
sete %al
movzbl %al,%eax
add %eax,%ebx
jmp 1229 <func0+0x40>
mov $0x64,%edi
callq 10e0 <malloc@plt>
mov %rax,%rdi
mov %rax,(%r12,%rbp,8)
sub $0x8,%rsp
push %rbx
mov %ebx,%r9d
mov %ebx,%r8d
mov %r14,%rcx
mov $0x64,%edx
mov $0x1,%esi
mov $0x0,%eax
callq 10f0 <__sprintf_chk@plt>
lea 0x1(%rbp),%rax
add $0x10,%rsp
cmp %r15,%rbp
je 12b6 <func0+0xcd>
mov %rax,%rbp
mov 0x0(%r13,%rbp,8),%rdx
movzbl (%rdx),%eax
add $0x1,%rdx
mov $0x0,%ebx
test %al,%al
jne 1235 <func0+0x4c>
jmp 125c <func0+0x73>
mov %r12,%rax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r13, rdi
mov ebx, esi
movsxd r14, esi
shl r14, 3
mov rdi, r14; size
call _malloc
mov r15, rax
test ebx, ebx
jle loc_12B9
mov rbp, r13
mov r12, rax
add r13, r14
lea r14, aTheNumberOfOdd; "the number of odd elements %d in the st"...
jmp short loc_12A3
loc_122C:
add rdx, 1
movzx eax, byte ptr [rdx-1]
test al, al
jz short loc_125F
loc_1238:
lea ecx, [rax-30h]
cmp cl, 9
ja short loc_122C
movsx eax, al
sub eax, 30h ; '0'
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
cmp eax, 1
setz al
movzx eax, al
add ebx, eax
jmp short loc_122C
loc_125F:
mov edi, 64h ; 'd'; size
call _malloc
mov rdi, rax
mov [r12], rax
sub rsp, 8
push rbx
mov r9d, ebx
mov r8d, ebx
mov rcx, r14
mov edx, 64h ; 'd'
mov esi, 2
mov eax, 0
call ___sprintf_chk
add rbp, 8
add r12, 8
add rsp, 10h
cmp rbp, r13
jz short loc_12B9
loc_12A3:
mov rdx, [rbp+0]
movzx eax, byte ptr [rdx]
add rdx, 1
mov ebx, 0
test al, al
jnz short loc_1238
jmp short loc_125F
loc_12B9:
mov rax, r15
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
_QWORD * func0(char **a1, int a2)
{
_QWORD *v2; // rax
_QWORD *v3; // r15
char **v4; // rbp
_QWORD *v5; // r12
long long v6; // rdx
char v7; // al
int i; // ebx
void *v9; // rax
v2 = malloc(8LL * a2);
v3 = v2;
if ( a2 > 0 )
{
v4 = a1;
v5 = v2;
do
{
v7 = **v4;
v6 = (long long)(*v4 + 1);
for ( i = 0; v7; v7 = *(_BYTE *)(v6 - 1) )
{
if ( (unsigned __int8)(v7 - 48) <= 9u )
i += (v7 - 48) % 2 == 1;
++v6;
}
v9 = malloc(0x64uLL);
*v5 = v9;
__sprintf_chk(v9, 2LL, 100LL, "the number of odd elements %d in the string %d of the %d input.", i, i, i);
++v4;
++v5;
}
while ( v4 != &a1[a2] );
}
return v3;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV EBX,ESI
MOVSXD R14,ESI
SHL R14,0x3
MOV RDI,R14
CALL 0x001010e0
MOV R15,RAX
TEST EBX,EBX
JLE 0x001012b9
MOV RBP,R13
MOV R12,RAX
ADD R13,R14
LEA R14,[0x102008]
JMP 0x001012a3
LAB_0010122c:
ADD RDX,0x1
MOVZX EAX,byte ptr [RDX + -0x1]
TEST AL,AL
JZ 0x0010125f
LAB_00101238:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JA 0x0010122c
MOVSX EAX,AL
SUB EAX,0x30
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
CMP EAX,0x1
SETZ AL
MOVZX EAX,AL
ADD EBX,EAX
JMP 0x0010122c
LAB_0010125f:
MOV EDI,0x64
CALL 0x001010e0
MOV RDI,RAX
MOV qword ptr [R12],RAX
SUB RSP,0x8
PUSH RBX
MOV R9D,EBX
MOV R8D,EBX
MOV RCX,R14
MOV EDX,0x64
MOV ESI,0x2
MOV EAX,0x0
CALL 0x001010f0
ADD RBP,0x8
ADD R12,0x8
ADD RSP,0x10
CMP RBP,R13
JZ 0x001012b9
LAB_001012a3:
MOV RDX,qword ptr [RBP]
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
MOV EBX,0x0
TEST AL,AL
JNZ 0x00101238
JMP 0x0010125f
LAB_001012b9:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int8 * func0(int8 *param_1,int param_2)
{
char cVar1;
int8 *puVar2;
void *pvVar3;
char *pcVar4;
int iVar5;
int8 *puVar6;
int8 *puVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar7 = param_1 + param_2;
puVar6 = puVar2;
do {
pcVar4 = (char *)*param_1;
iVar5 = 0;
cVar1 = *pcVar4;
while (cVar1 != '\0') {
pcVar4 = pcVar4 + 1;
if ((byte)(cVar1 - 0x30U) < 10) {
iVar5 = iVar5 + (uint)((cVar1 + -0x30) % 2 == 1);
}
cVar1 = *pcVar4;
}
pvVar3 = malloc(100);
*puVar6 = pvVar3;
__sprintf_chk(pvVar3,2,100,"the number of odd elements %d in the string %d of the %d input.",
iVar5,iVar5,iVar5);
param_1 = param_1 + 1;
puVar6 = puVar6 + 1;
} while (param_1 != puVar7);
}
return puVar2;
}
|
1,110 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
out[i] = malloc(100); // Assuming the string will not be longer than 99 characters.
sprintf(out[i], "the number of odd elements %d in the string %d of the %d input.", sum, sum, sum);
}
return out;
}
|
#include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number of odd elements 4 in the string 4 of the 4 input."};
char **result1 = func0(input1, 1);
assert(issame(result1, expected1, 1));
char *input2[] = {"3", "11111111"};
char *expected2[] = {
"the number of odd elements 1 in the string 1 of the 1 input.",
"the number of odd elements 8 in the string 8 of the 8 input."
};
char **result2 = func0(input2, 2);
assert(issame(result2, expected2, 2));
char *input3[] = {"271", "137", "314"};
char *expected3[] = {
"the number of odd elements 2 in the string 2 of the 2 input.",
"the number of odd elements 3 in the string 3 of the 3 input.",
"the number of odd elements 2 in the string 2 of the 2 input."
};
char **result3 = func0(input3, 3);
assert(issame(result3, expected3, 3));
// Free the allocated memory
for (int i = 0; i < 1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebp,%ebp
jle 14a8 <func0+0xb8>
lea -0x1(%rbp),%r13d
xor %r14d,%r14d
lea 0xbdb(%rip),%rbp
nopl (%rax)
mov (%rbx,%r14,8),%rdx
xor %r15d,%r15d
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
je 1464 <func0+0x74>
nopw 0x0(%rax,%rax,1)
lea -0x30(%rax),%ecx
cmp $0x9,%cl
ja 1459 <func0+0x69>
and $0x1,%eax
cmp $0x1,%al
sbb $0xffffffff,%r15d
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1448 <func0+0x58>
mov $0x64,%edi
callq 10e0 <malloc@plt>
sub $0x8,%rsp
mov %rbp,%rcx
mov %r15d,%r9d
push %r15
mov %rax,%rdi
mov $0x64,%edx
mov %r15d,%r8d
mov %rax,(%r12,%r14,8)
mov $0x1,%esi
xor %eax,%eax
callq 10f0 <__sprintf_chk@plt>
pop %rdx
lea 0x1(%r14),%rax
pop %rcx
cmp %r14,%r13
je 14a8 <func0+0xb8>
mov %rax,%r14
jmp 1430 <func0+0x40>
nopl (%rax)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rbp
shl rbp, 3
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov r13, rax
test ebx, ebx
jle loc_14C4
mov rbx, rax
add rbp, r14
lea r12, aTheNumberOfOdd_4; "the number of odd elements %d in the st"...
nop
loc_1450:
mov rdx, [r14]
xor r15d, r15d
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jz short loc_1484
nop dword ptr [rax+00000000h]
loc_1468:
lea ecx, [rax-30h]
cmp cl, 9
ja short loc_1479
and eax, 1
cmp al, 1
sbb r15d, 0FFFFFFFFh
loc_1479:
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_1468
loc_1484:
mov edi, 64h ; 'd'; size
add r14, 8
add rbx, 8
call _malloc
sub rsp, 8
mov r9d, r15d
mov r8d, r15d
mov [rbx-8], rax
mov rdi, rax
mov edx, 64h ; 'd'
mov rcx, r12
push r15
mov esi, 2
xor eax, eax
call ___sprintf_chk
pop rax
pop rdx
cmp r14, rbp
jnz short loc_1450
loc_14C4:
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
void * func0(char **a1, int a2)
{
char **v2; // r14
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbx
int v6; // r15d
char v7; // al
char *i; // rdx
void *v9; // rax
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
do
{
v6 = 0;
v7 = **v2;
for ( i = *v2 + 1; v7; ++i )
{
if ( (unsigned __int8)(v7 - 48) <= 9u )
v6 -= ((v7 & 1) == 0) - 1;
v7 = *i;
}
++v2;
++v5;
v9 = malloc(0x64uLL);
*(v5 - 1) = v9;
__sprintf_chk(v9, 2LL, 100LL, "the number of odd elements %d in the string %d of the %d input.", v6, v6, v6);
}
while ( v2 != &a1[a2] );
}
return v4;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RBP
SHL RBP,0x3
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010e0
MOV R13,RAX
TEST EBX,EBX
JLE 0x001014c4
MOV RBX,RAX
ADD RBP,R14
LEA R12,[0x102008]
NOP
LAB_00101450:
MOV RDX,qword ptr [R14]
XOR R15D,R15D
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JZ 0x00101484
NOP dword ptr [RAX]
LAB_00101468:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JA 0x00101479
AND EAX,0x1
CMP AL,0x1
SBB R15D,-0x1
LAB_00101479:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x00101468
LAB_00101484:
MOV EDI,0x64
ADD R14,0x8
ADD RBX,0x8
CALL 0x001010e0
SUB RSP,0x8
MOV R9D,R15D
MOV R8D,R15D
MOV qword ptr [RBX + -0x8],RAX
MOV RDI,RAX
MOV EDX,0x64
MOV RCX,R12
PUSH R15
MOV ESI,0x2
XOR EAX,EAX
CALL 0x001010f0
POP RAX
POP RDX
CMP R14,RBP
JNZ 0x00101450
LAB_001014c4:
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int8 * func0(int8 *param_1,int param_2)
{
byte bVar1;
int8 *puVar2;
void *pvVar3;
byte *pbVar4;
int8 *puVar5;
int8 *puVar6;
int iVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar6 = param_1 + param_2;
puVar5 = puVar2;
do {
pbVar4 = (byte *)*param_1;
iVar7 = 0;
bVar1 = *pbVar4;
while (bVar1 != 0) {
pbVar4 = pbVar4 + 1;
if ((byte)(bVar1 - 0x30) < 10) {
iVar7 = (iVar7 + 1) - (uint)((bVar1 & 1) == 0);
}
bVar1 = *pbVar4;
}
param_1 = param_1 + 1;
pvVar3 = malloc(100);
*puVar5 = pvVar3;
__sprintf_chk(pvVar3,2,100,"the number of odd elements %d in the string %d of the %d input.",
iVar7,iVar7,iVar7);
puVar5 = puVar5 + 1;
} while (param_1 != puVar6);
}
return puVar2;
}
|
1,111 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
char **func0(char *lst[], int size) {
char **out = malloc(size * sizeof(char *));
for (int i = 0; i < size; i++) {
int sum = 0;
for (int j = 0; lst[i][j] != '\0'; j++) {
if (lst[i][j] >= '0' && lst[i][j] <= '9' && (lst[i][j] - '0') % 2 == 1)
sum += 1;
}
out[i] = malloc(100); // Assuming the string will not be longer than 99 characters.
sprintf(out[i], "the number of odd elements %d in the string %d of the %d input.", sum, sum, sum);
}
return out;
}
|
#include <assert.h>
#include <string.h>
#include <stdlib.h>
int issame(char **a, char **b, int size) {
for (int i = 0; i < size; i++) {
if (strcmp(a[i], b[i]) != 0) {
return 0;
}
}
return 1;
}
int main() {
char *input1[] = {"1234567"};
char *expected1[] = {"the number of odd elements 4 in the string 4 of the 4 input."};
char **result1 = func0(input1, 1);
assert(issame(result1, expected1, 1));
char *input2[] = {"3", "11111111"};
char *expected2[] = {
"the number of odd elements 1 in the string 1 of the 1 input.",
"the number of odd elements 8 in the string 8 of the 8 input."
};
char **result2 = func0(input2, 2);
assert(issame(result2, expected2, 2));
char *input3[] = {"271", "137", "314"};
char *expected3[] = {
"the number of odd elements 2 in the string 2 of the 2 input.",
"the number of odd elements 3 in the string 3 of the 3 input.",
"the number of odd elements 2 in the string 2 of the 2 input."
};
char **result3 = func0(input3, 3);
assert(issame(result3, expected3, 3));
// Free the allocated memory
for (int i = 0; i < 1; i++) free(result1[i]);
free(result1);
for (int i = 0; i < 2; i++) free(result2[i]);
free(result2);
for (int i = 0; i < 3; i++) free(result3[i]);
free(result3);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
movslq %esi,%rdi
mov %rdi,%rbp
shl $0x3,%rdi
sub $0x8,%rsp
callq 10e0 <malloc@plt>
mov %rax,%r12
test %ebp,%ebp
jle 14c8 <func0+0xb8>
lea -0x1(%rbp),%r13d
xor %r14d,%r14d
lea 0xbbb(%rip),%rbp
nopl (%rax)
mov (%rbx,%r14,8),%rdx
xor %r15d,%r15d
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
je 1484 <func0+0x74>
nopw 0x0(%rax,%rax,1)
lea -0x30(%rax),%ecx
cmp $0x9,%cl
ja 1479 <func0+0x69>
and $0x1,%eax
cmp $0x1,%al
sbb $0xffffffff,%r15d
movzbl (%rdx),%eax
add $0x1,%rdx
test %al,%al
jne 1468 <func0+0x58>
mov $0x64,%edi
callq 10e0 <malloc@plt>
sub $0x8,%rsp
mov %rbp,%rcx
mov %r15d,%r9d
push %r15
mov %rax,%rdi
mov $0x64,%edx
mov %r15d,%r8d
mov %rax,(%r12,%r14,8)
mov $0x1,%esi
xor %eax,%eax
callq 10f0 <__sprintf_chk@plt>
pop %rdx
lea 0x1(%r14),%rax
pop %rcx
cmp %r13,%r14
je 14c8 <func0+0xb8>
mov %rax,%r14
jmp 1450 <func0+0x40>
nopl (%rax)
add $0x8,%rsp
mov %r12,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
mov r14, rdi
push r13
push r12
push rbp
movsxd rbp, esi
push rbx
mov rbx, rbp
shl rbp, 3
mov rdi, rbp; size
sub rsp, 8
call _malloc
mov r13, rax
test ebx, ebx
jle loc_14C4
mov rbx, rax
add rbp, r14
lea r12, aTheNumberOfOdd_4; "the number of odd elements %d in the st"...
nop
loc_1450:
mov rdx, [r14]
xor r15d, r15d
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jz short loc_1484
nop dword ptr [rax+00000000h]
loc_1468:
lea ecx, [rax-30h]
cmp cl, 9
ja short loc_1479
and eax, 1
cmp al, 1
sbb r15d, 0FFFFFFFFh
loc_1479:
movzx eax, byte ptr [rdx]
add rdx, 1
test al, al
jnz short loc_1468
loc_1484:
mov edi, 64h ; 'd'; size
add r14, 8
add rbx, 8
call _malloc
sub rsp, 8
mov r9d, r15d
mov r8d, r15d
mov [rbx-8], rax
mov rdi, rax
mov edx, 64h ; 'd'
mov rcx, r12
push r15
mov esi, 2
xor eax, eax
call ___sprintf_chk
pop rax
pop rdx
cmp r14, rbp
jnz short loc_1450
loc_14C4:
add rsp, 8
mov rax, r13
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
void * func0(char **a1, int a2)
{
char **v2; // r14
void *v3; // rax
void *v4; // r13
_QWORD *v5; // rbx
int v6; // r15d
char v7; // al
char *i; // rdx
void *v9; // rax
v2 = a1;
v3 = malloc(8LL * a2);
v4 = v3;
if ( a2 > 0 )
{
v5 = v3;
do
{
v6 = 0;
v7 = **v2;
for ( i = *v2 + 1; v7; ++i )
{
if ( (unsigned __int8)(v7 - 48) <= 9u )
v6 -= ((v7 & 1) == 0) - 1;
v7 = *i;
}
++v2;
++v5;
v9 = malloc(0x64uLL);
*(v5 - 1) = v9;
__sprintf_chk(v9, 2LL, 100LL, "the number of odd elements %d in the string %d of the %d input.", v6, v6, v6);
}
while ( v2 != &a1[a2] );
}
return v4;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
MOVSXD RBP,ESI
PUSH RBX
MOV RBX,RBP
SHL RBP,0x3
MOV RDI,RBP
SUB RSP,0x8
CALL 0x001010e0
MOV R13,RAX
TEST EBX,EBX
JLE 0x001014c4
MOV RBX,RAX
ADD RBP,R14
LEA R12,[0x102008]
NOP
LAB_00101450:
MOV RDX,qword ptr [R14]
XOR R15D,R15D
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JZ 0x00101484
NOP dword ptr [RAX]
LAB_00101468:
LEA ECX,[RAX + -0x30]
CMP CL,0x9
JA 0x00101479
AND EAX,0x1
CMP AL,0x1
SBB R15D,-0x1
LAB_00101479:
MOVZX EAX,byte ptr [RDX]
ADD RDX,0x1
TEST AL,AL
JNZ 0x00101468
LAB_00101484:
MOV EDI,0x64
ADD R14,0x8
ADD RBX,0x8
CALL 0x001010e0
SUB RSP,0x8
MOV R9D,R15D
MOV R8D,R15D
MOV qword ptr [RBX + -0x8],RAX
MOV RDI,RAX
MOV EDX,0x64
MOV RCX,R12
PUSH R15
MOV ESI,0x2
XOR EAX,EAX
CALL 0x001010f0
POP RAX
POP RDX
CMP R14,RBP
JNZ 0x00101450
LAB_001014c4:
ADD RSP,0x8
MOV RAX,R13
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
int8 * func0(int8 *param_1,int param_2)
{
byte bVar1;
int8 *puVar2;
void *pvVar3;
byte *pbVar4;
int8 *puVar5;
int8 *puVar6;
int iVar7;
puVar2 = (int8 *)malloc((long)param_2 * 8);
if (0 < param_2) {
puVar6 = param_1 + param_2;
puVar5 = puVar2;
do {
pbVar4 = (byte *)*param_1;
iVar7 = 0;
bVar1 = *pbVar4;
while (bVar1 != 0) {
pbVar4 = pbVar4 + 1;
if ((byte)(bVar1 - 0x30) < 10) {
iVar7 = (iVar7 + 1) - (uint)((bVar1 & 1) == 0);
}
bVar1 = *pbVar4;
}
param_1 = param_1 + 1;
pvVar3 = malloc(100);
*puVar5 = pvVar3;
__sprintf_chk(pvVar3,2,100,"the number of odd elements %d in the string %d of the %d input.",
iVar7,iVar7,iVar7);
puVar5 = puVar5 + 1;
} while (param_1 != puVar6);
}
return puVar2;
}
|
1,112 |
func0
|
#include <stdio.h>
|
long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
}
|
#include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
assert(func0(nums4, 1) == -9999999999999999);
long long nums5[] = {0, 10, 20, 1000000};
assert(func0(nums5, 4) == 0);
long long nums6[] = {-1, -2, -3, 10, -5};
assert(func0(nums6, 5) == -6);
long long nums7[] = {100, -1, -2, -3, 10, -5};
assert(func0(nums7, 6) == -6);
long long nums8[] = {10, 11, 13, 8, 3, 4};
assert(func0(nums8, 6) == 3);
long long nums9[] = {100, -33, 32, -1, 0, -2};
assert(func0(nums9, 6) == -33);
long long nums10[] = {-10};
assert(func0(nums10, 1) == -10);
long long nums11[] = {7};
assert(func0(nums11, 1) == 7);
long long nums12[] = {1, -1};
assert(func0(nums12, 2) == -1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%rax
mov %rax,-0x8(%rbp)
movl $0x1,-0x14(%rbp)
jmp 11ef <func0+0x86>
cmpq $0x0,-0x10(%rbp)
jns 11be <func0+0x55>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rdx
mov -0x10(%rbp),%rax
add %rdx,%rax
jmp 11d5 <func0+0x6c>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov %rax,-0x10(%rbp)
mov -0x10(%rbp),%rax
cmp -0x8(%rbp),%rax
jge 11eb <func0+0x82>
mov -0x10(%rbp),%rax
mov %rax,-0x8(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 1197 <func0+0x2e>
mov -0x8(%rbp),%rax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_8], rax
mov [rbp+var_14], 1
jmp short loc_11EF
loc_1197:
cmp [rbp+var_10], 0
jns short loc_11BE
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rdx, [rax]
mov rax, [rbp+var_10]
add rax, rdx
jmp short loc_11D5
loc_11BE:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
loc_11D5:
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
cmp rax, [rbp+var_8]
jge short loc_11EB
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_11EB:
add [rbp+var_14], 1
loc_11EF:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_1197
mov rax, [rbp+var_8]
pop rbp
retn
|
long long func0(long long *a1, int a2)
{
long long v2; // rax
int i; // [rsp+18h] [rbp-14h]
long long v5; // [rsp+1Ch] [rbp-10h]
long long v6; // [rsp+24h] [rbp-8h]
v5 = *a1;
v6 = *a1;
for ( i = 1; i < a2; ++i )
{
if ( v5 >= 0 )
v2 = a1[i];
else
v2 = a1[i] + v5;
v5 = v2;
if ( v2 < v6 )
v6 = v2;
}
return v6;
}
|
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]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x14],0x1
JMP 0x001011ef
LAB_00101197:
CMP qword ptr [RBP + -0x10],0x0
JNS 0x001011be
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,RDX
JMP 0x001011d5
LAB_001011be:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
LAB_001011d5:
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x8]
JGE 0x001011eb
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_001011eb:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ef:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x00101197
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long func0(long *param_1,int param_2)
{
int local_1c;
long local_18;
long local_10;
local_18 = *param_1;
local_10 = *param_1;
for (local_1c = 1; local_1c < param_2; local_1c = local_1c + 1) {
if (local_18 < 0) {
local_18 = local_18 + param_1[local_1c];
}
else {
local_18 = param_1[local_1c];
}
if (local_18 < local_10) {
local_10 = local_18;
}
}
return local_10;
}
|
1,113 |
func0
|
#include <stdio.h>
|
long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
}
|
#include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
assert(func0(nums4, 1) == -9999999999999999);
long long nums5[] = {0, 10, 20, 1000000};
assert(func0(nums5, 4) == 0);
long long nums6[] = {-1, -2, -3, 10, -5};
assert(func0(nums6, 5) == -6);
long long nums7[] = {100, -1, -2, -3, 10, -5};
assert(func0(nums7, 6) == -6);
long long nums8[] = {10, 11, 13, 8, 3, 4};
assert(func0(nums8, 6) == 3);
long long nums9[] = {100, -33, 32, -1, 0, -2};
assert(func0(nums9, 6) == -33);
long long nums10[] = {-10};
assert(func0(nums10, 1) == -10);
long long nums11[] = {7};
assert(func0(nums11, 1) == 7);
long long nums12[] = {1, -1};
assert(func0(nums12, 2) == -1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov (%rdi),%rax
cmp $0x1,%esi
jle 11a3 <func0+0x3a>
lea 0x8(%rdi),%rdx
lea -0x2(%rsi),%ecx
lea 0x10(%rdi,%rcx,8),%rsi
mov %rax,%rcx
jmp 1199 <func0+0x30>
add (%rdx),%rax
cmp %rax,%rcx
cmovg %rax,%rcx
add $0x8,%rdx
cmp %rsi,%rdx
je 11a6 <func0+0x3d>
test %rax,%rax
js 1186 <func0+0x1d>
mov (%rdx),%rax
jmp 1189 <func0+0x20>
mov %rax,%rcx
mov %rcx,%rax
retq
|
func0:
endbr64
mov rax, [rdi]
cmp esi, 1
jle short loc_11A3
lea rdx, [rdi+8]
lea ecx, [rsi-2]
lea rsi, [rdi+rcx*8+10h]
mov rcx, rax
jmp short loc_1199
loc_1186:
mov rax, [rdx]
loc_1189:
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp rdx, rsi
jz short loc_11A6
loc_1199:
test rax, rax
jns short loc_1186
add rax, [rdx]
jmp short loc_1189
loc_11A3:
mov rcx, rax
loc_11A6:
mov rax, rcx
retn
|
long long func0(long long *a1, int a2)
{
long long v2; // rax
long long *v3; // rdx
long long v4; // rsi
long long v5; // rcx
v2 = *a1;
if ( a2 <= 1 )
return *a1;
v3 = a1 + 1;
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
v5 = *a1;
do
{
if ( v2 >= 0 )
v2 = *v3;
else
v2 += *v3;
if ( v5 > v2 )
v5 = v2;
++v3;
}
while ( v3 != (long long *)v4 );
return v5;
}
|
func0:
ENDBR64
MOV RAX,qword ptr [RDI]
CMP ESI,0x1
JLE 0x001011a3
LEA RDX,[RDI + 0x8]
LEA ECX,[RSI + -0x2]
LEA RSI,[RDI + RCX*0x8 + 0x10]
MOV RCX,RAX
JMP 0x00101199
LAB_00101186:
MOV RAX,qword ptr [RDX]
LAB_00101189:
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP RDX,RSI
JZ 0x001011a6
LAB_00101199:
TEST RAX,RAX
JNS 0x00101186
ADD RAX,qword ptr [RDX]
JMP 0x00101189
LAB_001011a3:
MOV RCX,RAX
LAB_001011a6:
MOV RAX,RCX
RET
|
long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long *plVar3;
lVar1 = *param_1;
lVar2 = lVar1;
if (1 < param_2) {
plVar3 = param_1 + 1;
do {
if (lVar1 < 0) {
lVar1 = lVar1 + *plVar3;
}
else {
lVar1 = *plVar3;
}
if (lVar1 < lVar2) {
lVar2 = lVar1;
}
plVar3 = plVar3 + 1;
} while (plVar3 != param_1 + (ulong)(param_2 - 2) + 2);
}
return lVar2;
}
|
1,114 |
func0
|
#include <stdio.h>
|
long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
}
|
#include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
assert(func0(nums4, 1) == -9999999999999999);
long long nums5[] = {0, 10, 20, 1000000};
assert(func0(nums5, 4) == 0);
long long nums6[] = {-1, -2, -3, 10, -5};
assert(func0(nums6, 5) == -6);
long long nums7[] = {100, -1, -2, -3, 10, -5};
assert(func0(nums7, 6) == -6);
long long nums8[] = {10, 11, 13, 8, 3, 4};
assert(func0(nums8, 6) == 3);
long long nums9[] = {100, -33, 32, -1, 0, -2};
assert(func0(nums9, 6) == -33);
long long nums10[] = {-10};
assert(func0(nums10, 1) == -10);
long long nums11[] = {7};
assert(func0(nums11, 1) == 7);
long long nums12[] = {1, -1};
assert(func0(nums12, 2) == -1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov (%rdi),%rax
cmp $0x1,%esi
jle 15e8 <func0+0x48>
lea -0x2(%rsi),%ecx
lea 0x8(%rdi),%rdx
mov %rax,%r8
lea 0x10(%rdi,%rcx,8),%rdi
nopl 0x0(%rax,%rax,1)
mov (%rdx),%rcx
test %rax,%rax
lea (%rax,%rcx,1),%rsi
mov %rcx,%rax
cmovs %rsi,%rax
cmp %rax,%r8
cmovg %rax,%r8
add $0x8,%rdx
cmp %rdx,%rdi
jne 15c0 <func0+0x20>
mov %r8,%rax
retq
nopl (%rax)
mov %rax,%r8
mov %r8,%rax
retq
|
func0:
endbr64
mov rax, [rdi]
cmp esi, 1
jle short loc_1608
lea ecx, [rsi-2]
lea rdx, [rdi+8]
lea r8, [rdi+rcx*8+10h]
mov rcx, rax
nop dword ptr [rax+rax+00h]
loc_15E0:
mov rsi, [rdx]
test rax, rax
lea rdi, [rax+rsi]
mov rax, rsi
cmovs rax, rdi
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp r8, rdx
jnz short loc_15E0
mov rax, rcx
retn
loc_1608:
mov rcx, rax
mov rax, rcx
retn
|
long long func0(long long *a1, int a2)
{
long long result; // rax
long long *v3; // rdx
long long v4; // r8
long long v5; // rcx
bool v6; // sf
long long v7; // rdi
result = *a1;
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
v5 = *a1;
do
{
v6 = result < 0;
v7 = result + *v3;
result = *v3;
if ( v6 )
result = v7;
if ( v5 > result )
v5 = result;
++v3;
}
while ( (long long *)v4 != v3 );
return v5;
}
return result;
}
|
func0:
ENDBR64
MOV RAX,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101608
LEA ECX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
LEA R8,[RDI + RCX*0x8 + 0x10]
MOV RCX,RAX
NOP dword ptr [RAX + RAX*0x1]
LAB_001015e0:
MOV RSI,qword ptr [RDX]
TEST RAX,RAX
LEA RDI,[RAX + RSI*0x1]
MOV RAX,RSI
CMOVS RAX,RDI
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP R8,RDX
JNZ 0x001015e0
MOV RAX,RCX
RET
LAB_00101608:
MOV RCX,RAX
MOV RAX,RCX
RET
|
long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
bool bVar5;
lVar2 = *param_1;
if (1 < param_2) {
plVar4 = param_1 + 1;
lVar3 = lVar2;
do {
bVar5 = lVar2 < 0;
lVar1 = lVar2 + *plVar4;
lVar2 = *plVar4;
if (bVar5) {
lVar2 = lVar1;
}
if (lVar2 < lVar3) {
lVar3 = lVar2;
}
plVar4 = plVar4 + 1;
} while (param_1 + (ulong)(param_2 - 2) + 2 != plVar4);
return lVar3;
}
return lVar2;
}
|
1,115 |
func0
|
#include <stdio.h>
|
long long func0(long long *nums, int size) {
long long current = nums[0];
long long min = nums[0];
for (int i = 1; i < size; i++) {
current = current < 0 ? current + nums[i] : nums[i];
if (current < min) min = current;
}
return min;
}
|
#include <assert.h>
int main() {
long long nums1[] = {2, 3, 4, 1, 2, 4};
assert(func0(nums1, 6) == 1);
long long nums2[] = {-1, -2, -3};
assert(func0(nums2, 3) == -6);
long long nums3[] = {-1, -2, -3, 2, -10};
assert(func0(nums3, 5) == -14);
long long nums4[] = {-9999999999999999};
assert(func0(nums4, 1) == -9999999999999999);
long long nums5[] = {0, 10, 20, 1000000};
assert(func0(nums5, 4) == 0);
long long nums6[] = {-1, -2, -3, 10, -5};
assert(func0(nums6, 5) == -6);
long long nums7[] = {100, -1, -2, -3, 10, -5};
assert(func0(nums7, 6) == -6);
long long nums8[] = {10, 11, 13, 8, 3, 4};
assert(func0(nums8, 6) == 3);
long long nums9[] = {100, -33, 32, -1, 0, -2};
assert(func0(nums9, 6) == -33);
long long nums10[] = {-10};
assert(func0(nums10, 1) == -10);
long long nums11[] = {7};
assert(func0(nums11, 1) == 7);
long long nums12[] = {1, -1};
assert(func0(nums12, 2) == -1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
mov (%rdi),%rcx
cmp $0x1,%esi
jle 1678 <func0+0x48>
lea -0x2(%rsi),%eax
lea 0x8(%rdi),%rdx
mov %rcx,%r8
lea 0x10(%rdi,%rax,8),%rsi
jmp 1653 <func0+0x23>
nopl (%rax)
mov %rax,%rcx
mov (%rdx),%rax
test %rcx,%rcx
jns 165e <func0+0x2e>
add %rcx,%rax
cmp %rax,%r8
cmovg %rax,%r8
add $0x8,%rdx
cmp %rdx,%rsi
jne 1650 <func0+0x20>
mov %r8,%rax
retq
nopw 0x0(%rax,%rax,1)
mov %rcx,%r8
mov %r8,%rax
retq
|
func0:
endbr64
mov r8, [rdi]
cmp esi, 1
jle short loc_1198
lea eax, [rsi-2]
lea rdx, [rdi+8]
mov rcx, r8
lea rsi, [rdi+rax*8+10h]
jmp short loc_1173
loc_1160:
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp rsi, rdx
jz short loc_118E
loc_1170:
mov r8, rax
loc_1173:
mov rax, [rdx]
test r8, r8
jns short loc_1160
add rax, r8
cmp rcx, rax
cmovg rcx, rax
add rdx, 8
cmp rdx, rsi
jnz short loc_1170
loc_118E:
mov rax, rcx
retn
loc_1198:
mov rcx, r8
mov rax, rcx
retn
|
long long func0(long long *a1, int a2)
{
long long v2; // r8
long long *v3; // rdx
long long v4; // rcx
long long v5; // rsi
long long v6; // rax
v2 = *a1;
if ( a2 > 1 )
{
v3 = a1 + 1;
v4 = *a1;
v5 = (long long)&a1[(unsigned int)(a2 - 2) + 2];
while ( 1 )
{
v6 = *v3;
if ( v2 >= 0 )
{
if ( v4 > v6 )
v4 = *v3;
if ( (long long *)v5 == ++v3 )
return v4;
}
else
{
v6 += v2;
if ( v4 > v6 )
v4 = v6;
if ( ++v3 == (long long *)v5 )
return v4;
}
v2 = v6;
}
}
return *a1;
}
|
func0:
ENDBR64
MOV R8,qword ptr [RDI]
CMP ESI,0x1
JLE 0x00101198
LEA EAX,[RSI + -0x2]
LEA RDX,[RDI + 0x8]
MOV RCX,R8
LEA RSI,[RDI + RAX*0x8 + 0x10]
JMP 0x00101173
LAB_00101160:
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP RSI,RDX
JZ 0x0010118e
LAB_00101170:
MOV R8,RAX
LAB_00101173:
MOV RAX,qword ptr [RDX]
TEST R8,R8
JNS 0x00101160
ADD RAX,R8
CMP RCX,RAX
CMOVG RCX,RAX
ADD RDX,0x8
CMP RDX,RSI
JNZ 0x00101170
LAB_0010118e:
MOV RAX,RCX
RET
LAB_00101198:
MOV RCX,R8
MOV RAX,RCX
RET
|
long func0(long *param_1,int param_2)
{
long lVar1;
long lVar2;
long lVar3;
long *plVar4;
lVar3 = *param_1;
if (param_2 < 2) {
return lVar3;
}
plVar4 = param_1 + 1;
lVar2 = lVar3;
while( true ) {
lVar1 = *plVar4;
if (lVar2 < 0) {
lVar2 = lVar1 + lVar2;
if (lVar2 < lVar3) {
lVar3 = lVar2;
}
}
else {
lVar2 = lVar1;
if (lVar1 < lVar3) {
lVar3 = lVar1;
}
}
if (param_1 + (ulong)(param_2 - 2) + 2 == plVar4 + 1) break;
plVar4 = plVar4 + 1;
}
return lVar3;
}
|
1,116 |
func0
|
#include <stdio.h>
|
int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid1_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 6);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 2
rows = 4; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid2_data[4][4] = {{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid2_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 5);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 3
rows = 2; cols = 3; capacity = 5;
grid = (int **)malloc(rows * sizeof(int *));
int grid3_data[2][3] = {{0,0,0}, {0,0,0}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid3_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 0);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 4
rows = 2; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid4_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid4_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 4);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 5
rows = 2; cols = 4; capacity = 9;
grid = (int **)malloc(rows * sizeof(int *));
int grid5_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid5_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 2);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
printf("All tests passed!\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %ecx,-0x24(%rbp)
movl $0x0,-0x10(%rbp)
movl $0x0,-0xc(%rbp)
jmp 124f <func0+0x86>
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 122b <func0+0x62>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x4(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 11fe <func0+0x35>
cmpl $0x0,-0x8(%rbp)
jle 124b <func0+0x82>
mov -0x8(%rbp),%edx
mov -0x24(%rbp),%eax
add %edx,%eax
sub $0x1,%eax
cltd
idivl -0x24(%rbp)
add %eax,-0x10(%rbp)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 11ee <func0+0x25>
mov -0x10(%rbp),%eax
pop %rbp
retq
|
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_24], ecx
mov [rbp+var_10], 0
mov [rbp+var_C], 0
jmp short loc_124F
loc_11EE:
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_122B
loc_11FE:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_18]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_4]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_122B:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_20]
jl short loc_11FE
cmp [rbp+var_8], 0
jle short loc_124B
mov edx, [rbp+var_8]
mov eax, [rbp+var_24]
add eax, edx
sub eax, 1
cdq
idiv [rbp+var_24]
add [rbp+var_10], eax
loc_124B:
add [rbp+var_C], 1
loc_124F:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_1C]
jl short loc_11EE
mov eax, [rbp+var_10]
pop rbp
retn
|
long long func0(long long a1, int a2, int a3, int a4)
{
unsigned int v5; // [rsp+14h] [rbp-10h]
int i; // [rsp+18h] [rbp-Ch]
int v7; // [rsp+1Ch] [rbp-8h]
int j; // [rsp+20h] [rbp-4h]
v5 = 0;
for ( i = 0; i < a2; ++i )
{
v7 = 0;
for ( j = 0; j < a3; ++j )
v7 += *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1));
if ( v7 > 0 )
v5 += (v7 + a4 - 1) / a4;
}
return v5;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x10],0x0
MOV dword ptr [RBP + -0xc],0x0
JMP 0x0010124f
LAB_001011ee:
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0010122b
LAB_001011fe:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x4]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010122b:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x001011fe
CMP dword ptr [RBP + -0x8],0x0
JLE 0x0010124b
MOV EDX,dword ptr [RBP + -0x8]
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,EDX
SUB EAX,0x1
CDQ
IDIV dword ptr [RBP + -0x24]
ADD dword ptr [RBP + -0x10],EAX
LAB_0010124b:
ADD dword ptr [RBP + -0xc],0x1
LAB_0010124f:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x001011ee
MOV EAX,dword ptr [RBP + -0x10]
POP RBP
RET
|
int [16] func0(long param_1,int param_2,ulong param_3,int param_4)
{
int iVar1;
int iVar2;
int auVar3 [16];
int4 local_18;
int4 local_14;
int4 local_10;
int4 local_c;
iVar2 = (int)param_3;
local_18 = 0;
for (local_14 = 0; local_14 < param_2; local_14 = local_14 + 1) {
local_10 = 0;
for (local_c = 0; local_c < iVar2; local_c = local_c + 1) {
param_3 = (long)local_c * 4;
local_10 = local_10 + *(int *)(*(long *)(param_1 + (long)local_14 * 8) + param_3);
}
if (0 < local_10) {
iVar1 = param_4 + local_10 + -1;
param_3 = (long)iVar1 % (long)param_4 & 0xffffffff;
local_18 = local_18 + iVar1 / param_4;
}
}
auVar3._4_4_ = 0;
auVar3._0_4_ = local_18;
auVar3._8_8_ = param_3;
return auVar3;
}
|
1,117 |
func0
|
#include <stdio.h>
|
int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid1_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 6);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 2
rows = 4; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid2_data[4][4] = {{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid2_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 5);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 3
rows = 2; cols = 3; capacity = 5;
grid = (int **)malloc(rows * sizeof(int *));
int grid3_data[2][3] = {{0,0,0}, {0,0,0}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid3_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 0);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 4
rows = 2; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid4_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid4_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 4);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 5
rows = 2; cols = 4; capacity = 9;
grid = (int **)malloc(rows * sizeof(int *));
int grid5_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid5_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 2);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
printf("All tests passed!\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 122a <func0+0x61>
push %rbx
mov %edx,%r9d
mov %rdi,%r8
lea -0x1(%rsi),%eax
lea 0x8(%rdi,%rax,8),%r10
lea -0x1(%rdx),%eax
mov $0x0,%edi
lea 0x4(,%rax,4),%rbx
mov $0x0,%r11d
jmp 1201 <func0+0x38>
add $0x8,%r8
cmp %r10,%r8
je 1232 <func0+0x69>
test %r9d,%r9d
jle 11f8 <func0+0x2f>
mov (%r8),%rax
lea (%rbx,%rax,1),%rsi
mov %r11d,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 1210 <func0+0x47>
test %edx,%edx
jle 11f8 <func0+0x2f>
lea -0x1(%rdx,%rcx,1),%eax
cltd
idiv %ecx
add %eax,%edi
jmp 11f8 <func0+0x2f>
mov $0x0,%edi
mov %edi,%eax
retq
mov %edi,%eax
pop %rbx
retq
|
func0:
endbr64
test esi, esi
jle short loc_1229
push rbp
push rbx
mov r10d, edx
mov r9d, ecx
mov r8, rdi
movsxd rsi, esi
lea rbx, [rdi+rsi*8]
movsxd r11, edx
shl r11, 2
mov edi, 0
mov ebp, 0
jmp short loc_11FF
loc_11F6:
add r8, 8
cmp r8, rbx
jz short loc_1231
loc_11FF:
test r10d, r10d
jle short loc_11F6
mov rax, [r8]
lea rsi, [rax+r11]
mov ecx, ebp
loc_120D:
add ecx, [rax]
add rax, 4
cmp rax, rsi
jnz short loc_120D
test ecx, ecx
jle short loc_11F6
lea eax, [r9+rcx-1]
cdq
idiv r9d
add edi, eax
jmp short loc_11F6
loc_1229:
mov edi, 0
mov eax, edi
retn
loc_1231:
mov eax, edi
pop rbx
pop rbp
retn
|
long long func0(_DWORD **a1, int a2, int a3, int a4)
{
_DWORD **v5; // r8
_DWORD **v6; // rbx
unsigned int v7; // edi
_DWORD *v8; // rax
int v9; // ecx
if ( a2 <= 0 )
return 0LL;
v5 = a1;
v6 = &a1[a2];
v7 = 0;
do
{
if ( a3 > 0 )
{
v8 = *v5;
v9 = 0;
do
v9 += *v8++;
while ( v8 != &(*v5)[a3] );
if ( v9 > 0 )
v7 += (a4 + v9 - 1) / a4;
}
++v5;
}
while ( v5 != v6 );
return v7;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101229
PUSH RBP
PUSH RBX
MOV R10D,EDX
MOV R9D,ECX
MOV R8,RDI
MOVSXD RSI,ESI
LEA RBX,[RDI + RSI*0x8]
MOVSXD R11,EDX
SHL R11,0x2
MOV EDI,0x0
MOV EBP,0x0
JMP 0x001011ff
LAB_001011f6:
ADD R8,0x8
CMP R8,RBX
JZ 0x00101231
LAB_001011ff:
TEST R10D,R10D
JLE 0x001011f6
MOV RAX,qword ptr [R8]
LEA RSI,[RAX + R11*0x1]
MOV ECX,EBP
LAB_0010120d:
ADD ECX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x0010120d
TEST ECX,ECX
JLE 0x001011f6
LEA EAX,[R9 + RCX*0x1 + -0x1]
CDQ
IDIV R9D
ADD EDI,EAX
JMP 0x001011f6
LAB_00101229:
MOV EDI,0x0
MOV EAX,EDI
RET
LAB_00101231:
MOV EAX,EDI
POP RBX
POP RBP
RET
|
int [16] func0(int8 *param_1,int param_2,ulong param_3,int param_4)
{
int8 *puVar1;
int *piVar2;
int auVar3 [16];
int *piVar4;
int iVar5;
int iVar6;
uint uVar7;
int auVar8 [16];
if (0 < param_2) {
iVar6 = (int)param_3;
puVar1 = param_1 + param_2;
uVar7 = 0;
do {
if (0 < iVar6) {
piVar4 = (int *)*param_1;
piVar2 = piVar4 + iVar6;
iVar5 = 0;
do {
iVar5 = iVar5 + *piVar4;
piVar4 = piVar4 + 1;
} while (piVar4 != piVar2);
if (0 < iVar5) {
iVar5 = param_4 + -1 + iVar5;
param_3 = (long)iVar5 % (long)param_4 & 0xffffffff;
uVar7 = uVar7 + iVar5 / param_4;
}
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
auVar8._4_4_ = 0;
auVar8._0_4_ = uVar7;
auVar8._8_8_ = param_3;
return auVar8;
}
auVar3._8_8_ = 0;
auVar3._0_8_ = param_3;
return auVar3 << 0x40;
}
|
1,118 |
func0
|
#include <stdio.h>
|
int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid1_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 6);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 2
rows = 4; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid2_data[4][4] = {{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid2_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 5);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 3
rows = 2; cols = 3; capacity = 5;
grid = (int **)malloc(rows * sizeof(int *));
int grid3_data[2][3] = {{0,0,0}, {0,0,0}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid3_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 0);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 4
rows = 2; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid4_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid4_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 4);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 5
rows = 2; cols = 4; capacity = 9;
grid = (int **)malloc(rows * sizeof(int *));
int grid5_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid5_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 2);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
mov %edx,%r11d
test %esi,%esi
jle 16e6 <func0+0x66>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x8(%rdi,%rax,8),%r9
lea -0x1(%rdx),%eax
lea 0x4(,%rax,4),%r10
nopl 0x0(%rax)
test %r11d,%r11d
jle 16d9 <func0+0x59>
mov (%rdi),%rax
xor %edx,%edx
lea (%r10,%rax,1),%rsi
nopw %cs:0x0(%rax,%rax,1)
add (%rax),%edx
add $0x4,%rax
cmp %rsi,%rax
jne 16c0 <func0+0x40>
test %edx,%edx
jle 16d9 <func0+0x59>
lea -0x1(%rdx,%rcx,1),%eax
cltd
idiv %ecx
add %eax,%r8d
add $0x8,%rdi
cmp %r9,%rdi
jne 16a8 <func0+0x28>
mov %r8d,%eax
retq
xor %r8d,%r8d
mov %r8d,%eax
retq
nopl (%rax)
|
func0:
endbr64
mov r8d, ecx
test esi, esi
jle short loc_159F
movsxd rsi, esi
lea r10, [rdi+rsi*8]
loc_1592:
test edx, edx
jg short loc_15A6
add rdi, 8
cmp rdi, r10
jnz short loc_1592
loc_159F:
xor r9d, r9d
mov eax, r9d
retn
loc_15A6:
movsxd rdx, edx
xor r9d, r9d
lea rsi, ds:0[rdx*4]
nop dword ptr [rax+00h]
loc_15B8:
mov rax, [rdi]
xor edx, edx
lea rcx, [rax+rsi]
nop dword ptr [rax+00000000h]
loc_15C8:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_15C8
test edx, edx
jle short loc_15F0
lea eax, [rdx+r8-1]
add rdi, 8
cdq
idiv r8d
add r9d, eax
cmp rdi, r10
jnz short loc_15B8
mov eax, r9d
retn
loc_15F0:
add rdi, 8
cmp rdi, r10
jnz short loc_15B8
mov eax, r9d
retn
|
long long func0(_DWORD **a1, int a2, int a3, int a4)
{
_DWORD **v4; // r10
unsigned int v6; // r9d
long long v7; // rsi
_DWORD *v8; // rax
int v9; // edx
if ( a2 <= 0 )
return 0LL;
v4 = &a1[a2];
while ( a3 <= 0 )
{
if ( ++a1 == v4 )
return 0LL;
}
v6 = 0;
v7 = a3;
do
{
while ( 1 )
{
v8 = *a1;
v9 = 0;
do
v9 += *v8++;
while ( v8 != &(*a1)[v7] );
if ( v9 <= 0 )
break;
++a1;
v6 += (v9 + a4 - 1) / a4;
if ( a1 == v4 )
return v6;
}
++a1;
}
while ( a1 != v4 );
return v6;
}
|
func0:
ENDBR64
MOV R8D,ECX
TEST ESI,ESI
JLE 0x0010159f
MOVSXD RSI,ESI
LEA R10,[RDI + RSI*0x8]
LAB_00101592:
TEST EDX,EDX
JG 0x001015a6
ADD RDI,0x8
CMP RDI,R10
JNZ 0x00101592
LAB_0010159f:
XOR R9D,R9D
MOV EAX,R9D
RET
LAB_001015a6:
MOVSXD RDX,EDX
XOR R9D,R9D
LEA RSI,[RDX*0x4]
NOP dword ptr [RAX]
LAB_001015b8:
MOV RAX,qword ptr [RDI]
XOR EDX,EDX
LEA RCX,[RAX + RSI*0x1]
NOP dword ptr [RAX]
LAB_001015c8:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x001015c8
TEST EDX,EDX
JLE 0x001015f0
LEA EAX,[RDX + R8*0x1 + -0x1]
ADD RDI,0x8
CDQ
IDIV R8D
ADD R9D,EAX
CMP RDI,R10
JNZ 0x001015b8
MOV EAX,R9D
RET
LAB_001015f0:
ADD RDI,0x8
CMP RDI,R10
JNZ 0x001015b8
MOV EAX,R9D
RET
|
int func0(int8 *param_1,int param_2,int param_3,int param_4)
{
int8 *puVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
if (0 < param_2) {
puVar1 = param_1 + param_2;
do {
if (0 < param_3) {
iVar5 = 0;
do {
while( true ) {
piVar3 = (int *)*param_1;
iVar4 = 0;
piVar2 = piVar3 + param_3;
do {
iVar4 = iVar4 + *piVar3;
piVar3 = piVar3 + 1;
} while (piVar3 != piVar2);
if (0 < iVar4) break;
param_1 = param_1 + 1;
if (param_1 == puVar1) {
return iVar5;
}
}
param_1 = param_1 + 1;
iVar5 = iVar5 + (iVar4 + -1 + param_4) / param_4;
} while (param_1 != puVar1);
return iVar5;
}
param_1 = param_1 + 1;
} while (param_1 != puVar1);
}
return 0;
}
|
1,119 |
func0
|
#include <stdio.h>
|
int func0(int **grid, int rows, int cols, int capacity) {
int out = 0;
for (int i = 0; i < rows; i++) {
int sum = 0;
for (int j = 0; j < cols; j++)
sum += grid[i][j];
if (sum > 0) out += (sum + capacity - 1) / capacity;
}
return out;
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int main() {
int rows, cols, capacity;
int **grid;
// Test case 1
rows = 3; cols = 4; capacity = 1;
grid = (int **)malloc(rows * sizeof(int *));
int grid1_data[3][4] = {{0,0,1,0}, {0,1,0,0}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid1_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 6);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 2
rows = 4; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid2_data[4][4] = {{0,0,1,1}, {0,0,0,0}, {1,1,1,1}, {0,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid2_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 5);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 3
rows = 2; cols = 3; capacity = 5;
grid = (int **)malloc(rows * sizeof(int *));
int grid3_data[2][3] = {{0,0,0}, {0,0,0}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid3_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 0);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 4
rows = 2; cols = 4; capacity = 2;
grid = (int **)malloc(rows * sizeof(int *));
int grid4_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid4_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 4);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
// Test case 5
rows = 2; cols = 4; capacity = 9;
grid = (int **)malloc(rows * sizeof(int *));
int grid5_data[2][4] = {{1,1,1,1}, {1,1,1,1}};
for (int i = 0; i < rows; i++) {
grid[i] = (int *)malloc(cols * sizeof(int));
for (int j = 0; j < cols; j++) {
grid[i][j] = grid5_data[i][j];
}
}
assert(func0(grid, rows, cols, capacity) == 2);
for (int i = 0; i < rows; i++) free(grid[i]);
free(grid);
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 171a <func0+0xfa>
mov %edx,%r11d
lea -0x1(%rsi),%eax
mov %edx,%r9d
push %r13
shr $0x2,%r11d
push %r12
mov %edx,%r8d
and $0xfffffffc,%r9d
push %rbp
shl $0x4,%r11
lea -0x1(%rdx),%ebp
xor %r10d,%r10d
push %rbx
lea 0x8(%rdi,%rax,8),%rbx
nopl (%rax)
test %r8d,%r8d
jle 16fd <func0+0xdd>
mov (%rdi),%rsi
cmp $0x3,%ebp
jbe 1714 <func0+0xf4>
mov %rsi,%rax
lea (%rsi,%r11,1),%rdx
pxor %xmm0,%xmm0
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm2
add $0x10,%rax
paddd %xmm2,%xmm0
cmp %rdx,%rax
jne 1680 <func0+0x60>
movdqa %xmm0,%xmm1
mov %r9d,%edx
psrldq $0x8,%xmm1
paddd %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrldq $0x4,%xmm1
paddd %xmm1,%xmm0
movd %xmm0,%eax
cmp %r9d,%r8d
je 16ef <func0+0xcf>
movslq %edx,%r13
lea 0x0(,%r13,4),%r12
add (%rsi,%r13,4),%eax
lea 0x1(%rdx),%r13d
cmp %r13d,%r8d
jle 16ef <func0+0xcf>
lea 0x2(%rdx),%r13d
add 0x4(%rsi,%r12,1),%eax
cmp %r13d,%r8d
jle 16ef <func0+0xcf>
add $0x3,%edx
add 0x8(%rsi,%r12,1),%eax
cmp %edx,%r8d
jle 16ef <func0+0xcf>
add 0xc(%rsi,%r12,1),%eax
test %eax,%eax
jle 16fd <func0+0xdd>
lea -0x1(%rax,%rcx,1),%eax
cltd
idiv %ecx
add %eax,%r10d
add $0x8,%rdi
cmp %rbx,%rdi
jne 1658 <func0+0x38>
pop %rbx
mov %r10d,%eax
pop %rbp
pop %r12
pop %r13
retq
xor %edx,%edx
xor %eax,%eax
jmp 16b7 <func0+0x97>
xor %r10d,%r10d
mov %r10d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle loc_1547
movsxd rsi, esi
push r13
mov r9d, ecx
mov r8d, edx
push r12
mov rcx, rdi
push rbp
push rbx
lea rbx, [rdi+rsi*8]
loc_1452:
test r8d, r8d
jg short loc_146D
add rcx, 8
cmp rcx, rbx
jnz short loc_1452
xor r10d, r10d
loc_1463:
pop rbx
mov eax, r10d
pop rbp
pop r12
pop r13
retn
loc_146D:
mov r11d, r8d
mov edi, r8d
lea ebp, [r8-1]
xor r10d, r10d
shr r11d, 2
and edi, 0FFFFFFFCh
shl r11, 4
loc_1485:
mov rsi, [rcx]
cmp ebp, 2
jbe loc_1529
loc_1491:
mov rax, rsi
lea rdx, [rsi+r11]
pxor xmm0, xmm0
nop dword ptr [rax+00h]
loc_14A0:
movdqu xmm2, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm2
cmp rax, rdx
jnz short loc_14A0
movdqa xmm1, xmm0
mov edx, edi
psrldq xmm1, 8
paddd xmm0, xmm1
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movd eax, xmm0
cmp r8d, edi
jz short loc_1500
loc_14D6:
movsxd r12, edx
lea r13, ds:0[r12*4]
add eax, [rsi+r12*4]
lea r12d, [rdx+1]
cmp r8d, r12d
jle short loc_1500
add edx, 2
add eax, [rsi+r13+4]
cmp r8d, edx
jle short loc_1500
add eax, [rsi+r13+8]
loc_1500:
test eax, eax
jle short loc_1530
lea eax, [rax+r9-1]
add rcx, 8
cdq
idiv r9d
add r10d, eax
cmp rcx, rbx
jz loc_1463
mov rsi, [rcx]
cmp ebp, 2
ja loc_1491
loc_1529:
xor edx, edx
xor eax, eax
jmp short loc_14D6
loc_1530:
add rcx, 8
cmp rcx, rbx
jnz loc_1485
pop rbx
mov eax, r10d
pop rbp
pop r12
pop r13
retn
loc_1547:
xor eax, eax
retn
|
long long func0(const __m128i **a1, int a2, int a3, int a4)
{
const __m128i **v6; // rcx
const __m128i **v7; // rbx
unsigned int v8; // r10d
unsigned int v10; // ebp
const __m128i *v11; // rsi
const __m128i *v12; // rax
__m128i v13; // xmm0
__m128i v14; // xmm2
int v15; // edx
__m128i v16; // xmm0
int v17; // eax
long long v18; // r13
if ( a2 <= 0 )
return 0LL;
v6 = a1;
v7 = &a1[a2];
do
{
if ( a3 > 0 )
{
v10 = a3 - 1;
v8 = 0;
LABEL_8:
v11 = *v6;
if ( v10 <= 2 )
goto LABEL_18;
while ( 1 )
{
v12 = v11;
v13 = 0LL;
do
{
v14 = _mm_loadu_si128(v12++);
v13 = _mm_add_epi32(v13, v14);
}
while ( v12 != &v11[(unsigned int)a3 >> 2] );
v15 = a3 & 0x7FFFFFFC;
v16 = _mm_add_epi32(v13, _mm_srli_si128(v13, 8));
v17 = _mm_cvtsi128_si32(_mm_add_epi32(v16, _mm_srli_si128(v16, 4)));
if ( a3 == (a3 & 0xFFFFFFFC) )
goto LABEL_15;
while ( 1 )
{
v18 = v15;
v17 += v11->m128i_i32[v18];
if ( a3 > v15 + 1 )
{
v17 += v11->m128i_i32[v18 + 1];
if ( a3 > v15 + 2 )
v17 += v11->m128i_i32[v18 + 2];
}
LABEL_15:
if ( v17 <= 0 )
{
if ( ++v6 == v7 )
return v8;
goto LABEL_8;
}
++v6;
v8 += (v17 + a4 - 1) / a4;
if ( v6 == v7 )
return v8;
v11 = *v6;
if ( v10 > 2 )
break;
LABEL_18:
v15 = 0;
v17 = 0;
}
}
}
++v6;
}
while ( v6 != v7 );
return 0;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101547
MOVSXD RSI,ESI
PUSH R13
MOV R9D,ECX
MOV R8D,EDX
PUSH R12
MOV RCX,RDI
PUSH RBP
PUSH RBX
LEA RBX,[RDI + RSI*0x8]
LAB_00101452:
TEST R8D,R8D
JG 0x0010146d
ADD RCX,0x8
CMP RCX,RBX
JNZ 0x00101452
XOR R10D,R10D
LAB_00101463:
POP RBX
MOV EAX,R10D
POP RBP
POP R12
POP R13
RET
LAB_0010146d:
MOV R11D,R8D
MOV EDI,R8D
LEA EBP,[R8 + -0x1]
XOR R10D,R10D
SHR R11D,0x2
AND EDI,0xfffffffc
SHL R11,0x4
LAB_00101485:
MOV RSI,qword ptr [RCX]
CMP EBP,0x2
JBE 0x00101529
LAB_00101491:
MOV RAX,RSI
LEA RDX,[RSI + R11*0x1]
PXOR XMM0,XMM0
NOP dword ptr [RAX]
LAB_001014a0:
MOVDQU XMM2,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM2
CMP RAX,RDX
JNZ 0x001014a0
MOVDQA XMM1,XMM0
MOV EDX,EDI
PSRLDQ XMM1,0x8
PADDD XMM0,XMM1
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVD EAX,XMM0
CMP R8D,EDI
JZ 0x00101500
LAB_001014d6:
MOVSXD R12,EDX
LEA R13,[R12*0x4]
ADD EAX,dword ptr [RSI + R12*0x4]
LEA R12D,[RDX + 0x1]
CMP R8D,R12D
JLE 0x00101500
ADD EDX,0x2
ADD EAX,dword ptr [RSI + R13*0x1 + 0x4]
CMP R8D,EDX
JLE 0x00101500
ADD EAX,dword ptr [RSI + R13*0x1 + 0x8]
LAB_00101500:
TEST EAX,EAX
JLE 0x00101530
LEA EAX,[RAX + R9*0x1 + -0x1]
ADD RCX,0x8
CDQ
IDIV R9D
ADD R10D,EAX
CMP RCX,RBX
JZ 0x00101463
MOV RSI,qword ptr [RCX]
CMP EBP,0x2
JA 0x00101491
LAB_00101529:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001014d6
LAB_00101530:
ADD RCX,0x8
CMP RCX,RBX
JNZ 0x00101485
POP RBX
MOV EAX,R10D
POP RBP
POP R12
POP R13
RET
LAB_00101547:
XOR EAX,EAX
RET
|
int func0(int8 *param_1,int param_2,uint param_3,int param_4)
{
int8 *puVar1;
int iVar2;
int *piVar3;
int *piVar4;
int *piVar5;
int *piVar6;
uint uVar7;
int *piVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
if (param_2 < 1) {
return 0;
}
puVar1 = param_1 + param_2;
while ((int)param_3 < 1) {
param_1 = param_1 + 1;
if (param_1 == puVar1) {
return 0;
}
}
iVar9 = 0;
LAB_00101485:
piVar8 = (int *)*param_1;
if (param_3 - 1 < 3) goto LAB_00101529;
do {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
piVar6 = piVar8;
do {
iVar2 = *piVar6;
piVar3 = piVar6 + 1;
piVar4 = piVar6 + 2;
piVar5 = piVar6 + 3;
piVar6 = piVar6 + 4;
iVar10 = iVar10 + iVar2;
iVar11 = iVar11 + *piVar3;
iVar12 = iVar12 + *piVar4;
iVar13 = iVar13 + *piVar5;
} while (piVar6 != piVar8 + (ulong)(param_3 >> 2) * 4);
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
uVar7 = param_3 & 0xfffffffc;
if (param_3 == (param_3 & 0xfffffffc)) goto LAB_00101500;
while( true ) {
iVar10 = iVar10 + piVar8[(int)uVar7];
if (((int)(uVar7 + 1) < (int)param_3) &&
(iVar10 = iVar10 + piVar8[(long)(int)uVar7 + 1], (int)(uVar7 + 2) < (int)param_3)) {
iVar10 = iVar10 + piVar8[(long)(int)uVar7 + 2];
}
LAB_00101500:
if (iVar10 < 1) {
param_1 = param_1 + 1;
if (param_1 == puVar1) {
return iVar9;
}
goto LAB_00101485;
}
param_1 = param_1 + 1;
iVar9 = iVar9 + (iVar10 + -1 + param_4) / param_4;
if (param_1 == puVar1) {
return iVar9;
}
piVar8 = (int *)*param_1;
if (2 < param_3 - 1) break;
LAB_00101529:
uVar7 = 0;
iVar10 = 0;
}
} while( true );
}
|
1,120 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
}
x = count_ones;
count_ones = 0;
while (y > 0) {
count_ones += y & 1;
y >>= 1;
}
y = count_ones;
if (y < x || (y == x && arr[j] < arr[i])) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
func0(test1, 5);
assert(issame(test1, 5, expected1, 5));
int test3[] = {1, 0, 2, 3, 4};
int expected3[] = {0, 1, 2, 4, 3};
func0(test3, 5);
assert(issame(test3, 5, expected3, 5));
int test4[] = {2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4};
int expected4[] = {2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77};
func0(test4, 11);
assert(issame(test4, 11, expected4, 11));
int test5[] = {3, 6, 44, 12, 32, 5};
int expected5[] = {32, 3, 5, 6, 12, 44};
func0(test5, 6);
assert(issame(test5, 6, expected5, 6));
int test6[] = {2, 4, 8, 16, 32};
int expected6[] = {2, 4, 8, 16, 32};
func0(test6, 5);
assert(issame(test6, 5, expected6, 5));
printf("All tests passed!\n");
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0xc(%rbp)
jmpq 12dd <func0+0x154>
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,-0x8(%rbp)
jmpq 12cd <func0+0x144>
movl $0x0,-0x18(%rbp)
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x14(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x10(%rbp)
jmp 11f9 <func0+0x70>
mov -0x14(%rbp),%eax
and $0x1,%eax
add %eax,-0x18(%rbp)
sarl -0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 11ed <func0+0x64>
mov -0x18(%rbp),%eax
mov %eax,-0x14(%rbp)
movl $0x0,-0x18(%rbp)
jmp 121a <func0+0x91>
mov -0x10(%rbp),%eax
and $0x1,%eax
add %eax,-0x18(%rbp)
sarl -0x10(%rbp)
cmpl $0x0,-0x10(%rbp)
jg 120e <func0+0x85>
mov -0x18(%rbp),%eax
mov %eax,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x14(%rbp),%eax
jl 126a <func0+0xe1>
mov -0x10(%rbp),%eax
cmp -0x14(%rbp),%eax
jne 12c9 <func0+0x140>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x28(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 12c9 <func0+0x140>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11b2 <func0+0x29>
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11a4 <func0+0x1b>
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_C], 0
jmp loc_12DD
loc_11A4:
mov eax, [rbp+var_C]
add eax, 1
mov [rbp+var_8], eax
jmp loc_12CD
loc_11B2:
mov [rbp+var_18], 0
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_14], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_10], eax
jmp short loc_11F9
loc_11ED:
mov eax, [rbp+var_14]
and eax, 1
add [rbp+var_18], eax
sar [rbp+var_14], 1
loc_11F9:
cmp [rbp+var_14], 0
jg short loc_11ED
mov eax, [rbp+var_18]
mov [rbp+var_14], eax
mov [rbp+var_18], 0
jmp short loc_121A
loc_120E:
mov eax, [rbp+var_10]
and eax, 1
add [rbp+var_18], eax
sar [rbp+var_10], 1
loc_121A:
cmp [rbp+var_10], 0
jg short loc_120E
mov eax, [rbp+var_18]
mov [rbp+var_10], eax
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jl short loc_126A
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jnz loc_12C9
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_12C9
loc_126A:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_12C9:
add [rbp+var_8], 1
loc_12CD:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_2C]
jl loc_11B2
add [rbp+var_C], 1
loc_12DD:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_2C]
jl loc_11A4
nop
nop
pop rbp
retn
|
long long func0(long long a1, int a2)
{
long long result; // rax
int v3; // [rsp+14h] [rbp-18h]
int v4; // [rsp+14h] [rbp-18h]
int v5; // [rsp+18h] [rbp-14h]
int v6; // [rsp+18h] [rbp-14h]
int v7; // [rsp+1Ch] [rbp-10h]
unsigned int i; // [rsp+20h] [rbp-Ch]
int j; // [rsp+24h] [rbp-8h]
int v10; // [rsp+28h] [rbp-4h]
for ( i = 0; ; ++i )
{
result = i;
if ( (int)i >= a2 )
break;
for ( j = i + 1; j < a2; ++j )
{
v3 = 0;
v5 = *(_DWORD *)(4LL * (int)i + a1);
v7 = *(_DWORD *)(4LL * j + a1);
while ( v5 > 0 )
{
v3 += v5 & 1;
v5 >>= 1;
}
v6 = v3;
v4 = 0;
while ( v7 > 0 )
{
v4 += v7 & 1;
v7 >>= 1;
}
if ( v4 < v6 || v4 == v6 && *(_DWORD *)(4LL * j + a1) < *(_DWORD *)(4LL * (int)i + a1) )
{
v10 = *(_DWORD *)(4LL * (int)i + a1);
*(_DWORD *)(4LL * (int)i + a1) = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(a1 + 4LL * j) = v10;
}
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0xc],0x0
JMP 0x001012dd
LAB_001011a4:
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012cd
LAB_001011b2:
MOV dword ptr [RBP + -0x18],0x0
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001011f9
LAB_001011ed:
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x1
ADD dword ptr [RBP + -0x18],EAX
SAR dword ptr [RBP + -0x14],0x1
LAB_001011f9:
CMP dword ptr [RBP + -0x14],0x0
JG 0x001011ed
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr [RBP + -0x18],0x0
JMP 0x0010121a
LAB_0010120e:
MOV EAX,dword ptr [RBP + -0x10]
AND EAX,0x1
ADD dword ptr [RBP + -0x18],EAX
SAR dword ptr [RBP + -0x10],0x1
LAB_0010121a:
CMP dword ptr [RBP + -0x10],0x0
JG 0x0010120e
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JL 0x0010126a
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JNZ 0x001012c9
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001012c9
LAB_0010126a:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_001012c9:
ADD dword ptr [RBP + -0x8],0x1
LAB_001012cd:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011b2
ADD dword ptr [RBP + -0xc],0x1
LAB_001012dd:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011a4
NOP
NOP
POP RBP
RET
|
void func0(long param_1,int param_2)
{
int4 uVar1;
int iVar2;
int local_20;
uint local_1c;
uint local_18;
int local_14;
int local_10;
for (local_14 = 0; local_10 = local_14, local_14 < param_2; local_14 = local_14 + 1) {
while (local_10 = local_10 + 1, local_10 < param_2) {
local_20 = 0;
local_18 = *(uint *)(param_1 + (long)local_10 * 4);
for (local_1c = *(uint *)(param_1 + (long)local_14 * 4); iVar2 = local_20, 0 < (int)local_1c;
local_1c = (int)local_1c >> 1) {
local_20 = local_20 + (local_1c & 1);
}
local_20 = 0;
for (; 0 < (int)local_18; local_18 = (int)local_18 >> 1) {
local_20 = local_20 + (local_18 & 1);
}
if ((local_20 < iVar2) ||
((local_20 == iVar2 &&
(*(int *)(param_1 + (long)local_10 * 4) < *(int *)(param_1 + (long)local_14 * 4))))) {
uVar1 = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)(param_1 + (long)local_14 * 4) =
*(int4 *)(param_1 + (long)local_10 * 4);
*(int4 *)((long)local_10 * 4 + param_1) = uVar1;
}
}
}
return;
}
|
1,121 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
}
x = count_ones;
count_ones = 0;
while (y > 0) {
count_ones += y & 1;
y >>= 1;
}
y = count_ones;
if (y < x || (y == x && arr[j] < arr[i])) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
func0(test1, 5);
assert(issame(test1, 5, expected1, 5));
int test3[] = {1, 0, 2, 3, 4};
int expected3[] = {0, 1, 2, 4, 3};
func0(test3, 5);
assert(issame(test3, 5, expected3, 5));
int test4[] = {2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4};
int expected4[] = {2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77};
func0(test4, 11);
assert(issame(test4, 11, expected4, 11));
int test5[] = {3, 6, 44, 12, 32, 5};
int expected5[] = {32, 3, 5, 6, 12, 44};
func0(test5, 6);
assert(issame(test5, 6, expected5, 6));
int test6[] = {2, 4, 8, 16, 32};
int expected6[] = {2, 4, 8, 16, 32};
func0(test6, 5);
assert(issame(test6, 5, expected6, 5));
printf("All tests passed!\n");
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 1240 <func0+0xb7>
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%r11
mov %esi,%ebp
mov %rdi,%r10
lea -0x1(%rsi),%r13d
add $0x1,%r13
mov $0x1,%r12d
jmp 121e <func0+0x95>
mov $0x0,%ecx
jmp 1207 <func0+0x7e>
mov %r9d,(%rbx)
mov %r8d,(%r11,%rdi,4)
add $0x1,%rdi
cmp %edi,%ebp
jle 1216 <func0+0x8d>
mov %r10,%rbx
mov (%r10),%r8d
mov (%r11,%rdi,4),%r9d
test %r8d,%r8d
jle 1228 <func0+0x9f>
mov %r8d,%eax
mov $0x0,%edx
mov %eax,%ecx
and $0x1,%ecx
add %ecx,%edx
sar %eax
test %eax,%eax
jg 11e0 <func0+0x57>
test %r9d,%r9d
jle 11b3 <func0+0x2a>
mov %r9d,%eax
mov $0x0,%ecx
mov %eax,%esi
and $0x1,%esi
add %esi,%ecx
sar %eax
test %eax,%eax
jg 11fa <func0+0x71>
cmp %ecx,%edx
jg 11ba <func0+0x31>
cmp %r9d,%r8d
jle 11c1 <func0+0x38>
cmp %edx,%ecx
jne 11c1 <func0+0x38>
jmp 11ba <func0+0x31>
add $0x1,%r12
add $0x4,%r10
cmp %r13,%r12
je 1239 <func0+0xb0>
mov %r12,%rdi
jmp 11c9 <func0+0x40>
mov $0x0,%edx
mov $0x0,%ecx
test %r9d,%r9d
jg 11f2 <func0+0x69>
jmp 120b <func0+0x82>
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
retq
|
func0:
endbr64
test esi, esi
jle locret_128D
mov edx, esi
lea r10, [rdi+4]
lea r8d, [rsi-1]
mov esi, esi
movsxd rdx, edx
mov eax, 1
lea r9, [rdi+8]
mov edi, r8d
mov rcx, rsi
cmp rax, rsi
jz locret_128D
push r15
push r14
push r13
push r12
push rbp
push rbx
jmp loc_1255
loc_11CB:
mov r11d, 0
jmp short loc_122A
loc_11D3:
mov [r15-4], r13d
mov [r14], r12d
loc_11DA:
add rbx, 4
cmp rbx, rsi
jz short loc_123B
loc_11E3:
mov r15, r10
mov r12d, [r10-4]
mov r14, rbx
mov r13d, [rbx]
test r12d, r12d
jle short loc_126F
mov eax, r12d
mov r8d, 0
loc_11FE:
mov r11d, eax
and r11d, 1
add r8d, r11d
sar eax, 1
test eax, eax
jg short loc_11FE
test r13d, r13d
jle short loc_11CB
loc_1213:
mov eax, r13d
mov r11d, 0
loc_121C:
mov ebp, eax
and ebp, 1
add r11d, ebp
sar eax, 1
test eax, eax
jg short loc_121C
loc_122A:
cmp r8d, r11d
jg short loc_11D3
loc_122F:
cmp r12d, r13d
jle short loc_11DA
cmp r11d, r8d
jnz short loc_11DA
jmp short loc_11D3
loc_123B:
mov rax, [rsp+30h+var_38]
lea rsi, [rax+1]
add r10, 4
cmp rax, rdx
jz short loc_1282
mov rax, rsi
cmp rsi, rcx
jz short loc_1282
loc_1255:
mov esi, edi
sub esi, eax
lea rsi, [rax+rsi-1]
lea rsi, [r9+rsi*4]
mov rbx, r10
mov [rsp+30h+var_38], rax
jmp loc_11E3
loc_126F:
mov r8d, 0
mov r11d, 0
test r13d, r13d
jg short loc_1213
jmp short loc_122F
loc_1282:
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
locret_128D:
retn
|
void func0(long long a1, int a2)
{
int *v2; // r10
long long v3; // rdx
long long v4; // rax
long long v5; // r9
int v6; // edi
long long v7; // rcx
int v8; // r11d
int *v9; // rbx
int v10; // r12d
int v11; // r13d
int v12; // eax
int v13; // r8d
int v14; // eax
int *v15; // rsi
long long v16; // [rsp+0h] [rbp-38h]
if ( a2 <= 0 )
return;
v2 = (int *)(a1 + 4);
v3 = a2;
v4 = 1LL;
v5 = a1 + 8;
v6 = a2 - 1;
v7 = (unsigned int)a2;
if ( a2 == 1LL )
return;
while ( 2 )
{
v15 = (int *)(v5 + 4 * (v4 + (unsigned int)(v6 - v4) - 1));
v9 = v2;
v16 = v4;
do
{
v10 = *(v2 - 1);
v11 = *v9;
if ( v10 <= 0 )
{
v13 = 0;
v8 = 0;
if ( v11 <= 0 )
goto LABEL_14;
}
else
{
v12 = *(v2 - 1);
v13 = 0;
do
{
v13 += v12 & 1;
v12 >>= 1;
}
while ( v12 > 0 );
if ( v11 <= 0 )
{
v8 = 0;
goto LABEL_13;
}
}
v14 = *v9;
v8 = 0;
do
{
v8 += v14 & 1;
v14 >>= 1;
}
while ( v14 > 0 );
LABEL_13:
if ( v13 > v8 )
goto LABEL_5;
LABEL_14:
if ( v10 > v11 && v8 == v13 )
{
LABEL_5:
*(v2 - 1) = v11;
*v9 = v10;
}
++v9;
}
while ( v9 != v15 );
++v2;
if ( v16 != v3 )
{
v4 = v16 + 1;
if ( v16 + 1 != v7 )
continue;
}
break;
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010128d
MOV EDX,ESI
LEA R10,[RDI + 0x4]
LEA R8D,[RSI + -0x1]
MOV ESI,ESI
MOVSXD RDX,EDX
MOV EAX,0x1
LEA R9,[RDI + 0x8]
MOV EDI,R8D
MOV RCX,RSI
CMP RAX,RSI
JZ 0x0010128d
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
JMP 0x00101255
LAB_001011cb:
MOV R11D,0x0
JMP 0x0010122a
LAB_001011d3:
MOV dword ptr [R15 + -0x4],R13D
MOV dword ptr [R14],R12D
LAB_001011da:
ADD RBX,0x4
CMP RBX,RSI
JZ 0x0010123b
LAB_001011e3:
MOV R15,R10
MOV R12D,dword ptr [R10 + -0x4]
MOV R14,RBX
MOV R13D,dword ptr [RBX]
TEST R12D,R12D
JLE 0x0010126f
MOV EAX,R12D
MOV R8D,0x0
LAB_001011fe:
MOV R11D,EAX
AND R11D,0x1
ADD R8D,R11D
SAR EAX,0x1
TEST EAX,EAX
JG 0x001011fe
TEST R13D,R13D
JLE 0x001011cb
LAB_00101213:
MOV EAX,R13D
MOV R11D,0x0
LAB_0010121c:
MOV EBP,EAX
AND EBP,0x1
ADD R11D,EBP
SAR EAX,0x1
TEST EAX,EAX
JG 0x0010121c
LAB_0010122a:
CMP R8D,R11D
JG 0x001011d3
LAB_0010122f:
CMP R12D,R13D
JLE 0x001011da
CMP R11D,R8D
JNZ 0x001011da
JMP 0x001011d3
LAB_0010123b:
MOV RAX,qword ptr [RSP + -0x8]
LEA RSI,[RAX + 0x1]
ADD R10,0x4
CMP RAX,RDX
JZ 0x00101282
MOV RAX,RSI
CMP RSI,RCX
JZ 0x00101282
LAB_00101255:
MOV ESI,EDI
SUB ESI,EAX
LEA RSI,[RAX + RSI*0x1 + -0x1]
LEA RSI,[R9 + RSI*0x4]
MOV RBX,R10
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001011e3
LAB_0010126f:
MOV R8D,0x0
MOV R11D,0x0
TEST R13D,R13D
JG 0x00101213
JMP 0x0010122f
LAB_00101282:
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010128d:
RET
|
void func0(long param_1,uint param_2)
{
ulong uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
ulong uVar5;
uint *puVar6;
int iVar7;
uint *puVar8;
int iVar9;
if (0 < (int)param_2) {
puVar8 = (uint *)(param_1 + 4);
uVar5 = 1;
if ((ulong)param_2 != 1) {
do {
puVar6 = puVar8;
do {
uVar2 = puVar8[-1];
uVar3 = *puVar6;
if ((int)uVar2 < 1) {
iVar7 = 0;
iVar9 = 0;
if (0 < (int)uVar3) goto LAB_00101213;
LAB_0010122f:
if (((int)uVar3 < (int)uVar2) && (iVar9 == iVar7)) goto LAB_001011d3;
}
else {
iVar7 = 0;
uVar4 = uVar2;
do {
iVar7 = iVar7 + (uVar4 & 1);
uVar4 = (int)uVar4 >> 1;
} while (0 < (int)uVar4);
if ((int)uVar3 < 1) {
iVar9 = 0;
}
else {
LAB_00101213:
iVar9 = 0;
uVar4 = uVar3;
do {
iVar9 = iVar9 + (uVar4 & 1);
uVar4 = (int)uVar4 >> 1;
} while (0 < (int)uVar4);
}
if (iVar7 <= iVar9) goto LAB_0010122f;
LAB_001011d3:
puVar8[-1] = uVar3;
*puVar6 = uVar2;
}
puVar6 = puVar6 + 1;
} while (puVar6 != (uint *)(param_1 + 8 +
((uVar5 - 1) + (ulong)((param_2 - 1) - (int)uVar5)) * 4));
uVar1 = uVar5 + 1;
puVar8 = puVar8 + 1;
if ((uVar5 == (long)(int)param_2) || (uVar5 = uVar1, uVar1 == param_2)) {
return;
}
} while( true );
}
}
return;
}
|
1,122 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
}
x = count_ones;
count_ones = 0;
while (y > 0) {
count_ones += y & 1;
y >>= 1;
}
y = count_ones;
if (y < x || (y == x && arr[j] < arr[i])) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
func0(test1, 5);
assert(issame(test1, 5, expected1, 5));
int test3[] = {1, 0, 2, 3, 4};
int expected3[] = {0, 1, 2, 4, 3};
func0(test3, 5);
assert(issame(test3, 5, expected3, 5));
int test4[] = {2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4};
int expected4[] = {2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77};
func0(test4, 11);
assert(issame(test4, 11, expected4, 11));
int test5[] = {3, 6, 44, 12, 32, 5};
int expected5[] = {32, 3, 5, 6, 12, 44};
func0(test5, 6);
assert(issame(test5, 6, expected5, 6));
int test6[] = {2, 4, 8, 16, 32};
int expected6[] = {2, 4, 8, 16, 32};
func0(test6, 5);
assert(issame(test6, 5, expected6, 5));
printf("All tests passed!\n");
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 164e <func0+0xbe>
push %r12
lea -0x1(%rsi),%r12d
mov %rdi,%r11
mov %rdi,%r10
push %rbp
add $0x1,%r12
mov $0x1,%ebp
push %rbx
mov %esi,%ebx
cmp %rbp,%r12
je 1628 <func0+0x98>
nopw 0x0(%rax,%rax,1)
mov %rbp,%rdi
nopl 0x0(%rax,%rax,1)
mov (%r10),%r8d
mov (%r11,%rdi,4),%r9d
test %r8d,%r8d
jle 1640 <func0+0xb0>
mov %r8d,%eax
xor %ecx,%ecx
nopl 0x0(%rax)
mov %eax,%edx
and $0x1,%edx
add %edx,%ecx
sar %eax
jne 15e0 <func0+0x50>
test %r9d,%r9d
jle 1603 <func0+0x73>
mov %r9d,%edx
xor %eax,%eax
nopl (%rax)
mov %edx,%esi
and $0x1,%esi
add %esi,%eax
sar %edx
jne 15f8 <func0+0x68>
cmp %eax,%ecx
jg 1630 <func0+0xa0>
sete %al
cmp %r9d,%r8d
jle 1613 <func0+0x83>
test %al,%al
jne 1630 <func0+0xa0>
add $0x1,%rdi
cmp %edi,%ebx
jg 15c8 <func0+0x38>
add $0x1,%rbp
add $0x4,%r10
cmp %rbp,%r12
jne 15c0 <func0+0x30>
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
mov %r9d,(%r10)
mov %r8d,(%r11,%rdi,4)
jmp 1613 <func0+0x83>
nopl 0x0(%rax)
xor %ecx,%ecx
mov $0x1,%eax
test %r9d,%r9d
jg 15f0 <func0+0x60>
jmp 160a <func0+0x7a>
retq
|
func0:
endbr64
test esi, esi
jle locret_158E
push rbp
mov r10, rdi
mov ebp, esi
mov r11d, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_1564
loc_1500:
mov rdi, r11
nop dword ptr [rax+rax+00h]
loc_1508:
mov r8d, [r10+r11*4-4]
mov r9d, [r10+rdi*4]
test r8d, r8d
jle short loc_1580
mov eax, r8d
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1520:
mov edx, eax
and edx, 1
add ecx, edx
sar eax, 1
jnz short loc_1520
test r9d, r9d
jle short loc_1543
loc_1530:
mov edx, r9d
xor eax, eax
nop dword ptr [rax]
loc_1538:
mov esi, edx
and esi, 1
add eax, esi
sar edx, 1
jnz short loc_1538
loc_1543:
cmp ecx, eax
jg short loc_1570
setz al
loc_154A:
cmp r8d, r9d
jle short loc_1553
test al, al
jnz short loc_1570
loc_1553:
add rdi, 1
cmp ebx, edi
jg short loc_1508
add r11, 1
cmp r11, rbp
jnz short loc_1500
loc_1564:
pop rbx
pop rbp
retn
loc_1570:
mov [r10+r11*4-4], r9d
mov [r10+rdi*4], r8d
jmp short loc_1553
loc_1580:
xor ecx, ecx
mov eax, 1
test r9d, r9d
jg short loc_1530
jmp short loc_154A
locret_158E:
retn
|
void func0(long long a1, int a2)
{
long long v3; // r11
long long v4; // rdi
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // ecx
int v9; // edx
bool v10; // al
if ( a2 > 0 )
{
v3 = 1LL;
if ( a2 != 1 )
{
do
{
v4 = v3;
do
{
v5 = *(_DWORD *)(a1 + 4 * v3 - 4);
v6 = *(_DWORD *)(a1 + 4 * v4);
if ( v5 > 0 )
{
v7 = *(_DWORD *)(a1 + 4 * v3 - 4);
v8 = 0;
do
{
v8 += v7 & 1;
v7 >>= 1;
}
while ( v7 );
if ( v6 > 0 )
{
LABEL_8:
v9 = *(_DWORD *)(a1 + 4 * v4);
v7 = 0;
do
{
v7 += v9 & 1;
v9 >>= 1;
}
while ( v9 );
}
if ( v8 > v7 )
goto LABEL_17;
v10 = v8 == v7;
goto LABEL_12;
}
v8 = 0;
v10 = 1;
if ( v6 > 0 )
goto LABEL_8;
LABEL_12:
if ( v5 > v6 && v10 )
{
LABEL_17:
*(_DWORD *)(a1 + 4 * v3 - 4) = v6;
*(_DWORD *)(a1 + 4 * v4) = v5;
}
++v4;
}
while ( a2 > (int)v4 );
++v3;
}
while ( v3 != a2 );
}
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010158e
PUSH RBP
MOV R10,RDI
MOV EBP,ESI
MOV R11D,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x00101564
LAB_00101500:
MOV RDI,R11
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV R8D,dword ptr [R10 + R11*0x4 + -0x4]
MOV R9D,dword ptr [R10 + RDI*0x4]
TEST R8D,R8D
JLE 0x00101580
MOV EAX,R8D
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV EDX,EAX
AND EDX,0x1
ADD ECX,EDX
SAR EAX,0x1
JNZ 0x00101520
TEST R9D,R9D
JLE 0x00101543
LAB_00101530:
MOV EDX,R9D
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101538:
MOV ESI,EDX
AND ESI,0x1
ADD EAX,ESI
SAR EDX,0x1
JNZ 0x00101538
LAB_00101543:
CMP ECX,EAX
JG 0x00101570
SETZ AL
LAB_0010154a:
CMP R8D,R9D
JLE 0x00101553
TEST AL,AL
JNZ 0x00101570
LAB_00101553:
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101508
ADD R11,0x1
CMP R11,RBP
JNZ 0x00101500
LAB_00101564:
POP RBX
POP RBP
RET
LAB_00101570:
MOV dword ptr [R10 + R11*0x4 + -0x4],R9D
MOV dword ptr [R10 + RDI*0x4],R8D
JMP 0x00101553
LAB_00101580:
XOR ECX,ECX
MOV EAX,0x1
TEST R9D,R9D
JG 0x00101530
JMP 0x0010154a
LAB_0010158e:
RET
|
void func0(long param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
int iVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
if ((int)param_2 < 1) {
return;
}
uVar6 = 1;
uVar7 = uVar6;
if (param_2 != 1) {
do {
uVar1 = *(uint *)(param_1 + -4 + uVar7 * 4);
uVar2 = *(uint *)(param_1 + uVar6 * 4);
if ((int)uVar1 < 1) {
iVar5 = 0;
bVar8 = true;
if (0 < (int)uVar2) goto LAB_00101530;
LAB_0010154a:
if (((int)uVar2 < (int)uVar1) && (bVar8)) goto LAB_00101570;
}
else {
iVar5 = 0;
uVar3 = uVar1;
do {
iVar5 = iVar5 + (uVar3 & 1);
uVar3 = (int)uVar3 >> 1;
} while (uVar3 != 0);
iVar4 = 0;
if (0 < (int)uVar2) {
LAB_00101530:
iVar4 = 0;
uVar3 = uVar2;
do {
iVar4 = iVar4 + (uVar3 & 1);
uVar3 = (int)uVar3 >> 1;
} while (uVar3 != 0);
}
bVar8 = iVar5 == iVar4;
if (iVar5 <= iVar4) goto LAB_0010154a;
LAB_00101570:
*(uint *)(param_1 + -4 + uVar7 * 4) = uVar2;
*(uint *)(param_1 + uVar6 * 4) = uVar1;
}
uVar6 = uVar6 + 1;
} while (((int)uVar6 < (int)param_2) || (uVar6 = uVar7 + 1, uVar7 = uVar6, uVar6 != param_2));
}
return;
}
|
1,123 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int *arr, int size) {
int count_ones, x, y, temp;
for (int i = 0; i < size; i++) {
for (int j = i + 1; j < size; j++) {
count_ones = 0;
x = arr[i];
y = arr[j];
while (x > 0) {
count_ones += x & 1;
x >>= 1;
}
x = count_ones;
count_ones = 0;
while (y > 0) {
count_ones += y & 1;
y >>= 1;
}
y = count_ones;
if (y < x || (y == x && arr[j] < arr[i])) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int test1[] = {1, 5, 2, 3, 4};
int expected1[] = {1, 2, 4, 3, 5};
func0(test1, 5);
assert(issame(test1, 5, expected1, 5));
int test3[] = {1, 0, 2, 3, 4};
int expected3[] = {0, 1, 2, 4, 3};
func0(test3, 5);
assert(issame(test3, 5, expected3, 5));
int test4[] = {2, 5, 77, 4, 5, 3, 5, 7, 2, 3, 4};
int expected4[] = {2, 2, 4, 4, 3, 3, 5, 5, 5, 7, 77};
func0(test4, 11);
assert(issame(test4, 11, expected4, 11));
int test5[] = {3, 6, 44, 12, 32, 5};
int expected5[] = {32, 3, 5, 6, 12, 44};
func0(test5, 6);
assert(issame(test5, 6, expected5, 6));
int test6[] = {2, 4, 8, 16, 32};
int expected6[] = {2, 4, 8, 16, 32};
func0(test6, 5);
assert(issame(test6, 5, expected6, 5));
printf("All tests passed!\n");
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 159e <func0+0xbe>
push %r12
lea -0x2(%rsi),%r12d
mov %rdi,%r11
mov %rdi,%r10
push %rbp
add $0x2,%r12
mov $0x1,%ebp
push %rbx
mov %esi,%ebx
nopw %cs:0x0(%rax,%rax,1)
mov %rbp,%rdi
nopl 0x0(%rax,%rax,1)
mov (%r10),%r8d
mov (%r11,%rdi,4),%r9d
test %r8d,%r8d
jle 1590 <func0+0xb0>
mov %r8d,%eax
xor %ecx,%ecx
nopl 0x0(%rax)
mov %eax,%edx
and $0x1,%edx
add %edx,%ecx
sar %eax
jne 1530 <func0+0x50>
test %r9d,%r9d
jle 1553 <func0+0x73>
mov %r9d,%edx
xor %eax,%eax
nopl (%rax)
mov %edx,%esi
and $0x1,%esi
add %esi,%eax
sar %edx
jne 1548 <func0+0x68>
cmp %eax,%ecx
jg 1580 <func0+0xa0>
sete %al
cmp %r9d,%r8d
jle 1563 <func0+0x83>
test %al,%al
jne 1580 <func0+0xa0>
add $0x1,%rdi
cmp %edi,%ebx
jg 1518 <func0+0x38>
add $0x1,%rbp
add $0x4,%r10
cmp %rbp,%r12
jne 1510 <func0+0x30>
pop %rbx
pop %rbp
pop %r12
retq
nopl (%rax)
mov %r9d,(%r10)
mov %r8d,(%r11,%rdi,4)
jmp 1563 <func0+0x83>
nopl 0x0(%rax)
xor %ecx,%ecx
mov $0x1,%eax
test %r9d,%r9d
jg 1540 <func0+0x60>
jmp 155a <func0+0x7a>
retq
|
func0:
endbr64
test esi, esi
jle locret_158E
push rbp
mov r10, rdi
mov ebp, esi
mov r11d, 1
push rbx
mov ebx, esi
cmp esi, 1
jz short loc_1564
loc_1500:
mov rdi, r11
nop dword ptr [rax+rax+00h]
loc_1508:
mov r8d, [r10+r11*4-4]
mov r9d, [r10+rdi*4]
test r8d, r8d
jle short loc_1580
mov eax, r8d
xor ecx, ecx
nop dword ptr [rax+rax+00h]
loc_1520:
mov edx, eax
and edx, 1
add ecx, edx
sar eax, 1
jnz short loc_1520
test r9d, r9d
jle short loc_1543
loc_1530:
mov edx, r9d
xor eax, eax
nop dword ptr [rax]
loc_1538:
mov esi, edx
and esi, 1
add eax, esi
sar edx, 1
jnz short loc_1538
loc_1543:
cmp ecx, eax
jg short loc_1570
setz al
loc_154A:
cmp r8d, r9d
jle short loc_1553
test al, al
jnz short loc_1570
loc_1553:
add rdi, 1
cmp ebx, edi
jg short loc_1508
add r11, 1
cmp rbp, r11
jnz short loc_1500
loc_1564:
pop rbx
pop rbp
retn
loc_1570:
mov [r10+r11*4-4], r9d
mov [r10+rdi*4], r8d
jmp short loc_1553
loc_1580:
xor ecx, ecx
mov eax, 1
test r9d, r9d
jg short loc_1530
jmp short loc_154A
locret_158E:
retn
|
void func0(long long a1, int a2)
{
long long v3; // r11
long long v4; // rdi
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // ecx
int v9; // edx
bool v10; // al
if ( a2 > 0 )
{
v3 = 1LL;
if ( a2 != 1 )
{
do
{
v4 = v3;
do
{
v5 = *(_DWORD *)(a1 + 4 * v3 - 4);
v6 = *(_DWORD *)(a1 + 4 * v4);
if ( v5 > 0 )
{
v7 = *(_DWORD *)(a1 + 4 * v3 - 4);
v8 = 0;
do
{
v8 += v7 & 1;
v7 >>= 1;
}
while ( v7 );
if ( v6 > 0 )
{
LABEL_8:
v9 = *(_DWORD *)(a1 + 4 * v4);
v7 = 0;
do
{
v7 += v9 & 1;
v9 >>= 1;
}
while ( v9 );
}
if ( v8 > v7 )
goto LABEL_17;
v10 = v8 == v7;
goto LABEL_12;
}
v8 = 0;
v10 = 1;
if ( v6 > 0 )
goto LABEL_8;
LABEL_12:
if ( v5 > v6 && v10 )
{
LABEL_17:
*(_DWORD *)(a1 + 4 * v3 - 4) = v6;
*(_DWORD *)(a1 + 4 * v4) = v5;
}
++v4;
}
while ( a2 > (int)v4 );
++v3;
}
while ( a2 != v3 );
}
}
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010158e
PUSH RBP
MOV R10,RDI
MOV EBP,ESI
MOV R11D,0x1
PUSH RBX
MOV EBX,ESI
CMP ESI,0x1
JZ 0x00101564
LAB_00101500:
MOV RDI,R11
NOP dword ptr [RAX + RAX*0x1]
LAB_00101508:
MOV R8D,dword ptr [R10 + R11*0x4 + -0x4]
MOV R9D,dword ptr [R10 + RDI*0x4]
TEST R8D,R8D
JLE 0x00101580
MOV EAX,R8D
XOR ECX,ECX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101520:
MOV EDX,EAX
AND EDX,0x1
ADD ECX,EDX
SAR EAX,0x1
JNZ 0x00101520
TEST R9D,R9D
JLE 0x00101543
LAB_00101530:
MOV EDX,R9D
XOR EAX,EAX
NOP dword ptr [RAX]
LAB_00101538:
MOV ESI,EDX
AND ESI,0x1
ADD EAX,ESI
SAR EDX,0x1
JNZ 0x00101538
LAB_00101543:
CMP ECX,EAX
JG 0x00101570
SETZ AL
LAB_0010154a:
CMP R8D,R9D
JLE 0x00101553
TEST AL,AL
JNZ 0x00101570
LAB_00101553:
ADD RDI,0x1
CMP EBX,EDI
JG 0x00101508
ADD R11,0x1
CMP RBP,R11
JNZ 0x00101500
LAB_00101564:
POP RBX
POP RBP
RET
LAB_00101570:
MOV dword ptr [R10 + R11*0x4 + -0x4],R9D
MOV dword ptr [R10 + RDI*0x4],R8D
JMP 0x00101553
LAB_00101580:
XOR ECX,ECX
MOV EAX,0x1
TEST R9D,R9D
JG 0x00101530
JMP 0x0010154a
LAB_0010158e:
RET
|
void func0(long param_1,uint param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
int iVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
bool bVar8;
if ((int)param_2 < 1) {
return;
}
uVar6 = 1;
uVar7 = uVar6;
if (param_2 != 1) {
do {
uVar1 = *(uint *)(param_1 + -4 + uVar7 * 4);
uVar2 = *(uint *)(param_1 + uVar6 * 4);
if ((int)uVar1 < 1) {
iVar5 = 0;
bVar8 = true;
if (0 < (int)uVar2) goto LAB_00101530;
LAB_0010154a:
if (((int)uVar2 < (int)uVar1) && (bVar8)) goto LAB_00101570;
}
else {
iVar5 = 0;
uVar3 = uVar1;
do {
iVar5 = iVar5 + (uVar3 & 1);
uVar3 = (int)uVar3 >> 1;
} while (uVar3 != 0);
iVar4 = 0;
if (0 < (int)uVar2) {
LAB_00101530:
iVar4 = 0;
uVar3 = uVar2;
do {
iVar4 = iVar4 + (uVar3 & 1);
uVar3 = (int)uVar3 >> 1;
} while (uVar3 != 0);
}
bVar8 = iVar5 == iVar4;
if (iVar5 <= iVar4) goto LAB_0010154a;
LAB_00101570:
*(uint *)(param_1 + -4 + uVar7 * 4) = uVar2;
*(uint *)(param_1 + uVar6 * 4) = uVar1;
}
uVar6 = uVar6 + 1;
} while (((int)uVar6 < (int)param_2) || (uVar6 = uVar7 + 1, uVar7 = uVar6, param_2 != uVar6));
}
return;
}
|
1,124 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\0') {
if (numc == n) {
current[i - begin] = '\0';
out = (char **)realloc(out, sizeof(char *) * (word_count + 1));
out[word_count] = (char *)malloc(strlen(current) + 1);
strcpy(out[word_count], current);
word_count++;
}
begin = i + 1;
numc = 0;
} else {
current[i - begin] = s[i];
if (strchr(vowels, s[i]) == NULL && isalpha((unsigned char)s[i])) {
numc++;
}
}
}
free(current);
*returnSize = word_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
for (int i = 0; i < count; i++) {
free(words[i]);
}
free(words);
}
int main() {
int size;
char **words;
words = func0("Mary had a little lamb", 4, &size);
char *expected1[] = {"little"};
assert(issame(words, size, expected1, 1));
free_words(words, size);
words = func0("Mary had a little lamb", 3, &size);
char *expected2[] = {"Mary", "lamb"};
assert(issame(words, size, expected2, 2));
free_words(words, size);
words = func0("simple white space", 2, &size);
assert(size == 0);
free_words(words, size);
words = func0("Hello world", 4, &size);
char *expected3[] = {"world"};
assert(issame(words, size, expected3, 1));
free_words(words, size);
words = func0("Uncle sam", 3, &size);
char *expected4[] = {"Uncle"};
assert(issame(words, size, expected4, 1));
free_words(words, size);
words = func0("", 4, &size);
assert(size == 0);
free_words(words, size);
words = func0("a b c d e f", 1, &size);
char *expected5[] = {"b", "c", "d", "f"};
assert(issame(words, size, expected5, 4));
free_words(words, size);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x58,%rsp
mov %rdi,-0x48(%rbp)
mov %esi,-0x4c(%rbp)
mov %rdx,-0x58(%rbp)
lea 0xd80(%rip),%rax
mov %rax,-0x28(%rbp)
movq $0x0,-0x30(%rbp)
movl $0x0,-0x40(%rbp)
movl $0x0,-0x3c(%rbp)
movl $0x0,-0x38(%rbp)
mov -0x48(%rbp),%rax
mov %rax,%rdi
callq 1100 <strlen@plt>
mov %rax,-0x20(%rbp)
mov -0x20(%rbp),%rax
add $0x1,%rax
mov %rax,%rdi
callq 1150 <malloc@plt>
mov %rax,-0x18(%rbp)
movl $0x0,-0x34(%rbp)
jmpq 1452 <func0+0x1e9>
callq 1170 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x2000,%eax
test %eax,%eax
jne 1322 <func0+0xb9>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 13d1 <func0+0x168>
mov -0x40(%rbp),%eax
cmp -0x4c(%rbp),%eax
jne 13bf <func0+0x156>
mov -0x34(%rbp),%eax
sub -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movb $0x0,(%rax)
mov -0x3c(%rbp),%eax
add $0x1,%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x30(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 1160 <realloc@plt>
mov %rax,-0x30(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 1100 <strlen@plt>
add $0x1,%rax
mov -0x3c(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,8),%rcx
mov -0x30(%rbp),%rdx
lea (%rcx,%rdx,1),%rbx
mov %rax,%rdi
callq 1150 <malloc@plt>
mov %rax,(%rbx)
mov -0x3c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x18(%rbp),%rdx
mov %rdx,%rsi
mov %rax,%rdi
callq 10f0 <strcpy@plt>
addl $0x1,-0x3c(%rbp)
mov -0x34(%rbp),%eax
add $0x1,%eax
mov %eax,-0x38(%rbp)
movl $0x0,-0x40(%rbp)
jmp 144e <func0+0x1e5>
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x34(%rbp),%eax
sub -0x38(%rbp),%eax
movslq %eax,%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
movzbl (%rcx),%eax
mov %al,(%rdx)
mov -0x34(%rbp),%eax
movslq %eax,%rdx
mov -0x48(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x28(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1120 <strchr@plt>
test %rax,%rax
jne 144e <func0+0x1e5>
callq 1170 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x34(%rbp),%edx
movslq %edx,%rcx
mov -0x48(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
je 144e <func0+0x1e5>
addl $0x1,-0x40(%rbp)
addl $0x1,-0x34(%rbp)
mov -0x34(%rbp),%eax
cltq
cmp %rax,-0x20(%rbp)
jae 12d9 <func0+0x70>
mov -0x18(%rbp),%rax
mov %rax,%rdi
callq 10e0 <free@plt>
mov -0x58(%rbp),%rax
mov -0x3c(%rbp),%edx
mov %edx,(%rax)
mov -0x30(%rbp),%rax
add $0x58,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+s], rdi
mov [rbp+var_4C], esi
mov [rbp+var_58], rdx
lea rax, aAeiouaeiou; "aeiouAEIOU"
mov [rbp+var_28], rax
mov [rbp+ptr], 0
mov [rbp+var_40], 0
mov [rbp+var_3C], 0
mov [rbp+var_38], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
add rax, 1
mov rdi, rax; size
call _malloc
mov [rbp+src], rax
mov [rbp+var_34], 0
jmp loc_1452
loc_12D9:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_34]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 2000h
test eax, eax
jnz short loc_1322
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz loc_13D1
loc_1322:
mov eax, [rbp+var_40]
cmp eax, [rbp+var_4C]
jnz loc_13BF
mov eax, [rbp+var_34]
sub eax, [rbp+var_38]
movsxd rdx, eax
mov rax, [rbp+src]
add rax, rdx
mov byte ptr [rax], 0
mov eax, [rbp+var_3C]
add eax, 1
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
mov rax, [rbp+src]
mov rdi, rax; s
call _strlen
add rax, 1
mov edx, [rbp+var_3C]
movsxd rdx, edx
lea rcx, ds:0[rdx*8]
mov rdx, [rbp+ptr]
lea rbx, [rcx+rdx]
mov rdi, rax; size
call _malloc
mov [rbx], rax
mov eax, [rbp+var_3C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+ptr]
add rax, rdx
mov rax, [rax]
mov rdx, [rbp+src]
mov rsi, rdx; src
mov rdi, rax; dest
call _strcpy
add [rbp+var_3C], 1
loc_13BF:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_38], eax
mov [rbp+var_40], 0
jmp short loc_144E
loc_13D1:
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_34]
sub eax, [rbp+var_38]
movsxd rdx, eax
mov rax, [rbp+src]
add rdx, rax
movzx eax, byte ptr [rcx]
mov [rdx], al
mov eax, [rbp+var_34]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+var_28]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_144E
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_34]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jz short loc_144E
add [rbp+var_40], 1
loc_144E:
add [rbp+var_34], 1
loc_1452:
mov eax, [rbp+var_34]
cdqe
cmp [rbp+var_20], rax
jnb loc_12D9
mov rax, [rbp+src]
mov rdi, rax; ptr
call _free
mov rax, [rbp+var_58]
mov edx, [rbp+var_3C]
mov [rax], edx
mov rax, [rbp+ptr]
mov rbx, [rbp+var_8]
leave
retn
|
void * func0(const char *a1, int a2, _DWORD *a3)
{
size_t v3; // rax
int v6; // [rsp+20h] [rbp-40h]
int v7; // [rsp+24h] [rbp-3Ch]
int v8; // [rsp+28h] [rbp-38h]
int i; // [rsp+2Ch] [rbp-34h]
void *ptr; // [rsp+30h] [rbp-30h]
size_t v11; // [rsp+40h] [rbp-20h]
char *src; // [rsp+48h] [rbp-18h]
ptr = 0LL;
v6 = 0;
v7 = 0;
v8 = 0;
v11 = strlen(a1);
src = (char *)malloc(v11 + 1);
for ( i = 0; v11 >= i; ++i )
{
if ( ((*__ctype_b_loc())[a1[i]] & 0x2000) == 0 && a1[i] )
{
src[i - v8] = a1[i];
if ( !strchr("aeiouAEIOU", a1[i]) && ((*__ctype_b_loc())[(unsigned __int8)a1[i]] & 0x400) != 0 )
++v6;
}
else
{
if ( v6 == a2 )
{
src[i - v8] = 0;
ptr = realloc(ptr, 8LL * (v7 + 1));
v3 = strlen(src);
*((_QWORD *)ptr + v7) = malloc(v3 + 1);
strcpy(*((char **)ptr + v7++), src);
}
v8 = i + 1;
v6 = 0;
}
}
free(src);
*a3 = v7;
return ptr;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV qword ptr [RBP + -0x48],RDI
MOV dword ptr [RBP + -0x4c],ESI
MOV qword ptr [RBP + -0x58],RDX
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x30],0x0
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x3c],0x0
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00101100
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00101452
LAB_001012d9:
CALL 0x00101170
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x2000
TEST EAX,EAX
JNZ 0x00101322
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x001013d1
LAB_00101322:
MOV EAX,dword ptr [RBP + -0x40]
CMP EAX,dword ptr [RBP + -0x4c]
JNZ 0x001013bf
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV byte ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x00101160
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00101100
ADD RAX,0x1
MOV EDX,dword ptr [RBP + -0x3c]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x8]
MOV RDX,qword ptr [RBP + -0x30]
LEA RBX,[RCX + RDX*0x1]
MOV RDI,RAX
CALL 0x00101150
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [RBP + -0x3c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010f0
ADD dword ptr [RBP + -0x3c],0x1
LAB_001013bf:
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
MOV dword ptr [RBP + -0x40],0x0
JMP 0x0010144e
LAB_001013d1:
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,dword ptr [RBP + -0x38]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOVZX EAX,byte ptr [RCX]
MOV byte ptr [RDX],AL
MOV EAX,dword ptr [RBP + -0x34]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101120
TEST RAX,RAX
JNZ 0x0010144e
CALL 0x00101170
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x34]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JZ 0x0010144e
ADD dword ptr [RBP + -0x40],0x1
LAB_0010144e:
ADD dword ptr [RBP + -0x34],0x1
LAB_00101452:
MOV EAX,dword ptr [RBP + -0x34]
CDQE
CMP qword ptr [RBP + -0x20],RAX
JNC 0x001012d9
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x001010e0
MOV RAX,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RBP + -0x3c]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x30]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(char *param_1,int param_2,int *param_3)
{
size_t sVar1;
char *__s;
ushort **ppuVar2;
size_t sVar3;
void *pvVar4;
char *pcVar5;
int local_48;
int local_44;
int local_40;
int local_3c;
void *local_38;
local_38 = (void *)0x0;
local_48 = 0;
local_44 = 0;
local_40 = 0;
sVar1 = strlen(param_1);
__s = (char *)malloc(sVar1 + 1);
for (local_3c = 0; (ulong)(long)local_3c <= sVar1; local_3c = local_3c + 1) {
ppuVar2 = __ctype_b_loc();
if ((((*ppuVar2)[param_1[local_3c]] & 0x2000) == 0) && (param_1[local_3c] != '\0')) {
__s[local_3c - local_40] = param_1[local_3c];
pcVar5 = strchr("aeiouAEIOU",(int)param_1[local_3c]);
if (pcVar5 == (char *)0x0) {
ppuVar2 = __ctype_b_loc();
if (((*ppuVar2)[(byte)param_1[local_3c]] & 0x400) != 0) {
local_48 = local_48 + 1;
}
}
}
else {
if (local_48 == param_2) {
__s[local_3c - local_40] = '\0';
local_38 = realloc(local_38,(long)(local_44 + 1) * 8);
sVar3 = strlen(__s);
pvVar4 = malloc(sVar3 + 1);
*(void **)((long)local_44 * 8 + (long)local_38) = pvVar4;
strcpy(*(char **)((long)local_38 + (long)local_44 * 8),__s);
local_44 = local_44 + 1;
}
local_40 = local_3c + 1;
local_48 = 0;
}
}
free(__s);
*param_3 = local_44;
return local_38;
}
|
1,125 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\0') {
if (numc == n) {
current[i - begin] = '\0';
out = (char **)realloc(out, sizeof(char *) * (word_count + 1));
out[word_count] = (char *)malloc(strlen(current) + 1);
strcpy(out[word_count], current);
word_count++;
}
begin = i + 1;
numc = 0;
} else {
current[i - begin] = s[i];
if (strchr(vowels, s[i]) == NULL && isalpha((unsigned char)s[i])) {
numc++;
}
}
}
free(current);
*returnSize = word_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
for (int i = 0; i < count; i++) {
free(words[i]);
}
free(words);
}
int main() {
int size;
char **words;
words = func0("Mary had a little lamb", 4, &size);
char *expected1[] = {"little"};
assert(issame(words, size, expected1, 1));
free_words(words, size);
words = func0("Mary had a little lamb", 3, &size);
char *expected2[] = {"Mary", "lamb"};
assert(issame(words, size, expected2, 2));
free_words(words, size);
words = func0("simple white space", 2, &size);
assert(size == 0);
free_words(words, size);
words = func0("Hello world", 4, &size);
char *expected3[] = {"world"};
assert(issame(words, size, expected3, 1));
free_words(words, size);
words = func0("Uncle sam", 3, &size);
char *expected4[] = {"Uncle"};
assert(issame(words, size, expected4, 1));
free_words(words, size);
words = func0("", 4, &size);
assert(size == 0);
free_words(words, size);
words = func0("a b c d e f", 1, &size);
char *expected5[] = {"b", "c", "d", "f"};
assert(issame(words, size, expected5, 4));
free_words(words, size);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %rdi,%r14
mov %esi,0x18(%rsp)
mov %rdx,0x28(%rsp)
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
mov %rcx,%rdi
not %rdi
lea -0x1(%rdi),%rax
mov %rax,0x8(%rsp)
callq 1130 <malloc@plt>
mov %rax,0x10(%rsp)
callq 1150 <__ctype_b_loc@plt>
mov %rax,%r15
mov $0x0,%ebx
mov $0x0,%r13d
movl $0x0,0x1c(%rsp)
movl $0x0,0x4(%rsp)
movq $0x0,0x20(%rsp)
jmp 12e8 <func0+0x9f>
mov 0x4(%rsp),%edx
cmp %edx,0x18(%rsp)
je 1341 <func0+0xf8>
mov (%rsp),%r13d
add $0x1,%r13d
movl $0x0,0x4(%rsp)
lea 0x1(%rbx),%rax
cmp %rbx,0x8(%rsp)
je 13ab <func0+0x162>
mov %rax,%rbx
mov %ebx,(%rsp)
mov %ebx,%eax
mov (%r15),%r12
movzbl (%r14,%rbx,1),%ebp
movsbq %bpl,%rdx
testb $0x20,0x1(%r12,%rdx,2)
jne 12bc <func0+0x73>
test %bpl,%bpl
je 12bc <func0+0x73>
sub %r13d,%eax
cltq
mov 0x10(%rsp),%rdi
mov %bpl,(%rdi,%rax,1)
movsbl %bpl,%esi
lea 0xce5(%rip),%rdi
callq 1100 <strchr@plt>
test %rax,%rax
jne 12d6 <func0+0x8d>
movzbl %bpl,%ebp
movzwl (%r12,%rbp,2),%eax
and $0x400,%ax
cmp $0x1,%ax
sbbl $0xffffffff,0x4(%rsp)
jmp 12d6 <func0+0x8d>
sub %r13d,%eax
cltq
mov 0x10(%rsp),%r12
movb $0x0,(%r12,%rax,1)
addl $0x1,0x1c(%rsp)
mov 0x1c(%rsp),%eax
movslq %eax,%rbp
shl $0x3,%rbp
mov %rbp,%rsi
mov 0x20(%rsp),%rdi
callq 1140 <realloc@plt>
mov %rax,%r13
mov %rax,0x20(%rsp)
mov $0x0,%eax
mov $0xffffffffffffffff,%rcx
mov %r12,0x10(%rsp)
mov %r12,%rdi
repnz scas %es:(%rdi),%al
not %rcx
mov %rcx,%rdi
callq 1130 <malloc@plt>
mov %rax,%rdi
mov %rax,-0x8(%r13,%rbp,1)
mov %r12,%rsi
callq 10e0 <strcpy@plt>
jmpq 12c6 <func0+0x7d>
mov 0x10(%rsp),%rdi
callq 10d0 <free@plt>
mov 0x28(%rsp),%rax
mov 0x1c(%rsp),%esi
mov %esi,(%rax)
mov 0x20(%rsp),%rax
add $0x38,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov r15, rdi
mov [rsp+68h+var_58], esi
mov rbp, rdx
call _strlen
mov r14, rax
lea rdi, [rax+1]; size
call _malloc
mov [rsp+68h+s], rax
call ___ctype_b_loc
mov [rsp+68h+var_60], rax
mov ebx, 0
mov r13d, 0
mov [rsp+68h+var_54], 0
mov [rsp+68h+var_64], 0
mov [rsp+68h+ptr], 0
mov [rsp+68h+var_40], rbp
jmp short loc_12FA
loc_12D0:
mov ecx, [rsp+68h+var_64]
cmp [rsp+68h+var_58], ecx
jz short loc_1358
loc_12DA:
mov r13d, [rsp+68h+var_68]
add r13d, 1
mov [rsp+68h+var_64], 0
loc_12EA:
lea rax, [rbx+1]
cmp rbx, r14
jz loc_13BB
mov rbx, rax
loc_12FA:
mov [rsp+68h+var_68], ebx
mov eax, ebx
mov rcx, [rsp+68h+var_60]
mov r12, [rcx]
movzx ebp, byte ptr [r15+rbx]
movsx rdx, bpl
test byte ptr [r12+rdx*2+1], 20h
jnz short loc_12D0
test bpl, bpl
jz short loc_12D0
sub eax, r13d
cdqe
mov rdi, [rsp+68h+s]
mov [rdi+rax], bpl
movsx esi, bpl; c
lea rdi, s; "aeiouAEIOU"
call _strchr
test rax, rax
jnz short loc_12EA
movzx ebp, bpl
movzx eax, word ptr [r12+rbp*2]
and ax, 400h
cmp ax, 1
sbb [rsp+68h+var_64], 0FFFFFFFFh
jmp short loc_12EA
loc_1358:
sub eax, r13d
cdqe
mov r13, [rsp+68h+s]
mov byte ptr [r13+rax+0], 0
add [rsp+68h+var_54], 1
mov eax, [rsp+68h+var_54]
movsxd r12, eax
shl r12, 3
mov rsi, r12; size
mov rdi, [rsp+68h+ptr]; ptr
call _realloc
mov [rsp+68h+ptr], rax
mov rdi, r13; s
call _strlen
lea rbp, [rax+1]
mov rdi, rbp; size
call _malloc
mov rdi, rax
mov rax, [rsp+68h+ptr]
mov [rax+r12-8], rdi
mov rdx, rbp
mov rsi, r13
call ___strcpy_chk
jmp loc_12DA
loc_13BB:
mov rbp, [rsp+68h+var_40]
mov rdi, [rsp+68h+s]; ptr
call _free
mov eax, [rsp+68h+var_54]
mov [rbp+0], eax
mov rax, [rsp+68h+ptr]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
|
void * func0(const char *a1, int a2, _DWORD *a3)
{
size_t v4; // r14
long long v5; // rbx
int v6; // r13d
const unsigned __int16 *v7; // r12
char v8; // bp
size_t v9; // rbp
void *v10; // rax
int v12; // [rsp+4h] [rbp-64h]
const unsigned __int16 **v13; // [rsp+8h] [rbp-60h]
int v14; // [rsp+14h] [rbp-54h]
void *ptr; // [rsp+18h] [rbp-50h]
char *s; // [rsp+20h] [rbp-48h]
_DWORD *v17; // [rsp+28h] [rbp-40h]
v4 = strlen(a1);
s = (char *)malloc(v4 + 1);
v13 = __ctype_b_loc();
v5 = 0LL;
v6 = 0;
v14 = 0;
v12 = 0;
ptr = 0LL;
v17 = a3;
while ( 1 )
{
v7 = *v13;
v8 = a1[v5];
if ( ((*v13)[v8] & 0x2000) != 0 || !v8 )
{
if ( a2 == v12 )
{
s[(int)v5 - v6] = 0;
ptr = realloc(ptr, 8LL * ++v14);
v9 = strlen(s) + 1;
v10 = malloc(v9);
*((_QWORD *)ptr + v14 - 1) = v10;
__strcpy_chk(v10, s, v9);
}
v6 = v5 + 1;
v12 = 0;
}
else
{
s[(int)v5 - v6] = v8;
if ( !strchr("aeiouAEIOU", v8) )
v12 -= ((v7[(unsigned __int8)v8] & 0x400) == 0) - 1;
}
if ( v5 == v4 )
break;
++v5;
}
free(s);
*v17 = v14;
return ptr;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV R15,RDI
MOV dword ptr [RSP + 0x10],ESI
MOV RBP,RDX
CALL 0x001010f0
MOV R14,RAX
LEA RDI,[RAX + 0x1]
CALL 0x00101140
MOV qword ptr [RSP + 0x20],RAX
CALL 0x00101170
MOV qword ptr [RSP + 0x8],RAX
MOV EBX,0x0
MOV R13D,0x0
MOV dword ptr [RSP + 0x14],0x0
MOV dword ptr [RSP + 0x4],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x28],RBP
JMP 0x001012fa
LAB_001012d0:
MOV ECX,dword ptr [RSP + 0x4]
CMP dword ptr [RSP + 0x10],ECX
JZ 0x00101358
LAB_001012da:
MOV R13D,dword ptr [RSP]
ADD R13D,0x1
MOV dword ptr [RSP + 0x4],0x0
LAB_001012ea:
LEA RAX,[RBX + 0x1]
CMP RBX,R14
JZ 0x001013bb
MOV RBX,RAX
LAB_001012fa:
MOV dword ptr [RSP],EBX
MOV EAX,EBX
MOV RCX,qword ptr [RSP + 0x8]
MOV R12,qword ptr [RCX]
MOVZX EBP,byte ptr [R15 + RBX*0x1]
MOVSX RDX,BPL
TEST byte ptr [R12 + RDX*0x2 + 0x1],0x20
JNZ 0x001012d0
TEST BPL,BPL
JZ 0x001012d0
SUB EAX,R13D
CDQE
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RDI + RAX*0x1],BPL
MOVSX ESI,BPL
LEA RDI,[0x102004]
CALL 0x00101110
TEST RAX,RAX
JNZ 0x001012ea
MOVZX EBP,BPL
MOVZX EAX,word ptr [R12 + RBP*0x2]
AND AX,0x400
CMP AX,0x1
SBB dword ptr [RSP + 0x4],-0x1
JMP 0x001012ea
LAB_00101358:
SUB EAX,R13D
CDQE
MOV R13,qword ptr [RSP + 0x20]
MOV byte ptr [R13 + RAX*0x1],0x0
ADD dword ptr [RSP + 0x14],0x1
MOV EAX,dword ptr [RSP + 0x14]
MOVSXD R12,EAX
SHL R12,0x3
MOV RSI,R12
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00101150
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,R13
CALL 0x001010f0
LEA RBP,[RAX + 0x1]
MOV RDI,RBP
CALL 0x00101140
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + R12*0x1 + -0x8],RDI
MOV RDX,RBP
MOV RSI,R13
CALL 0x00101160
JMP 0x001012da
LAB_001013bb:
MOV RBP,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x001010e0
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RBP],EAX
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
|
void * func0(char *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar10;
bool bVar11;
int local_64;
int local_54;
void *local_50;
size_t sVar9;
sVar3 = strlen(param_1);
__s = (char *)malloc(sVar3 + 1);
ppuVar4 = __ctype_b_loc();
iVar10 = 0;
local_54 = 0;
local_64 = 0;
local_50 = (void *)0x0;
sVar9 = 0;
do {
iVar8 = (int)sVar9;
puVar2 = *ppuVar4;
bVar1 = param_1[sVar9];
if (((*(byte *)((long)puVar2 + (long)(char)bVar1 * 2 + 1) & 0x20) == 0) && (bVar1 != 0)) {
__s[iVar8 - iVar10] = bVar1;
pcVar5 = strchr("aeiouAEIOU",(int)(char)bVar1);
if (pcVar5 == (char *)0x0) {
local_64 = (local_64 + 1) - (uint)((puVar2[bVar1] & 0x400) == 0);
}
}
else {
if (param_2 == local_64) {
__s[iVar8 - iVar10] = '\0';
local_54 = local_54 + 1;
local_50 = realloc(local_50,(long)local_54 * 8);
sVar6 = strlen(__s);
pvVar7 = malloc(sVar6 + 1);
*(void **)((long)local_50 + ((long)local_54 * 8 - 8U)) = pvVar7;
__strcpy_chk(pvVar7,__s,sVar6 + 1);
}
iVar10 = iVar8 + 1;
local_64 = 0;
}
bVar11 = sVar9 != sVar3;
sVar9 = sVar9 + 1;
} while (bVar11);
free(__s);
*param_3 = local_54;
return local_50;
}
|
1,126 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\0') {
if (numc == n) {
current[i - begin] = '\0';
out = (char **)realloc(out, sizeof(char *) * (word_count + 1));
out[word_count] = (char *)malloc(strlen(current) + 1);
strcpy(out[word_count], current);
word_count++;
}
begin = i + 1;
numc = 0;
} else {
current[i - begin] = s[i];
if (strchr(vowels, s[i]) == NULL && isalpha((unsigned char)s[i])) {
numc++;
}
}
}
free(current);
*returnSize = word_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
for (int i = 0; i < count; i++) {
free(words[i]);
}
free(words);
}
int main() {
int size;
char **words;
words = func0("Mary had a little lamb", 4, &size);
char *expected1[] = {"little"};
assert(issame(words, size, expected1, 1));
free_words(words, size);
words = func0("Mary had a little lamb", 3, &size);
char *expected2[] = {"Mary", "lamb"};
assert(issame(words, size, expected2, 2));
free_words(words, size);
words = func0("simple white space", 2, &size);
assert(size == 0);
free_words(words, size);
words = func0("Hello world", 4, &size);
char *expected3[] = {"world"};
assert(issame(words, size, expected3, 1));
free_words(words, size);
words = func0("Uncle sam", 3, &size);
char *expected4[] = {"Uncle"};
assert(issame(words, size, expected4, 1));
free_words(words, size);
words = func0("", 4, &size);
assert(size == 0);
free_words(words, size);
words = func0("a b c d e f", 1, &size);
char *expected5[] = {"b", "c", "d", "f"};
assert(issame(words, size, expected5, 4));
free_words(words, size);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
xor %r14d,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %esi,0xc(%rsp)
mov %rdx,0x28(%rsp)
callq 10f0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 1150 <malloc@plt>
add $0x1,%ebx
mov %rax,%rbp
callq 1170 <__ctype_b_loc@plt>
movl $0x0,0x20(%rsp)
xor %r10d,%r10d
xor %r9d,%r9d
mov (%rax),%r12
jmp 16a2 <func0+0x72>
nopl 0x0(%rax,%rax,1)
cmp %r9d,0xc(%rsp)
je 1740 <func0+0x110>
mov %r15d,%r10d
xor %r9d,%r9d
add $0x1,%r13
cmp %r15d,%ebx
je 1714 <func0+0xe4>
movsbq 0x0(%r13),%rsi
mov %r15d,%eax
add $0x1,%r15d
mov %rsi,%rdx
testb $0x20,0x1(%r12,%rsi,2)
jne 1688 <func0+0x58>
test %sil,%sil
je 1688 <func0+0x58>
sub %r10d,%eax
lea 0x93c(%rip),%rdi
mov %r9d,0x24(%rsp)
cltq
mov %r10d,0x18(%rsp)
mov %sil,0x0(%rbp,%rax,1)
movsbl %sil,%esi
mov %dl,0x10(%rsp)
callq 1110 <strchr@plt>
movzbl 0x10(%rsp),%edx
mov 0x18(%rsp),%r10d
test %rax,%rax
mov 0x24(%rsp),%r9d
jne 1699 <func0+0x69>
movzwl (%r12,%rdx,2),%eax
and $0x400,%ax
cmp $0x1,%ax
sbb $0xffffffff,%r9d
add $0x1,%r13
cmp %r15d,%ebx
jne 16a2 <func0+0x72>
mov %rbp,%rdi
callq 10e0 <free@plt>
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%ebx
mov %ebx,(%rax)
add $0x38,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
sub %r10d,%eax
addl $0x1,0x20(%rsp)
mov %r14,%rdi
cltq
movb $0x0,0x0(%rbp,%rax,1)
movslq 0x20(%rsp),%rax
shl $0x3,%rax
mov %rax,%rsi
mov %rax,0x18(%rsp)
callq 1160 <realloc@plt>
mov %rbp,%rdx
mov %rax,%r14
mov (%rdx),%esi
add $0x4,%rdx
lea -0x1010101(%rsi),%eax
not %esi
and %esi,%eax
and $0x80808080,%eax
je 176e <func0+0x13e>
mov %eax,%esi
shr $0x10,%esi
test $0x8080,%eax
cmove %esi,%eax
lea 0x2(%rdx),%rsi
cmove %rsi,%rdx
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdx
sub %rbp,%rdx
add $0x1,%rdx
mov %rdx,%rdi
mov %rdx,0x10(%rsp)
callq 1150 <malloc@plt>
mov 0x10(%rsp),%rdx
mov %rbp,%rsi
mov %rax,%rdi
mov 0x18(%rsp),%rax
mov %rdi,-0x8(%r14,%rax,1)
callq 1140 <memcpy@plt>
jmpq 1693 <func0+0x63>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
xor r15d, r15d
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_5C], esi
mov [rsp+68h+var_40], rdx
call _strlen
lea rdi, [rax+1]; size
mov rbx, rax
call _malloc
lea r13d, [rbx+1]
xor ebx, ebx
mov rbp, rax
call ___ctype_b_loc
mov [rsp+68h+var_48], 0
xor r11d, r11d
mov [rsp+68h+ptr], 0
mov r12, [rax]
jmp short loc_16BA
loc_16A0:
cmp [rsp+68h+var_5C], r15d
jz loc_1750
loc_16AB:
mov r11d, ebx
xor r15d, r15d
loc_16B1:
add r14, 1
cmp r13d, ebx
jz short loc_171F
loc_16BA:
movsx rsi, byte ptr [r14]
mov eax, ebx
add ebx, 1
mov rdx, rsi
test byte ptr [r12+rsi*2+1], 20h
jnz short loc_16A0
test sil, sil
jz short loc_16A0
sub eax, r11d
lea rdi, s; "aeiouAEIOU"
mov [rsp+68h+var_44], r11d
cdqe
mov byte ptr [rsp+68h+var_50], dl
mov [rbp+rax+0], sil
movsx esi, sil; c
call _strchr
movzx edx, byte ptr [rsp+68h+var_50]
mov r11d, [rsp+68h+var_44]
test rax, rax
jnz short loc_16B1
movzx eax, word ptr [r12+rdx*2]
and ax, 400h
cmp ax, 1
sbb r15d, 0FFFFFFFFh
add r14, 1
cmp r13d, ebx
jnz short loc_16BA
loc_171F:
mov rdi, rbp; ptr
call _free
mov rax, [rsp+68h+var_40]
mov edi, [rsp+68h+var_48]
mov [rax], edi
mov rax, [rsp+68h+ptr]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1750:
sub eax, r11d
add [rsp+68h+var_48], 1
movsxd rcx, [rsp+68h+var_48]
cdqe
mov rdi, [rsp+68h+ptr]; ptr
mov byte ptr [rbp+rax+0], 0
shl rcx, 3
mov rsi, rcx; size
mov [rsp+68h+var_50], rcx
call _realloc
mov rdi, rbp; s
mov [rsp+68h+ptr], rax
call _strlen
lea r15, [rax+1]
mov rdi, r15; size
call _malloc
mov rcx, [rsp+68h+var_50]
mov rdx, r15
mov rsi, rbp
mov rdi, rax
mov rax, [rsp+68h+ptr]
mov [rax+rcx-8], rdi
mov rcx, r15
call ___memcpy_chk
jmp loc_16AB
|
char * func0(const char *a1, int a2, _DWORD *a3)
{
int v3; // r15d
const char *v4; // r14
size_t v5; // rax
int v6; // r13d
int v7; // ebx
char *v8; // rbp
const unsigned __int16 **v9; // rax
int v10; // r11d
const unsigned __int16 *v11; // r12
long long v12; // rsi
int v13; // eax
char *v14; // rax
size_t v16; // r15
void *v17; // rax
char *ptr; // [rsp+10h] [rbp-58h]
size_t v20; // [rsp+18h] [rbp-50h]
int v21; // [rsp+20h] [rbp-48h]
int v22; // [rsp+24h] [rbp-44h]
v3 = 0;
v4 = a1;
v5 = strlen(a1);
v6 = v5 + 1;
v7 = 0;
v8 = (char *)malloc(v5 + 1);
v9 = __ctype_b_loc();
v21 = 0;
v10 = 0;
ptr = 0LL;
v11 = *v9;
do
{
while ( 1 )
{
v12 = *v4;
v13 = v7++;
if ( (v11[v12] & 0x2000) != 0 || !(_BYTE)v12 )
{
if ( a2 == v3 )
{
++v21;
v8[v13 - v10] = 0;
v20 = 8LL * v21;
ptr = (char *)realloc(ptr, v20);
v16 = strlen(v8) + 1;
v17 = malloc(v16);
*(_QWORD *)&ptr[v20 - 8] = v17;
__memcpy_chk(v17, v8, v16, v16);
}
v10 = v7;
v3 = 0;
goto LABEL_5;
}
v22 = v10;
v8[v13 - v10] = v12;
v14 = strchr("aeiouAEIOU", (char)v12);
v10 = v22;
if ( !v14 )
break;
LABEL_5:
++v4;
if ( v6 == v7 )
goto LABEL_10;
}
v3 -= ((v11[(unsigned __int8)v12] & 0x400) == 0) - 1;
++v4;
}
while ( v6 != v7 );
LABEL_10:
free(v8);
*a3 = v21;
return ptr;
}
|
func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0xc],ESI
MOV qword ptr [RSP + 0x28],RDX
CALL 0x001010f0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x00101150
LEA R13D,[RBX + 0x1]
XOR EBX,EBX
MOV RBP,RAX
CALL 0x00101170
MOV dword ptr [RSP + 0x20],0x0
XOR R11D,R11D
MOV qword ptr [RSP + 0x10],0x0
MOV R12,qword ptr [RAX]
JMP 0x001016ba
LAB_001016a0:
CMP dword ptr [RSP + 0xc],R15D
JZ 0x00101750
LAB_001016ab:
MOV R11D,EBX
XOR R15D,R15D
LAB_001016b1:
ADD R14,0x1
CMP R13D,EBX
JZ 0x0010171f
LAB_001016ba:
MOVSX RSI,byte ptr [R14]
MOV EAX,EBX
ADD EBX,0x1
MOV RDX,RSI
TEST byte ptr [R12 + RSI*0x2 + 0x1],0x20
JNZ 0x001016a0
TEST SIL,SIL
JZ 0x001016a0
SUB EAX,R11D
LEA RDI,[0x102004]
MOV dword ptr [RSP + 0x24],R11D
CDQE
MOV byte ptr [RSP + 0x18],DL
MOV byte ptr [RBP + RAX*0x1],SIL
MOVSX ESI,SIL
CALL 0x00101110
MOVZX EDX,byte ptr [RSP + 0x18]
MOV R11D,dword ptr [RSP + 0x24]
TEST RAX,RAX
JNZ 0x001016b1
MOVZX EAX,word ptr [R12 + RDX*0x2]
AND AX,0x400
CMP AX,0x1
SBB R15D,-0x1
ADD R14,0x1
CMP R13D,EBX
JNZ 0x001016ba
LAB_0010171f:
MOV RDI,RBP
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x28]
MOV EDI,dword ptr [RSP + 0x20]
MOV dword ptr [RAX],EDI
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101750:
SUB EAX,R11D
ADD dword ptr [RSP + 0x20],0x1
MOVSXD RCX,dword ptr [RSP + 0x20]
CDQE
MOV RDI,qword ptr [RSP + 0x10]
MOV byte ptr [RBP + RAX*0x1],0x0
SHL RCX,0x3
MOV RSI,RCX
MOV qword ptr [RSP + 0x18],RCX
CALL 0x00101160
MOV RDI,RBP
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
LEA R15,[RAX + 0x1]
MOV RDI,R15
CALL 0x00101150
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,R15
MOV RSI,RBP
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + RCX*0x1 + -0x8],RDI
MOV RCX,R15
CALL 0x00101140
JMP 0x001016ab
|
void * func0(byte *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
void *local_58;
int local_48;
iVar11 = 0;
sVar3 = strlen((char *)param_1);
__s = (char *)malloc(sVar3 + 1);
ppuVar4 = __ctype_b_loc();
local_48 = 0;
iVar10 = 0;
local_58 = (void *)0x0;
puVar2 = *ppuVar4;
iVar8 = 0;
do {
bVar1 = *param_1;
iVar9 = iVar8 + 1;
if (((*(byte *)((long)puVar2 + (long)(char)bVar1 * 2 + 1) & 0x20) == 0) && (bVar1 != 0)) {
__s[iVar8 - iVar10] = bVar1;
pcVar5 = strchr("aeiouAEIOU",(int)(char)bVar1);
if (pcVar5 == (char *)0x0) {
iVar11 = (iVar11 + 1) - (uint)((puVar2[bVar1] & 0x400) == 0);
}
}
else {
if (param_2 == iVar11) {
local_48 = local_48 + 1;
__s[iVar8 - iVar10] = '\0';
local_58 = realloc(local_58,(long)local_48 * 8);
sVar6 = strlen(__s);
sVar6 = sVar6 + 1;
pvVar7 = malloc(sVar6);
*(void **)((long)local_58 + ((long)local_48 * 8 - 8U)) = pvVar7;
__memcpy_chk(pvVar7,__s,sVar6,sVar6);
}
iVar11 = 0;
iVar10 = iVar9;
}
param_1 = param_1 + 1;
iVar8 = iVar9;
} while ((int)sVar3 + 1 != iVar9);
free(__s);
*param_3 = local_48;
return local_58;
}
|
1,127 |
func0
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
|
char **func0(const char *s, int n, int *returnSize) {
const char *vowels = "aeiouAEIOU";
char **out = NULL;
int numc = 0, word_count = 0, begin = 0;
size_t length = strlen(s);
char *current = (char *)malloc(length + 1);
for (int i = 0; i <= length; i++) {
if (isspace(s[i]) || s[i] == '\0') {
if (numc == n) {
current[i - begin] = '\0';
out = (char **)realloc(out, sizeof(char *) * (word_count + 1));
out[word_count] = (char *)malloc(strlen(current) + 1);
strcpy(out[word_count], current);
word_count++;
}
begin = i + 1;
numc = 0;
} else {
current[i - begin] = s[i];
if (strchr(vowels, s[i]) == NULL && isalpha((unsigned char)s[i])) {
numc++;
}
}
}
free(current);
*returnSize = word_count;
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int count) {
for (int i = 0; i < count; i++) {
free(words[i]);
}
free(words);
}
int main() {
int size;
char **words;
words = func0("Mary had a little lamb", 4, &size);
char *expected1[] = {"little"};
assert(issame(words, size, expected1, 1));
free_words(words, size);
words = func0("Mary had a little lamb", 3, &size);
char *expected2[] = {"Mary", "lamb"};
assert(issame(words, size, expected2, 2));
free_words(words, size);
words = func0("simple white space", 2, &size);
assert(size == 0);
free_words(words, size);
words = func0("Hello world", 4, &size);
char *expected3[] = {"world"};
assert(issame(words, size, expected3, 1));
free_words(words, size);
words = func0("Uncle sam", 3, &size);
char *expected4[] = {"Uncle"};
assert(issame(words, size, expected4, 1));
free_words(words, size);
words = func0("", 4, &size);
assert(size == 0);
free_words(words, size);
words = func0("a b c d e f", 1, &size);
char *expected5[] = {"b", "c", "d", "f"};
assert(issame(words, size, expected5, 4));
free_words(words, size);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
xor %r15d,%r15d
push %r14
xor %r14d,%r14d
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %esi,0xc(%rsp)
mov %rdx,0x28(%rsp)
callq 10f0 <strlen@plt>
lea 0x1(%rax),%rdi
mov %rax,%rbx
callq 1150 <malloc@plt>
add $0x1,%ebx
mov %rax,%rbp
callq 1170 <__ctype_b_loc@plt>
movl $0x0,0x20(%rsp)
xor %r10d,%r10d
xor %r9d,%r9d
mov (%rax),%r12
jmp 16c2 <func0+0x72>
nopl 0x0(%rax,%rax,1)
cmp %r9d,0xc(%rsp)
je 1760 <func0+0x110>
mov %r15d,%r10d
xor %r9d,%r9d
add $0x1,%r13
cmp %r15d,%ebx
je 1734 <func0+0xe4>
movsbq 0x0(%r13),%rsi
mov %r15d,%eax
add $0x1,%r15d
mov %rsi,%rdx
testb $0x20,0x1(%r12,%rsi,2)
jne 16a8 <func0+0x58>
test %sil,%sil
je 16a8 <func0+0x58>
sub %r10d,%eax
lea 0x91c(%rip),%rdi
mov %r9d,0x24(%rsp)
cltq
mov %r10d,0x18(%rsp)
mov %sil,0x0(%rbp,%rax,1)
movsbl %sil,%esi
mov %dl,0x10(%rsp)
callq 1110 <strchr@plt>
movzbl 0x10(%rsp),%edx
mov 0x18(%rsp),%r10d
test %rax,%rax
mov 0x24(%rsp),%r9d
jne 16b9 <func0+0x69>
movzwl (%r12,%rdx,2),%eax
and $0x400,%ax
cmp $0x1,%ax
sbb $0xffffffff,%r9d
add $0x1,%r13
cmp %r15d,%ebx
jne 16c2 <func0+0x72>
mov %rbp,%rdi
callq 10e0 <free@plt>
mov 0x28(%rsp),%rax
mov 0x20(%rsp),%ebx
mov %ebx,(%rax)
add $0x38,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopl 0x0(%rax)
sub %r10d,%eax
addl $0x1,0x20(%rsp)
mov %r14,%rdi
cltq
movb $0x0,0x0(%rbp,%rax,1)
movslq 0x20(%rsp),%rax
shl $0x3,%rax
mov %rax,%rsi
mov %rax,0x18(%rsp)
callq 1160 <realloc@plt>
mov %rbp,%rdx
mov %rax,%r14
mov (%rdx),%esi
add $0x4,%rdx
lea -0x1010101(%rsi),%eax
not %esi
and %esi,%eax
and $0x80808080,%eax
je 178e <func0+0x13e>
mov %eax,%esi
shr $0x10,%esi
test $0x8080,%eax
cmove %esi,%eax
lea 0x2(%rdx),%rsi
cmove %rsi,%rdx
mov %eax,%ecx
add %al,%cl
sbb $0x3,%rdx
sub %rbp,%rdx
add $0x1,%rdx
mov %rdx,%rdi
mov %rdx,0x10(%rsp)
callq 1150 <malloc@plt>
mov 0x10(%rsp),%rdx
mov %rbp,%rsi
mov %rax,%rdi
mov 0x18(%rsp),%rax
mov %rdi,-0x8(%r14,%rax,1)
callq 1140 <memcpy@plt>
jmpq 16b3 <func0+0x63>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
xor r15d, r15d
push r14
mov r14, rdi
push r13
push r12
push rbp
push rbx
sub rsp, 38h
mov [rsp+68h+var_5C], esi
mov [rsp+68h+var_40], rdx
call _strlen
lea rdi, [rax+1]; size
mov rbx, rax
call _malloc
lea r13d, [rbx+1]
xor ebx, ebx
mov rbp, rax
call ___ctype_b_loc
mov [rsp+68h+var_48], 0
xor r11d, r11d
mov [rsp+68h+ptr], 0
mov r12, [rax]
jmp short loc_16BA
loc_16A0:
cmp [rsp+68h+var_5C], r15d
jz loc_1750
loc_16AB:
mov r11d, ebx
xor r15d, r15d
loc_16B1:
add r14, 1
cmp r13d, ebx
jz short loc_171F
loc_16BA:
movsx rsi, byte ptr [r14]
mov eax, ebx
add ebx, 1
mov rdx, rsi
test byte ptr [r12+rsi*2+1], 20h
jnz short loc_16A0
test sil, sil
jz short loc_16A0
sub eax, r11d
lea rdi, s; "aeiouAEIOU"
mov [rsp+68h+var_44], r11d
cdqe
mov byte ptr [rsp+68h+var_50], dl
mov [rbp+rax+0], sil
movsx esi, sil; c
call _strchr
movzx edx, byte ptr [rsp+68h+var_50]
mov r11d, [rsp+68h+var_44]
test rax, rax
jnz short loc_16B1
movzx eax, word ptr [r12+rdx*2]
and ax, 400h
cmp ax, 1
sbb r15d, 0FFFFFFFFh
add r14, 1
cmp r13d, ebx
jnz short loc_16BA
loc_171F:
mov rdi, rbp; ptr
call _free
mov rax, [rsp+68h+var_40]
mov edi, [rsp+68h+var_48]
mov [rax], edi
mov rax, [rsp+68h+ptr]
add rsp, 38h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1750:
sub eax, r11d
add [rsp+68h+var_48], 1
movsxd rcx, [rsp+68h+var_48]
cdqe
mov rdi, [rsp+68h+ptr]; ptr
mov byte ptr [rbp+rax+0], 0
shl rcx, 3
mov rsi, rcx; size
mov [rsp+68h+var_50], rcx
call _realloc
mov rdi, rbp; s
mov [rsp+68h+ptr], rax
call _strlen
lea r15, [rax+1]
mov rdi, r15; size
call _malloc
mov rcx, [rsp+68h+var_50]
mov rdx, r15
mov rsi, rbp
mov rdi, rax
mov rax, [rsp+68h+ptr]
mov [rax+rcx-8], rdi
mov rcx, r15
call ___memcpy_chk
jmp loc_16AB
|
char * func0(const char *a1, int a2, _DWORD *a3)
{
int v3; // r15d
const char *v4; // r14
size_t v5; // rax
int v6; // r13d
int v7; // ebx
char *v8; // rbp
const unsigned __int16 **v9; // rax
int v10; // r11d
const unsigned __int16 *v11; // r12
long long v12; // rsi
int v13; // eax
char *v14; // rax
size_t v16; // r15
void *v17; // rax
char *ptr; // [rsp+10h] [rbp-58h]
size_t v20; // [rsp+18h] [rbp-50h]
int v21; // [rsp+20h] [rbp-48h]
int v22; // [rsp+24h] [rbp-44h]
v3 = 0;
v4 = a1;
v5 = strlen(a1);
v6 = v5 + 1;
v7 = 0;
v8 = (char *)malloc(v5 + 1);
v9 = __ctype_b_loc();
v21 = 0;
v10 = 0;
ptr = 0LL;
v11 = *v9;
do
{
while ( 1 )
{
v12 = *v4;
v13 = v7++;
if ( (v11[v12] & 0x2000) != 0 || !(_BYTE)v12 )
{
if ( a2 == v3 )
{
++v21;
v8[v13 - v10] = 0;
v20 = 8LL * v21;
ptr = (char *)realloc(ptr, v20);
v16 = strlen(v8) + 1;
v17 = malloc(v16);
*(_QWORD *)&ptr[v20 - 8] = v17;
__memcpy_chk(v17, v8, v16, v16);
}
v10 = v7;
v3 = 0;
goto LABEL_5;
}
v22 = v10;
v8[v13 - v10] = v12;
v14 = strchr("aeiouAEIOU", (char)v12);
v10 = v22;
if ( !v14 )
break;
LABEL_5:
++v4;
if ( v6 == v7 )
goto LABEL_10;
}
v3 -= ((v11[(unsigned __int8)v12] & 0x400) == 0) - 1;
++v4;
}
while ( v6 != v7 );
LABEL_10:
free(v8);
*a3 = v21;
return ptr;
}
|
func0:
ENDBR64
PUSH R15
XOR R15D,R15D
PUSH R14
MOV R14,RDI
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV dword ptr [RSP + 0xc],ESI
MOV qword ptr [RSP + 0x28],RDX
CALL 0x001010f0
LEA RDI,[RAX + 0x1]
MOV RBX,RAX
CALL 0x00101150
LEA R13D,[RBX + 0x1]
XOR EBX,EBX
MOV RBP,RAX
CALL 0x00101170
MOV dword ptr [RSP + 0x20],0x0
XOR R11D,R11D
MOV qword ptr [RSP + 0x10],0x0
MOV R12,qword ptr [RAX]
JMP 0x001016ba
LAB_001016a0:
CMP dword ptr [RSP + 0xc],R15D
JZ 0x00101750
LAB_001016ab:
MOV R11D,EBX
XOR R15D,R15D
LAB_001016b1:
ADD R14,0x1
CMP R13D,EBX
JZ 0x0010171f
LAB_001016ba:
MOVSX RSI,byte ptr [R14]
MOV EAX,EBX
ADD EBX,0x1
MOV RDX,RSI
TEST byte ptr [R12 + RSI*0x2 + 0x1],0x20
JNZ 0x001016a0
TEST SIL,SIL
JZ 0x001016a0
SUB EAX,R11D
LEA RDI,[0x102004]
MOV dword ptr [RSP + 0x24],R11D
CDQE
MOV byte ptr [RSP + 0x18],DL
MOV byte ptr [RBP + RAX*0x1],SIL
MOVSX ESI,SIL
CALL 0x00101110
MOVZX EDX,byte ptr [RSP + 0x18]
MOV R11D,dword ptr [RSP + 0x24]
TEST RAX,RAX
JNZ 0x001016b1
MOVZX EAX,word ptr [R12 + RDX*0x2]
AND AX,0x400
CMP AX,0x1
SBB R15D,-0x1
ADD R14,0x1
CMP R13D,EBX
JNZ 0x001016ba
LAB_0010171f:
MOV RDI,RBP
CALL 0x001010e0
MOV RAX,qword ptr [RSP + 0x28]
MOV EDI,dword ptr [RSP + 0x20]
MOV dword ptr [RAX],EDI
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x38
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101750:
SUB EAX,R11D
ADD dword ptr [RSP + 0x20],0x1
MOVSXD RCX,dword ptr [RSP + 0x20]
CDQE
MOV RDI,qword ptr [RSP + 0x10]
MOV byte ptr [RBP + RAX*0x1],0x0
SHL RCX,0x3
MOV RSI,RCX
MOV qword ptr [RSP + 0x18],RCX
CALL 0x00101160
MOV RDI,RBP
MOV qword ptr [RSP + 0x10],RAX
CALL 0x001010f0
LEA R15,[RAX + 0x1]
MOV RDI,R15
CALL 0x00101150
MOV RCX,qword ptr [RSP + 0x18]
MOV RDX,R15
MOV RSI,RBP
MOV RDI,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + RCX*0x1 + -0x8],RDI
MOV RCX,R15
CALL 0x00101140
JMP 0x001016ab
|
void * func0(byte *param_1,int param_2,int *param_3)
{
byte bVar1;
ushort *puVar2;
size_t sVar3;
char *__s;
ushort **ppuVar4;
char *pcVar5;
size_t sVar6;
void *pvVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
void *local_58;
int local_48;
iVar11 = 0;
sVar3 = strlen((char *)param_1);
__s = (char *)malloc(sVar3 + 1);
ppuVar4 = __ctype_b_loc();
local_48 = 0;
iVar10 = 0;
local_58 = (void *)0x0;
puVar2 = *ppuVar4;
iVar8 = 0;
do {
bVar1 = *param_1;
iVar9 = iVar8 + 1;
if (((*(byte *)((long)puVar2 + (long)(char)bVar1 * 2 + 1) & 0x20) == 0) && (bVar1 != 0)) {
__s[iVar8 - iVar10] = bVar1;
pcVar5 = strchr("aeiouAEIOU",(int)(char)bVar1);
if (pcVar5 == (char *)0x0) {
iVar11 = (iVar11 + 1) - (uint)((puVar2[bVar1] & 0x400) == 0);
}
}
else {
if (param_2 == iVar11) {
local_48 = local_48 + 1;
__s[iVar8 - iVar10] = '\0';
local_58 = realloc(local_58,(long)local_48 * 8);
sVar6 = strlen(__s);
sVar6 = sVar6 + 1;
pvVar7 = malloc(sVar6);
*(void **)((long)local_58 + ((long)local_48 * 8 - 8U)) = pvVar7;
__memcpy_chk(pvVar7,__s,sVar6,sVar6);
}
iVar11 = 0;
iVar10 = iVar9;
}
param_1 = param_1 + 1;
iVar8 = iVar9;
} while ((int)sVar3 + 1 != iVar9);
free(__s);
*param_3 = local_48;
return local_58;
}
|
1,128 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
return out;
}
}
out[0] = '\0';
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0("bad"), "a") == 0);
assert(strcmp(func0("most"), "o") == 0);
assert(strcmp(func0("ab"), "") == 0);
assert(strcmp(func0("ba"), "") == 0);
assert(strcmp(func0("quick"), "") == 0);
assert(strcmp(func0("anime"), "i") == 0);
assert(strcmp(func0("Asia"), "") == 0);
assert(strcmp(func0("Above"), "o") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
lea 0xe48(%rip),%rax
mov %rax,-0x10(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
sub $0x2,%eax
mov %eax,-0x14(%rbp)
jmpq 127e <func0+0xd5>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x10(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
je 127a <func0+0xd1>
mov -0x14(%rbp),%eax
cltq
lea 0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x10(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
jne 127a <func0+0xd1>
mov -0x14(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%edx
mov -0x10(%rbp),%rax
mov %edx,%esi
mov %rax,%rdi
callq 1090 <strchr@plt>
test %rax,%rax
jne 127a <func0+0xd1>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,0x2da0(%rip)
lea 0x2d99(%rip),%rax
jmp 1296 <func0+0xed>
subl $0x1,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 11e3 <func0+0x3a>
movb $0x0,0x2d82(%rip)
lea 0x2d7b(%rip),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
lea rax, aAeiouaeiou; "AEIOUaeiou"
mov [rbp+var_10], rax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
sub eax, 2
mov [rbp+var_14], eax
jmp loc_127E
loc_11E3:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+var_10]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jz short loc_127A
mov eax, [rbp+var_14]
cdqe
lea rdx, [rax+1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+var_10]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_127A
mov eax, [rbp+var_14]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx edx, al
mov rax, [rbp+var_10]
mov esi, edx; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_127A
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov cs:out_1, al
lea rax, out_1
jmp short locret_1296
loc_127A:
sub [rbp+var_14], 1
loc_127E:
cmp [rbp+var_14], 0
jg loc_11E3
mov cs:out_1, 0
lea rax, out_1
locret_1296:
leave
retn
|
char * func0(const char *a1)
{
int i; // [rsp+1Ch] [rbp-14h]
for ( i = strlen(a1) - 2; i > 0; --i )
{
if ( strchr("AEIOUaeiou", a1[i]) && !strchr("AEIOUaeiou", a1[i + 1]) && !strchr("AEIOUaeiou", a1[i - 1]) )
{
out_1 = a1[i];
return &out_1;
}
}
out_1 = 0;
return &out_1;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
LEA RAX,[0x102008]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101080
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
SUB EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010127e
LAB_001011e3:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101090
TEST RAX,RAX
JZ 0x0010127a
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX + 0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101090
TEST RAX,RAX
JNZ 0x0010127a
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EDX,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV ESI,EDX
MOV RDI,RAX
CALL 0x00101090
TEST RAX,RAX
JNZ 0x0010127a
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [0x00104011],AL
LEA RAX,[0x104011]
JMP 0x00101296
LAB_0010127a:
SUB dword ptr [RBP + -0x14],0x1
LAB_0010127e:
CMP dword ptr [RBP + -0x14],0x0
JG 0x001011e3
MOV byte ptr [0x00104011],0x0
LEA RAX,[0x104011]
LAB_00101296:
LEAVE
RET
|
int2 * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int local_1c;
sVar1 = strlen(param_1);
local_1c = (int)sVar1 + -2;
while( true ) {
if (local_1c < 1) {
out_1._0_1_ = 0;
return &out_1;
}
pcVar2 = strchr("AEIOUaeiou",(int)param_1[local_1c]);
if (((pcVar2 != (char *)0x0) &&
(pcVar2 = strchr("AEIOUaeiou",(int)param_1[(long)local_1c + 1]), pcVar2 == (char *)0x0)) &&
(pcVar2 = strchr("AEIOUaeiou",(int)param_1[(long)local_1c + -1]), pcVar2 == (char *)0x0))
break;
local_1c = local_1c + -1;
}
out_1._0_1_ = param_1[local_1c];
return &out_1;
}
|
1,129 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
return out;
}
}
out[0] = '\0';
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0("bad"), "a") == 0);
assert(strcmp(func0("most"), "o") == 0);
assert(strcmp(func0("ab"), "") == 0);
assert(strcmp(func0("ba"), "") == 0);
assert(strcmp(func0("quick"), "") == 0);
assert(strcmp(func0("anime"), "i") == 0);
assert(strcmp(func0("Asia"), "") == 0);
assert(strcmp(func0("Above"), "o") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%rdx
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x3(%rcx),%eax
test %eax,%eax
jle 1211 <func0+0xa8>
push %r14
push %r13
push %r12
push %rbp
push %rbx
lea -0x1(%rcx),%rsi
cltq
lea (%rdx,%rax,1),%rbx
lea -0x1(%rdx,%rax,1),%r14
lea -0x3(%rsi),%eax
sub %rax,%r14
lea 0xe54(%rip),%r12
jmp 11bb <func0+0x52>
sub $0x1,%rbx
cmp %r14,%rbx
je 11fa <func0+0x91>
movzbl (%rbx),%ebp
movsbl %bpl,%esi
mov %r12,%rdi
callq 1060 <strchr@plt>
test %rax,%rax
je 11b2 <func0+0x49>
movsbl 0x1(%rbx),%esi
mov %r12,%rdi
callq 1060 <strchr@plt>
test %rax,%rax
jne 11b2 <func0+0x49>
movsbl -0x1(%rbx),%esi
mov %r12,%rdi
callq 1060 <strchr@plt>
test %rax,%rax
jne 11b2 <func0+0x49>
mov %bpl,0x2e19(%rip)
jmp 1201 <func0+0x98>
movb $0x0,0x2e10(%rip)
lea 0x2e09(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
retq
movb $0x0,0x2df9(%rip)
lea 0x2df2(%rip),%rax
retq
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbp, rdi
call _strlen
lea edx, [rax-2]
test edx, edx
jle short loc_123D
movsxd rdx, edx
lea rbx, [rbp+rdx+0]
lea r14, [rbp+rdx-1]
lea eax, [rax-3]
sub r14, rax
lea r12, s; "AEIOUaeiou"
jmp short loc_11E9
loc_11E0:
sub rbx, 1
cmp rbx, r14
jz short loc_1221
loc_11E9:
movzx ebp, byte ptr [rbx]
movsx esi, bpl; c
mov rdi, r12; s
call _strchr
test rax, rax
jz short loc_11E0
movsx esi, byte ptr [rbx+1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_11E0
movsx esi, byte ptr [rbx-1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_11E0
jmp short loc_1226
loc_1221:
mov ebp, 0
loc_1226:
mov cs:out_1, bpl
lea rax, out_1
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_123D:
mov ebp, 0
jmp short loc_1226
|
char * func0(const char *a1)
{
int v1; // eax
char *v2; // rbx
long long v3; // r14
char v4; // bp
v1 = strlen(a1);
if ( v1 - 2 <= 0 )
{
v4 = 0;
}
else
{
v2 = (char *)&a1[v1 - 2];
v3 = (long long)&v2[-(v1 - 3) - 1];
while ( 1 )
{
v4 = *v2;
if ( strchr("AEIOUaeiou", *v2) )
{
if ( !strchr("AEIOUaeiou", v2[1]) && !strchr("AEIOUaeiou", *(v2 - 1)) )
break;
}
if ( --v2 == (char *)v3 )
{
v4 = 0;
break;
}
}
}
out_1 = v4;
return &out_1;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
CALL 0x00101080
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x0010123d
MOVSXD RDX,EDX
LEA RBX,[RBP + RDX*0x1]
LEA R14,[RBP + RDX*0x1 + -0x1]
LEA EAX,[RAX + -0x3]
SUB R14,RAX
LEA R12,[0x102004]
JMP 0x001011e9
LAB_001011e0:
SUB RBX,0x1
CMP RBX,R14
JZ 0x00101221
LAB_001011e9:
MOVZX EBP,byte ptr [RBX]
MOVSX ESI,BPL
MOV RDI,R12
CALL 0x00101090
TEST RAX,RAX
JZ 0x001011e0
MOVSX ESI,byte ptr [RBX + 0x1]
MOV RDI,R12
CALL 0x00101090
TEST RAX,RAX
JNZ 0x001011e0
MOVSX ESI,byte ptr [RBX + -0x1]
MOV RDI,R12
CALL 0x00101090
TEST RAX,RAX
JNZ 0x001011e0
JMP 0x00101226
LAB_00101221:
MOV EBP,0x0
LAB_00101226:
MOV byte ptr [0x00104011],BPL
LEA RAX,[0x104011]
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_0010123d:
MOV EBP,0x0
JMP 0x00101226
|
int2 * func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
char *pcVar4;
char cVar5;
sVar1 = strlen(param_1);
iVar3 = (int)sVar1 + -2;
if (iVar3 < 1) {
cVar5 = '\0';
}
else {
pcVar4 = param_1 + iVar3;
do {
cVar5 = *pcVar4;
pcVar2 = strchr("AEIOUaeiou",(int)cVar5);
if (((pcVar2 != (char *)0x0) &&
(pcVar2 = strchr("AEIOUaeiou",(int)pcVar4[1]), pcVar2 == (char *)0x0)) &&
(pcVar2 = strchr("AEIOUaeiou",(int)pcVar4[-1]), pcVar2 == (char *)0x0)) goto LAB_00101226;
pcVar4 = pcVar4 + -1;
} while (pcVar4 != param_1 + (((long)iVar3 + -1) - (ulong)((int)sVar1 - 3)));
cVar5 = '\0';
}
LAB_00101226:
out_1._0_1_ = cVar5;
return &out_1;
}
|
1,130 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
return out;
}
}
out[0] = '\0';
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0("bad"), "a") == 0);
assert(strcmp(func0("most"), "o") == 0);
assert(strcmp(func0("ab"), "") == 0);
assert(strcmp(func0("ba"), "") == 0);
assert(strcmp(func0("quick"), "") == 0);
assert(strcmp(func0("anime"), "i") == 0);
assert(strcmp(func0("Asia"), "") == 0);
assert(strcmp(func0("Above"), "o") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x2(%rax),%edx
test %edx,%edx
jle 14f0 <func0+0x90>
movslq %edx,%rdx
sub $0x3,%eax
lea 0xb7a(%rip),%r12
lea -0x1(%rbp,%rdx,1),%r13
lea 0x0(%rbp,%rdx,1),%rbx
sub %rax,%r13
jmp 14a9 <func0+0x49>
nopl 0x0(%rax)
sub $0x1,%rbx
cmp %rbx,%r13
je 14f0 <func0+0x90>
movsbl (%rbx),%esi
mov %r12,%rdi
mov %esi,%ebp
callq 1080 <strchr@plt>
test %rax,%rax
je 14a0 <func0+0x40>
movsbl 0x1(%rbx),%esi
mov %r12,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 14a0 <func0+0x40>
movsbl -0x1(%rbx),%esi
mov %r12,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 14a0 <func0+0x40>
mov %bpl,0x2b2d(%rip)
jmp 14f7 <func0+0x97>
nopw %cs:0x0(%rax,%rax,1)
movb $0x0,0x2b1a(%rip)
add $0x8,%rsp
lea 0x2b0f(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-2]
test edx, edx
jle loc_1500
lea r13, [rbp+rdx-1]
sub eax, 3
lea rbx, [rbp+rdx+0]
sub r13, rax
lea r12, s; "AEIOUaeiou"
jmp short loc_14A9
loc_14A0:
sub rbx, 1
cmp rbx, r13
jz short loc_1500
loc_14A9:
movsx esi, byte ptr [rbx]; c
mov rdi, r12; s
mov ebp, esi
call _strchr
test rax, rax
jz short loc_14A0
movsx esi, byte ptr [rbx+1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_14A0
movsx esi, byte ptr [rbx-1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_14A0
loc_14DD:
mov cs:out_1, bpl
add rsp, 8
lea rax, out_1
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1500:
xor ebp, ebp
jmp short loc_14DD
|
char * func0(const char *a1)
{
int v1; // eax
long long v2; // rdx
char *v3; // rbx
long long v4; // r13
char v5; // bp
v1 = strlen(a1);
v2 = (unsigned int)(v1 - 2);
if ( v1 - 2 <= 0 )
{
LABEL_8:
v5 = 0;
}
else
{
v3 = (char *)&a1[v2];
v4 = (long long)&a1[v2 - 1 - (unsigned int)(v1 - 3)];
while ( 1 )
{
v5 = *v3;
if ( strchr("AEIOUaeiou", *v3) )
{
if ( !strchr("AEIOUaeiou", v3[1]) && !strchr("AEIOUaeiou", *(v3 - 1)) )
break;
}
if ( --v3 == (char *)v4 )
goto LABEL_8;
}
}
out_1 = v5;
return &out_1;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x00101500
LEA R13,[RBP + RDX*0x1 + -0x1]
SUB EAX,0x3
LEA RBX,[RBP + RDX*0x1]
SUB R13,RAX
LEA R12,[0x102004]
JMP 0x001014a9
LAB_001014a0:
SUB RBX,0x1
CMP RBX,R13
JZ 0x00101500
LAB_001014a9:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R12
MOV EBP,ESI
CALL 0x00101080
TEST RAX,RAX
JZ 0x001014a0
MOVSX ESI,byte ptr [RBX + 0x1]
MOV RDI,R12
CALL 0x00101080
TEST RAX,RAX
JNZ 0x001014a0
MOVSX ESI,byte ptr [RBX + -0x1]
MOV RDI,R12
CALL 0x00101080
TEST RAX,RAX
JNZ 0x001014a0
LAB_001014dd:
MOV byte ptr [0x00104011],BPL
ADD RSP,0x8
LEA RAX,[0x104011]
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101500:
XOR EBP,EBP
JMP 0x001014dd
|
int2 * func0(char *param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
uint uVar4;
char *pcVar5;
sVar2 = strlen(param_1);
uVar4 = (int)sVar2 - 2;
if (0 < (int)uVar4) {
pcVar5 = param_1 + uVar4;
do {
cVar1 = *pcVar5;
pcVar3 = strchr("AEIOUaeiou",(int)cVar1);
if (((pcVar3 != (char *)0x0) &&
(pcVar3 = strchr("AEIOUaeiou",(int)pcVar5[1]), pcVar3 == (char *)0x0)) &&
(pcVar3 = strchr("AEIOUaeiou",(int)pcVar5[-1]), pcVar3 == (char *)0x0)) {
out_1._0_1_ = cVar1;
return &out_1;
}
pcVar5 = pcVar5 + -1;
} while (pcVar5 != param_1 + (((ulong)uVar4 - 1) - (ulong)((int)sVar2 - 3)));
}
out_1._0_1_ = 0;
return &out_1;
}
|
1,131 |
func0
|
#include <stdio.h>
#include <string.h>
|
char *func0(const char *word) {
static char out[2] = {0};
const char *vowels = "AEIOUaeiou";
size_t len = strlen(word);
for (int i = len - 2; i >= 1; i--) {
if (strchr(vowels, word[i]) && !strchr(vowels, word[i + 1]) && !strchr(vowels, word[i - 1])) {
out[0] = word[i];
return out;
}
}
out[0] = '\0';
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0("yogurt"), "u") == 0);
assert(strcmp(func0("full"), "u") == 0);
assert(strcmp(func0("easy"), "") == 0);
assert(strcmp(func0("eAsy"), "") == 0);
assert(strcmp(func0("ali"), "") == 0);
assert(strcmp(func0("bad"), "a") == 0);
assert(strcmp(func0("most"), "o") == 0);
assert(strcmp(func0("ab"), "") == 0);
assert(strcmp(func0("ba"), "") == 0);
assert(strcmp(func0("quick"), "") == 0);
assert(strcmp(func0("anime"), "i") == 0);
assert(strcmp(func0("Asia"), "") == 0);
assert(strcmp(func0("Above"), "o") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x8,%rsp
callq 1070 <strlen@plt>
lea -0x2(%rax),%edx
test %edx,%edx
jle 14f0 <func0+0x90>
movslq %edx,%rdx
sub $0x3,%eax
lea 0xb7a(%rip),%r12
lea -0x1(%rbp,%rdx,1),%r13
lea 0x0(%rbp,%rdx,1),%rbx
sub %rax,%r13
jmp 14a9 <func0+0x49>
nopl 0x0(%rax)
sub $0x1,%rbx
cmp %rbx,%r13
je 14f0 <func0+0x90>
movsbl (%rbx),%esi
mov %r12,%rdi
mov %esi,%ebp
callq 1080 <strchr@plt>
test %rax,%rax
je 14a0 <func0+0x40>
movsbl 0x1(%rbx),%esi
mov %r12,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 14a0 <func0+0x40>
movsbl -0x1(%rbx),%esi
mov %r12,%rdi
callq 1080 <strchr@plt>
test %rax,%rax
jne 14a0 <func0+0x40>
mov %bpl,0x2b2d(%rip)
jmp 14f7 <func0+0x97>
nopw %cs:0x0(%rax,%rax,1)
movb $0x0,0x2b1a(%rip)
add $0x8,%rsp
lea 0x2b0f(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
call _strlen
lea edx, [rax-2]
test edx, edx
jle loc_1500
lea r13, [rbp+rdx-1]
sub eax, 3
lea rbx, [rbp+rdx+0]
sub r13, rax
lea r12, s; "AEIOUaeiou"
jmp short loc_14A9
loc_14A0:
sub rbx, 1
cmp rbx, r13
jz short loc_1500
loc_14A9:
movsx esi, byte ptr [rbx]; c
mov rdi, r12; s
mov ebp, esi
call _strchr
test rax, rax
jz short loc_14A0
movsx esi, byte ptr [rbx+1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_14A0
movsx esi, byte ptr [rbx-1]; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_14A0
loc_14DD:
mov cs:out_1, bpl
add rsp, 8
lea rax, out_1
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1500:
xor ebp, ebp
jmp short loc_14DD
|
char * func0(const char *a1)
{
int v1; // eax
long long v2; // rdx
char *v3; // rbx
long long v4; // r13
char v5; // bp
v1 = strlen(a1);
v2 = (unsigned int)(v1 - 2);
if ( v1 - 2 <= 0 )
{
LABEL_8:
v5 = 0;
}
else
{
v3 = (char *)&a1[v2];
v4 = (long long)&a1[v2 - 1 - (unsigned int)(v1 - 3)];
while ( 1 )
{
v5 = *v3;
if ( strchr("AEIOUaeiou", *v3) )
{
if ( !strchr("AEIOUaeiou", v3[1]) && !strchr("AEIOUaeiou", *(v3 - 1)) )
break;
}
if ( --v3 == (char *)v4 )
goto LABEL_8;
}
}
out_1 = v5;
return &out_1;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
CALL 0x00101070
LEA EDX,[RAX + -0x2]
TEST EDX,EDX
JLE 0x00101500
LEA R13,[RBP + RDX*0x1 + -0x1]
SUB EAX,0x3
LEA RBX,[RBP + RDX*0x1]
SUB R13,RAX
LEA R12,[0x102004]
JMP 0x001014a9
LAB_001014a0:
SUB RBX,0x1
CMP RBX,R13
JZ 0x00101500
LAB_001014a9:
MOVSX ESI,byte ptr [RBX]
MOV RDI,R12
MOV EBP,ESI
CALL 0x00101080
TEST RAX,RAX
JZ 0x001014a0
MOVSX ESI,byte ptr [RBX + 0x1]
MOV RDI,R12
CALL 0x00101080
TEST RAX,RAX
JNZ 0x001014a0
MOVSX ESI,byte ptr [RBX + -0x1]
MOV RDI,R12
CALL 0x00101080
TEST RAX,RAX
JNZ 0x001014a0
LAB_001014dd:
MOV byte ptr [0x00104011],BPL
ADD RSP,0x8
LEA RAX,[0x104011]
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101500:
XOR EBP,EBP
JMP 0x001014dd
|
int2 * func0(char *param_1)
{
char cVar1;
size_t sVar2;
char *pcVar3;
uint uVar4;
char *pcVar5;
sVar2 = strlen(param_1);
uVar4 = (int)sVar2 - 2;
if (0 < (int)uVar4) {
pcVar5 = param_1 + uVar4;
do {
cVar1 = *pcVar5;
pcVar3 = strchr("AEIOUaeiou",(int)cVar1);
if (((pcVar3 != (char *)0x0) &&
(pcVar3 = strchr("AEIOUaeiou",(int)pcVar5[1]), pcVar3 == (char *)0x0)) &&
(pcVar3 = strchr("AEIOUaeiou",(int)pcVar5[-1]), pcVar3 == (char *)0x0)) {
out_1._0_1_ = cVar1;
return &out_1;
}
pcVar5 = pcVar5 + -1;
} while (pcVar5 != param_1 + (((ulong)uVar4 - 1) - (ulong)((int)sVar2 - 3)));
}
out_1._0_1_ = 0;
return &out_1;
}
|
1,132 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
count = 0;
can = 1;
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
return "No";
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes") == 0);
assert(strcmp(func0("()", "())"), "No") == 0);
assert(strcmp(func0("(()(", "()))()"), "Yes") == 0);
assert(strcmp(func0("((((", "((())"), "No") == 0);
assert(strcmp(func0(")(()", "(()("), "No") == 0);
assert(strcmp(func0(")(", ")("), "No") == 0);
assert(strcmp(func0("(", ")"), "Yes") == 0);
assert(strcmp(func0(")", "("), "Yes") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
movl $0x0,-0x14(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x8(%rbp)
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x0,-0x10(%rbp)
jmp 1213 <func0+0x8a>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x28,%al
jne 11ea <func0+0x61>
addl $0x1,-0x14(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x29,%al
jne 1202 <func0+0x79>
subl $0x1,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 120f <func0+0x86>
movl $0x0,-0xc(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 11d2 <func0+0x49>
movl $0x0,-0x10(%rbp)
jmp 1265 <func0+0xdc>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x28,%al
jne 123c <func0+0xb3>
addl $0x1,-0x14(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x29,%al
jne 1254 <func0+0xcb>
subl $0x1,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 1261 <func0+0xd8>
movl $0x0,-0xc(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 1224 <func0+0x9b>
cmpl $0x0,-0x14(%rbp)
jne 1285 <func0+0xfc>
cmpl $0x0,-0xc(%rbp)
je 1285 <func0+0xfc>
lea 0xd88(%rip),%rax
jmpq 1353 <func0+0x1ca>
movl $0x0,-0x14(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x0,-0x10(%rbp)
jmp 12dd <func0+0x154>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x28,%al
jne 12b4 <func0+0x12b>
addl $0x1,-0x14(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x30(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x29,%al
jne 12cc <func0+0x143>
subl $0x1,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 12d9 <func0+0x150>
movl $0x0,-0xc(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x4(%rbp),%eax
jl 129c <func0+0x113>
movl $0x0,-0x10(%rbp)
jmp 132f <func0+0x1a6>
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x28,%al
jne 1306 <func0+0x17d>
addl $0x1,-0x14(%rbp)
mov -0x10(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x29,%al
jne 131e <func0+0x195>
subl $0x1,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jns 132b <func0+0x1a2>
movl $0x0,-0xc(%rbp)
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
cmp -0x8(%rbp),%eax
jl 12ee <func0+0x165>
cmpl $0x0,-0x14(%rbp)
jne 134c <func0+0x1c3>
cmpl $0x0,-0xc(%rbp)
je 134c <func0+0x1c3>
lea 0xcbe(%rip),%rax
jmp 1353 <func0+0x1ca>
lea 0xcb9(%rip),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+s], rdi
mov [rbp+var_30], rsi
mov [rbp+var_14], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8], eax
mov rax, [rbp+var_30]
mov rdi, rax; s
call _strlen
mov [rbp+var_4], eax
mov [rbp+var_C], 1
mov [rbp+var_10], 0
jmp short loc_1213
loc_11D2:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 28h ; '('
jnz short loc_11EA
add [rbp+var_14], 1
loc_11EA:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 29h ; ')'
jnz short loc_1202
sub [rbp+var_14], 1
loc_1202:
cmp [rbp+var_14], 0
jns short loc_120F
mov [rbp+var_C], 0
loc_120F:
add [rbp+var_10], 1
loc_1213:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_8]
jl short loc_11D2
mov [rbp+var_10], 0
jmp short loc_1265
loc_1224:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 28h ; '('
jnz short loc_123C
add [rbp+var_14], 1
loc_123C:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 29h ; ')'
jnz short loc_1254
sub [rbp+var_14], 1
loc_1254:
cmp [rbp+var_14], 0
jns short loc_1261
mov [rbp+var_C], 0
loc_1261:
add [rbp+var_10], 1
loc_1265:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_4]
jl short loc_1224
cmp [rbp+var_14], 0
jnz short loc_1285
cmp [rbp+var_C], 0
jz short loc_1285
lea rax, s2; "Yes"
jmp locret_1353
loc_1285:
mov [rbp+var_14], 0
mov [rbp+var_C], 1
mov [rbp+var_10], 0
jmp short loc_12DD
loc_129C:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 28h ; '('
jnz short loc_12B4
add [rbp+var_14], 1
loc_12B4:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+var_30]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 29h ; ')'
jnz short loc_12CC
sub [rbp+var_14], 1
loc_12CC:
cmp [rbp+var_14], 0
jns short loc_12D9
mov [rbp+var_C], 0
loc_12D9:
add [rbp+var_10], 1
loc_12DD:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_4]
jl short loc_129C
mov [rbp+var_10], 0
jmp short loc_132F
loc_12EE:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 28h ; '('
jnz short loc_1306
add [rbp+var_14], 1
loc_1306:
mov eax, [rbp+var_10]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 29h ; ')'
jnz short loc_131E
sub [rbp+var_14], 1
loc_131E:
cmp [rbp+var_14], 0
jns short loc_132B
mov [rbp+var_C], 0
loc_132B:
add [rbp+var_10], 1
loc_132F:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_8]
jl short loc_12EE
cmp [rbp+var_14], 0
jnz short loc_134C
cmp [rbp+var_C], 0
jz short loc_134C
lea rax, s2; "Yes"
jmp short locret_1353
loc_134C:
lea rax, aNo; "No"
locret_1353:
leave
retn
|
const char * func0(const char *a1, const char *a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
int v4; // [rsp+1Ch] [rbp-14h]
int i; // [rsp+20h] [rbp-10h]
int j; // [rsp+20h] [rbp-10h]
int k; // [rsp+20h] [rbp-10h]
int m; // [rsp+20h] [rbp-10h]
int v9; // [rsp+24h] [rbp-Ch]
int v10; // [rsp+24h] [rbp-Ch]
int v11; // [rsp+28h] [rbp-8h]
int v12; // [rsp+2Ch] [rbp-4h]
v3 = 0;
v11 = strlen(a1);
v12 = strlen(a2);
v9 = 1;
for ( i = 0; i < v11; ++i )
{
if ( a1[i] == 40 )
++v3;
if ( a1[i] == 41 )
--v3;
if ( v3 < 0 )
v9 = 0;
}
for ( j = 0; j < v12; ++j )
{
if ( a2[j] == 40 )
++v3;
if ( a2[j] == 41 )
--v3;
if ( v3 < 0 )
v9 = 0;
}
if ( !v3 && v9 )
return "Yes";
v4 = 0;
v10 = 1;
for ( k = 0; k < v12; ++k )
{
if ( a2[k] == 40 )
++v4;
if ( a2[k] == 41 )
--v4;
if ( v4 < 0 )
v10 = 0;
}
for ( m = 0; m < v11; ++m )
{
if ( a1[m] == 40 )
++v4;
if ( a1[m] == 41 )
--v4;
if ( v4 < 0 )
v10 = 0;
}
if ( v4 || !v10 )
return "No";
else
return "Yes";
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x8],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x00101070
MOV dword ptr [RBP + -0x4],EAX
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101213
LAB_001011d2:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x28
JNZ 0x001011ea
ADD dword ptr [RBP + -0x14],0x1
LAB_001011ea:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x29
JNZ 0x00101202
SUB dword ptr [RBP + -0x14],0x1
LAB_00101202:
CMP dword ptr [RBP + -0x14],0x0
JNS 0x0010120f
MOV dword ptr [RBP + -0xc],0x0
LAB_0010120f:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101213:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001011d2
MOV dword ptr [RBP + -0x10],0x0
JMP 0x00101265
LAB_00101224:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x28
JNZ 0x0010123c
ADD dword ptr [RBP + -0x14],0x1
LAB_0010123c:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x29
JNZ 0x00101254
SUB dword ptr [RBP + -0x14],0x1
LAB_00101254:
CMP dword ptr [RBP + -0x14],0x0
JNS 0x00101261
MOV dword ptr [RBP + -0xc],0x0
LAB_00101261:
ADD dword ptr [RBP + -0x10],0x1
LAB_00101265:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x00101224
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101285
CMP dword ptr [RBP + -0xc],0x0
JZ 0x00101285
LEA RAX,[0x102008]
JMP 0x00101353
LAB_00101285:
MOV dword ptr [RBP + -0x14],0x0
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x10],0x0
JMP 0x001012dd
LAB_0010129c:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x28
JNZ 0x001012b4
ADD dword ptr [RBP + -0x14],0x1
LAB_001012b4:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x29
JNZ 0x001012cc
SUB dword ptr [RBP + -0x14],0x1
LAB_001012cc:
CMP dword ptr [RBP + -0x14],0x0
JNS 0x001012d9
MOV dword ptr [RBP + -0xc],0x0
LAB_001012d9:
ADD dword ptr [RBP + -0x10],0x1
LAB_001012dd:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x4]
JL 0x0010129c
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010132f
LAB_001012ee:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x28
JNZ 0x00101306
ADD dword ptr [RBP + -0x14],0x1
LAB_00101306:
MOV EAX,dword ptr [RBP + -0x10]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x29
JNZ 0x0010131e
SUB dword ptr [RBP + -0x14],0x1
LAB_0010131e:
CMP dword ptr [RBP + -0x14],0x0
JNS 0x0010132b
MOV dword ptr [RBP + -0xc],0x0
LAB_0010132b:
ADD dword ptr [RBP + -0x10],0x1
LAB_0010132f:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x8]
JL 0x001012ee
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x0010134c
CMP dword ptr [RBP + -0xc],0x0
JZ 0x0010134c
LEA RAX,[0x102008]
JMP 0x00101353
LAB_0010134c:
LEA RAX,[0x10200c]
LAB_00101353:
LEAVE
RET
|
int * func0(char *param_1,char *param_2)
{
bool bVar1;
size_t sVar2;
size_t sVar3;
int *puVar4;
int local_1c;
int local_18;
local_1c = 0;
sVar2 = strlen(param_1);
sVar3 = strlen(param_2);
bVar1 = true;
for (local_18 = 0; local_18 < (int)sVar2; local_18 = local_18 + 1) {
if (param_1[local_18] == '(') {
local_1c = local_1c + 1;
}
if (param_1[local_18] == ')') {
local_1c = local_1c + -1;
}
if (local_1c < 0) {
bVar1 = false;
}
}
for (local_18 = 0; local_18 < (int)sVar3; local_18 = local_18 + 1) {
if (param_2[local_18] == '(') {
local_1c = local_1c + 1;
}
if (param_2[local_18] == ')') {
local_1c = local_1c + -1;
}
if (local_1c < 0) {
bVar1 = false;
}
}
if ((local_1c == 0) && (bVar1)) {
puVar4 = &DAT_00102008;
}
else {
local_1c = 0;
bVar1 = true;
for (local_18 = 0; local_18 < (int)sVar3; local_18 = local_18 + 1) {
if (param_2[local_18] == '(') {
local_1c = local_1c + 1;
}
if (param_2[local_18] == ')') {
local_1c = local_1c + -1;
}
if (local_1c < 0) {
bVar1 = false;
}
}
for (local_18 = 0; local_18 < (int)sVar2; local_18 = local_18 + 1) {
if (param_1[local_18] == '(') {
local_1c = local_1c + 1;
}
if (param_1[local_18] == ')') {
local_1c = local_1c + -1;
}
if (local_1c < 0) {
bVar1 = false;
}
}
if ((local_1c == 0) && (bVar1)) {
puVar4 = &DAT_00102008;
}
else {
puVar4 = &DAT_0010200c;
}
}
return puVar4;
}
|
1,133 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
count = 0;
can = 1;
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
return "No";
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes") == 0);
assert(strcmp(func0("()", "())"), "No") == 0);
assert(strcmp(func0("(()(", "()))()"), "Yes") == 0);
assert(strcmp(func0("((((", "((())"), "No") == 0);
assert(strcmp(func0(")(()", "(()("), "No") == 0);
assert(strcmp(func0(")(", ")("), "No") == 0);
assert(strcmp(func0("(", ")"), "Yes") == 0);
assert(strcmp(func0(")", "("), "Yes") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r8
mov $0xffffffffffffffff,%rbx
mov $0x0,%eax
mov %rbx,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%r10
mov %r10d,%r9d
mov %rbx,%rcx
mov %rsi,%rdi
repnz scas %es:(%rdi),%al
mov %rcx,%rax
not %rax
lea -0x1(%rax),%rbx
mov %ebx,%r11d
test %r10d,%r10d
jle 12f1 <func0+0x1a8>
mov %r8,%rcx
lea -0x1(%r10),%eax
lea 0x1(%r8,%rax,1),%r12
mov $0x1,%edx
mov $0x0,%eax
mov $0x0,%ebp
jmp 11c6 <func0+0x7d>
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%eax
test %eax,%eax
cmovs %ebp,%edx
add $0x1,%rcx
cmp %r12,%rcx
je 11d4 <func0+0x8b>
movzbl (%rcx),%edi
cmp $0x28,%dil
jne 11aa <func0+0x61>
add $0x1,%eax
jmp 11b8 <func0+0x6f>
test %ebx,%ebx
jle 1218 <func0+0xcf>
mov %rsi,%rcx
lea -0x1(%rbx),%edi
lea 0x1(%rsi,%rdi,1),%rbp
mov $0x0,%ebx
jmp 120a <func0+0xc1>
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%eax
test %eax,%eax
cmovs %ebx,%edx
add $0x1,%rcx
cmp %rcx,%rbp
je 12c9 <func0+0x180>
movzbl (%rcx),%edi
cmp $0x28,%dil
jne 11ea <func0+0xa1>
add $0x1,%eax
jmp 11f8 <func0+0xaf>
test %eax,%eax
jne 122b <func0+0xe2>
lea 0xde1(%rip),%rcx
test %edx,%edx
jne 12c1 <func0+0x178>
mov $0x1,%edx
mov $0x0,%eax
lea 0xdc8(%rip),%rcx
test %r10d,%r10d
jg 1273 <func0+0x12a>
jmp 12c1 <func0+0x178>
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%eax
test %eax,%eax
cmovs %ebx,%edx
add $0x1,%rcx
cmp %ecx,%r11d
jle 126e <func0+0x125>
movzbl (%rsi,%rcx,1),%edi
cmp $0x28,%dil
jne 1243 <func0+0xfa>
add $0x1,%eax
jmp 1251 <func0+0x108>
test %r10d,%r10d
jle 12ab <func0+0x162>
mov $0x0,%ecx
mov $0x0,%edi
jmp 129b <func0+0x152>
cmp $0x29,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rcx
cmp %ecx,%r9d
jle 12ab <func0+0x162>
movzbl (%r8,%rcx,1),%esi
cmp $0x28,%sil
jne 127f <func0+0x136>
add $0x1,%eax
jmp 128d <func0+0x144>
test %eax,%eax
jne 12ba <func0+0x171>
lea 0xd4e(%rip),%rcx
test %edx,%edx
jne 12c1 <func0+0x178>
lea 0xd47(%rip),%rcx
mov %rcx,%rax
pop %rbx
pop %rbp
pop %r12
retq
test %edx,%edx
je 12d8 <func0+0x18f>
lea 0xd30(%rip),%rcx
test %eax,%eax
je 12c1 <func0+0x178>
mov $0x0,%ecx
mov $0x1,%edx
mov $0x0,%eax
mov $0x0,%ebx
jmpq 125f <func0+0x116>
mov $0x1,%edx
mov $0x0,%eax
test %ebx,%ebx
jg 11d8 <func0+0x8f>
lea 0xcfa(%rip),%rcx
jmp 12c1 <func0+0x178>
|
func0:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
mov r13, rsi
call _strlen
mov rbp, rax
mov r12d, eax
mov rdi, r13; s
call _strlen
mov r8, rax
mov edi, eax
test ebp, ebp
jle loc_12D5
mov rcx, rbx
lea eax, [rbp-1]
lea r10, [rbx+rax+1]
mov edx, 1
mov eax, 0
mov r9d, 0
jmp short loc_11F7
loc_11DA:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
loc_11E8:
test eax, eax
cmovs edx, r9d
add rcx, 1
cmp rcx, r10
jz short loc_1205
loc_11F7:
movzx esi, byte ptr [rcx]
cmp sil, 28h ; '('
jnz short loc_11DA
add eax, 1
jmp short loc_11E8
loc_1205:
test r8d, r8d
jle loc_1320
loc_120E:
mov ecx, 0
mov r9d, 0
jmp short loc_1230
loc_121B:
add eax, 1
loc_121E:
test eax, eax
cmovs edx, r9d
add rcx, 1
cmp edi, ecx
jle loc_12F1
loc_1230:
movzx esi, byte ptr [r13+rcx+0]
cmp sil, 28h ; '('
jz short loc_121B
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
jmp short loc_121E
loc_124C:
add eax, 1
loc_124F:
test eax, eax
cmovs edx, edi
add rcx, 1
cmp rcx, r8
jz short loc_1276
loc_125D:
movzx esi, byte ptr [rcx]
cmp sil, 28h ; '('
jz short loc_124C
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
jmp short loc_124F
loc_1276:
test ebp, ebp
jle short loc_12B1
loc_127A:
mov ecx, 0
mov edi, 0
jmp short loc_1297
loc_1286:
add eax, 1
loc_1289:
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r12d, ecx
jle short loc_12B1
loc_1297:
movzx esi, byte ptr [rbx+rcx]
cmp sil, 28h ; '('
jz short loc_1286
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
jmp short loc_1289
loc_12B1:
test eax, eax
jnz short loc_12C0
lea rcx, s2; "Yes"
test edx, edx
jnz short loc_12C7
loc_12C0:
lea rcx, aNo; "No"
loc_12C7:
mov rax, rcx
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_12D5:
mov edx, 1
mov eax, 0
lea rcx, s2; "Yes"
test r8d, r8d
jg loc_120E
jmp short loc_12C7
loc_12F1:
test edx, edx
jz short loc_1300
lea rcx, s2; "Yes"
test eax, eax
jz short loc_12C7
loc_1300:
mov rcx, r13
lea eax, [r8-1]
lea r8, [r13+rax+1]
mov edx, 1
mov eax, 0
mov edi, 0
jmp loc_125D
loc_1320:
test eax, eax
jnz short loc_132F
lea rcx, s2; "Yes"
test edx, edx
jnz short loc_12C7
loc_132F:
mov edx, 1
mov eax, 0
jmp loc_127A
|
const char * func0(const char *a1, const char *a2)
{
int v3; // ebp
int v4; // r8d
const char *v5; // rcx
int v6; // edx
int v7; // eax
long long v8; // rcx
char v9; // si
int v10; // eax
int v11; // edx
const char *v12; // rcx
long long v13; // rcx
char v14; // si
const char *v15; // rcx
long long v17; // r8
v3 = strlen(a1);
v4 = strlen(a2);
if ( v3 <= 0 )
{
v6 = 1;
v7 = 0;
v15 = "Yes";
if ( v4 <= 0 )
return v15;
}
else
{
v5 = a1;
v6 = 1;
v7 = 0;
do
{
if ( *v5 == 40 )
++v7;
else
v7 -= *v5 == 41;
if ( v7 < 0 )
v6 = 0;
++v5;
}
while ( v5 != &a1[v3 - 1 + 1] );
if ( v4 <= 0 )
{
if ( !v7 )
{
v15 = "Yes";
if ( v6 )
return v15;
}
v11 = 1;
v10 = 0;
LABEL_24:
v13 = 0LL;
do
{
v14 = a1[v13];
if ( v14 == 40 )
++v10;
else
v10 -= v14 == 41;
if ( v10 < 0 )
v11 = 0;
++v13;
}
while ( v3 > (int)v13 );
LABEL_31:
if ( v10 )
return "No";
v15 = "Yes";
if ( !v11 )
return "No";
return v15;
}
}
v8 = 0LL;
do
{
v9 = a2[v8];
if ( v9 == 40 )
++v7;
else
v7 -= v9 == 41;
if ( v7 < 0 )
v6 = 0;
++v8;
}
while ( v4 > (int)v8 );
if ( !v6 || (v15 = "Yes", v7) )
{
v12 = a2;
v17 = (long long)&a2[v4 - 1 + 1];
v11 = 1;
v10 = 0;
do
{
if ( *v12 == 40 )
++v10;
else
v10 -= *v12 == 41;
if ( v10 < 0 )
v11 = 0;
++v12;
}
while ( v12 != (const char *)v17 );
if ( v3 <= 0 )
goto LABEL_31;
goto LABEL_24;
}
return v15;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
MOV R13,RSI
CALL 0x00101070
MOV RBP,RAX
MOV R12D,EAX
MOV RDI,R13
CALL 0x00101070
MOV R8,RAX
MOV EDI,EAX
TEST EBP,EBP
JLE 0x001012d5
MOV RCX,RBX
LEA EAX,[RBP + -0x1]
LEA R10,[RBX + RAX*0x1 + 0x1]
MOV EDX,0x1
MOV EAX,0x0
MOV R9D,0x0
JMP 0x001011f7
LAB_001011da:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
LAB_001011e8:
TEST EAX,EAX
CMOVS EDX,R9D
ADD RCX,0x1
CMP RCX,R10
JZ 0x00101205
LAB_001011f7:
MOVZX ESI,byte ptr [RCX]
CMP SIL,0x28
JNZ 0x001011da
ADD EAX,0x1
JMP 0x001011e8
LAB_00101205:
TEST R8D,R8D
JLE 0x00101320
LAB_0010120e:
MOV ECX,0x0
MOV R9D,0x0
JMP 0x00101230
LAB_0010121b:
ADD EAX,0x1
LAB_0010121e:
TEST EAX,EAX
CMOVS EDX,R9D
ADD RCX,0x1
CMP EDI,ECX
JLE 0x001012f1
LAB_00101230:
MOVZX ESI,byte ptr [R13 + RCX*0x1]
CMP SIL,0x28
JZ 0x0010121b
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
JMP 0x0010121e
LAB_0010124c:
ADD EAX,0x1
LAB_0010124f:
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP RCX,R8
JZ 0x00101276
LAB_0010125d:
MOVZX ESI,byte ptr [RCX]
CMP SIL,0x28
JZ 0x0010124c
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
JMP 0x0010124f
LAB_00101276:
TEST EBP,EBP
JLE 0x001012b1
LAB_0010127a:
MOV ECX,0x0
MOV EDI,0x0
JMP 0x00101297
LAB_00101286:
ADD EAX,0x1
LAB_00101289:
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R12D,ECX
JLE 0x001012b1
LAB_00101297:
MOVZX ESI,byte ptr [RBX + RCX*0x1]
CMP SIL,0x28
JZ 0x00101286
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
JMP 0x00101289
LAB_001012b1:
TEST EAX,EAX
JNZ 0x001012c0
LEA RCX,[0x102004]
TEST EDX,EDX
JNZ 0x001012c7
LAB_001012c0:
LEA RCX,[0x102008]
LAB_001012c7:
MOV RAX,RCX
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001012d5:
MOV EDX,0x1
MOV EAX,0x0
LEA RCX,[0x102004]
TEST R8D,R8D
JG 0x0010120e
JMP 0x001012c7
LAB_001012f1:
TEST EDX,EDX
JZ 0x00101300
LEA RCX,[0x102004]
TEST EAX,EAX
JZ 0x001012c7
LAB_00101300:
MOV RCX,R13
LEA EAX,[R8 + -0x1]
LEA R8,[R13 + RAX*0x1 + 0x1]
MOV EDX,0x1
MOV EAX,0x0
MOV EDI,0x0
JMP 0x0010125d
LAB_00101320:
TEST EAX,EAX
JNZ 0x0010132f
LEA RCX,[0x102004]
TEST EDX,EDX
JNZ 0x001012c7
LAB_0010132f:
MOV EDX,0x1
MOV EAX,0x0
JMP 0x0010127a
|
int * func0(char *param_1,char *param_2)
{
bool bVar1;
int iVar2;
int iVar3;
int iVar4;
size_t sVar5;
char *pcVar6;
long lVar7;
int *puVar8;
sVar5 = strlen(param_1);
iVar2 = (int)sVar5;
sVar5 = strlen(param_2);
iVar4 = (int)sVar5;
if (iVar2 < 1) {
bVar1 = true;
iVar3 = 0;
if (iVar4 < 1) {
return &DAT_00102004;
}
LAB_0010120e:
lVar7 = 0;
do {
if (param_2[lVar7] == '(') {
iVar3 = iVar3 + 1;
}
else {
iVar3 = iVar3 - (uint)(param_2[lVar7] == ')');
}
if (iVar3 < 0) {
bVar1 = false;
}
lVar7 = lVar7 + 1;
} while ((int)lVar7 < iVar4);
if ((bVar1) && (iVar3 == 0)) {
return &DAT_00102004;
}
pcVar6 = param_2 + (ulong)(iVar4 - 1) + 1;
bVar1 = true;
iVar4 = 0;
do {
if (*param_2 == '(') {
iVar4 = iVar4 + 1;
}
else {
iVar4 = iVar4 - (uint)(*param_2 == ')');
}
if (iVar4 < 0) {
bVar1 = false;
}
param_2 = param_2 + 1;
} while (param_2 != pcVar6);
if (iVar2 < 1) goto LAB_001012b1;
}
else {
bVar1 = true;
iVar3 = 0;
pcVar6 = param_1;
do {
if (*pcVar6 == '(') {
iVar3 = iVar3 + 1;
}
else {
iVar3 = iVar3 - (uint)(*pcVar6 == ')');
}
if (iVar3 < 0) {
bVar1 = false;
}
pcVar6 = pcVar6 + 1;
} while (pcVar6 != param_1 + (ulong)(iVar2 - 1) + 1);
if (0 < iVar4) goto LAB_0010120e;
if ((iVar3 == 0) && (bVar1)) {
return &DAT_00102004;
}
bVar1 = true;
iVar4 = 0;
}
lVar7 = 0;
do {
if (param_1[lVar7] == '(') {
iVar4 = iVar4 + 1;
}
else {
iVar4 = iVar4 - (uint)(param_1[lVar7] == ')');
}
if (iVar4 < 0) {
bVar1 = false;
}
lVar7 = lVar7 + 1;
} while ((int)lVar7 < iVar2);
LAB_001012b1:
if ((iVar4 != 0) || (puVar8 = &DAT_00102004, !bVar1)) {
puVar8 = &DAT_00102008;
}
return puVar8;
}
|
1,134 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
count = 0;
can = 1;
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
return "No";
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes") == 0);
assert(strcmp(func0("()", "())"), "No") == 0);
assert(strcmp(func0("(()(", "()))()"), "Yes") == 0);
assert(strcmp(func0("((((", "((())"), "No") == 0);
assert(strcmp(func0(")(()", "(()("), "No") == 0);
assert(strcmp(func0(")(", ")("), "No") == 0);
assert(strcmp(func0("(", ")"), "Yes") == 0);
assert(strcmp(func0(")", "("), "Yes") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r13
mov %eax,%r12d
callq 1060 <strlen@plt>
test %r13d,%r13d
jle 16a0 <func0+0x1c0>
lea -0x1(%r13),%edx
mov %rbp,%rsi
mov $0x1,%ecx
xor %r8d,%r8d
lea 0x1(%rbp,%rdx,1),%r9
xor %edx,%edx
jmp 154d <func0+0x6d>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%edx
test %edx,%edx
cmovs %r8d,%ecx
add $0x1,%rsi
cmp %r9,%rsi
je 1568 <func0+0x88>
movzbl (%rsi),%edi
cmp $0x28,%dil
jne 1530 <func0+0x50>
add $0x1,%edx
test %edx,%edx
cmovs %r8d,%ecx
add $0x1,%rsi
cmp %r9,%rsi
jne 154d <func0+0x6d>
test %eax,%eax
jle 16b8 <func0+0x1d8>
sub $0x1,%eax
mov %rbx,%rsi
xor %r9d,%r9d
lea 0x1(%rbx,%rax,1),%r8
mov %rbx,%rax
jmp 15a5 <func0+0xc5>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%edx
test %edx,%edx
cmovs %r9d,%ecx
add $0x1,%rax
cmp %r8,%rax
je 15c0 <func0+0xe0>
movzbl (%rax),%edi
cmp $0x28,%dil
jne 1588 <func0+0xa8>
add $0x1,%edx
test %edx,%edx
cmovs %r9d,%ecx
add $0x1,%rax
cmp %r8,%rax
jne 15a5 <func0+0xc5>
test %edx,%edx
jne 15e0 <func0+0x100>
and $0x1,%ecx
lea 0xa36(%rip),%rax
je 15e0 <func0+0x100>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%edx
xor %eax,%eax
xor %edi,%edi
jmp 1609 <func0+0x129>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%cl
sete %cl
movzbl %cl,%ecx
sub %ecx,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rsi
cmp %r8,%rsi
je 1622 <func0+0x142>
movzbl (%rsi),%ecx
cmp $0x28,%cl
jne 15f0 <func0+0x110>
add $0x1,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rsi
cmp %r8,%rsi
jne 1609 <func0+0x129>
test %r13d,%r13d
jle 1668 <func0+0x188>
xor %ecx,%ecx
xor %edi,%edi
jmp 164c <func0+0x16c>
nopl (%rax)
cmp $0x29,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rcx
cmp %ecx,%r12d
jle 1668 <func0+0x188>
movzbl 0x0(%rbp,%rcx,1),%esi
cmp $0x28,%sil
jne 1630 <func0+0x150>
add $0x1,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rcx
cmp %ecx,%r12d
jg 164c <func0+0x16c>
test %eax,%eax
jne 1688 <func0+0x1a8>
and $0x1,%edx
je 1688 <func0+0x1a8>
add $0x8,%rsp
lea 0x988(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
lea 0x975(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
mov $0x1,%ecx
test %eax,%eax
jg 1570 <func0+0x90>
jmp 1671 <func0+0x191>
nopl 0x0(%rax)
test %edx,%edx
jne 16cc <func0+0x1ec>
and $0x1,%ecx
lea 0x93e(%rip),%rax
jne 15d0 <func0+0xf0>
xor %eax,%eax
mov $0x1,%edx
jmpq 1627 <func0+0x147>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rdi, rbx; s
mov r13, rax
mov r12d, eax
call _strlen
mov r8d, eax
test r13d, r13d
jle loc_1680
lea edx, [r13-1]
mov rsi, rbp
mov ecx, 1
xor r9d, r9d
lea r10, [rbp+rdx+1]
xor edx, edx
jmp short loc_153D
loc_1520:
cmp dil, 29h ; ')'
setz dil
movzx edi, dil
sub edx, edi
test edx, edx
cmovs ecx, r9d
add rsi, 1
cmp r10, rsi
jz short loc_1558
loc_153D:
movzx edi, byte ptr [rsi]
cmp dil, 28h ; '('
jnz short loc_1520
add edx, 1
test edx, edx
cmovs ecx, r9d
add rsi, 1
cmp r10, rsi
jnz short loc_153D
loc_1558:
test eax, eax
jle loc_16A0
loc_1560:
xor eax, eax
xor edi, edi
jmp short loc_158C
loc_1570:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub edx, esi
test edx, edx
cmovs ecx, edi
add rax, 1
cmp r8d, eax
jle short loc_15A7
loc_158C:
movzx esi, byte ptr [rbx+rax]
cmp sil, 28h ; '('
jnz short loc_1570
add edx, 1
test edx, edx
cmovs ecx, edi
add rax, 1
cmp r8d, eax
jg short loc_158C
loc_15A7:
test edx, edx
jnz short loc_15C8
and ecx, 1
lea rax, s2; "Yes"
jz short loc_15C8
loc_15B7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15C8:
xor ecx, ecx
mov edx, 1
xor eax, eax
xor edi, edi
jmp short loc_15F4
loc_15D8:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r8d, ecx
jle short loc_160F
loc_15F4:
movzx esi, byte ptr [rbx+rcx]
cmp sil, 28h ; '('
jnz short loc_15D8
add eax, 1
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r8d, ecx
jg short loc_15F4
loc_160F:
test r13d, r13d
jle short loc_1658
loc_1614:
xor ecx, ecx
xor edi, edi
jmp short loc_163C
loc_1620:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r12d, ecx
jle short loc_1658
loc_163C:
movzx esi, byte ptr [rbp+rcx+0]
cmp sil, 28h ; '('
jnz short loc_1620
add eax, 1
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r12d, ecx
jg short loc_163C
loc_1658:
test eax, eax
jnz short loc_166C
and edx, 1
lea rax, s2; "Yes"
jnz loc_15B7
loc_166C:
add rsp, 8
lea rax, aNo; "No"
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1680:
mov ecx, 1
xor edx, edx
test eax, eax
jg loc_1560
lea rax, s2; "Yes"
jmp loc_15B7
loc_16A0:
test edx, edx
jnz short loc_16B4
and ecx, 1
lea rax, s2; "Yes"
jnz loc_15B7
loc_16B4:
mov edx, 1
xor eax, eax
jmp loc_1614
|
const char * func0(const char *a1, const char *a2)
{
int v3; // r13d
int v4; // eax
int v5; // r8d
const char *v6; // rsi
char v7; // cl
long long v8; // r10
int v9; // edx
long long v10; // rax
char v11; // si
const char *result; // rax
long long v13; // rcx
char v14; // dl
int v15; // eax
char v16; // si
long long v17; // rcx
char v18; // si
v3 = strlen(a1);
v4 = strlen(a2);
v5 = v4;
if ( v3 <= 0 )
{
v7 = 1;
v9 = 0;
if ( v4 <= 0 )
return "Yes";
}
else
{
v6 = a1;
v7 = 1;
v8 = (long long)&a1[v3 - 1 + 1];
v9 = 0;
do
{
while ( *v6 == 40 )
{
if ( ++v9 < 0 )
v7 = 0;
if ( (const char *)v8 == ++v6 )
goto LABEL_10;
}
v9 -= *v6 == 41;
if ( v9 < 0 )
v7 = 0;
++v6;
}
while ( (const char *)v8 != v6 );
LABEL_10:
if ( v4 <= 0 )
{
if ( !v9 )
{
result = "Yes";
if ( (v7 & 1) != 0 )
return result;
}
v14 = 1;
v15 = 0;
LABEL_31:
v17 = 0LL;
do
{
while ( 1 )
{
v18 = a1[v17];
if ( v18 != 40 )
break;
if ( ++v15 < 0 )
v14 = 0;
if ( v3 <= (int)++v17 )
goto LABEL_39;
}
v15 -= v18 == 41;
if ( v15 < 0 )
v14 = 0;
++v17;
}
while ( v3 > (int)v17 );
LABEL_39:
if ( v15 )
return "No";
result = "Yes";
if ( (v14 & 1) == 0 )
return "No";
return result;
}
}
v10 = 0LL;
do
{
while ( 1 )
{
v11 = a2[v10];
if ( v11 != 40 )
break;
if ( ++v9 < 0 )
v7 = 0;
if ( v5 <= (int)++v10 )
goto LABEL_19;
}
v9 -= v11 == 41;
if ( v9 < 0 )
v7 = 0;
++v10;
}
while ( v5 > (int)v10 );
LABEL_19:
if ( v9 || (result = "Yes", (v7 & 1) == 0) )
{
v13 = 0LL;
v14 = 1;
v15 = 0;
do
{
while ( 1 )
{
v16 = a2[v13];
if ( v16 != 40 )
break;
if ( ++v15 < 0 )
v14 = 0;
if ( v5 <= (int)++v13 )
goto LABEL_30;
}
v15 -= v16 == 41;
if ( v15 < 0 )
v14 = 0;
++v13;
}
while ( v5 > (int)v13 );
LABEL_30:
if ( v3 <= 0 )
goto LABEL_39;
goto LABEL_31;
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RBX
MOV R13,RAX
MOV R12D,EAX
CALL 0x00101070
MOV R8D,EAX
TEST R13D,R13D
JLE 0x00101680
LEA EDX,[R13 + -0x1]
MOV RSI,RBP
MOV ECX,0x1
XOR R9D,R9D
LEA R10,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x0010153d
LAB_00101520:
CMP DIL,0x29
SETZ DIL
MOVZX EDI,DIL
SUB EDX,EDI
TEST EDX,EDX
CMOVS ECX,R9D
ADD RSI,0x1
CMP R10,RSI
JZ 0x00101558
LAB_0010153d:
MOVZX EDI,byte ptr [RSI]
CMP DIL,0x28
JNZ 0x00101520
ADD EDX,0x1
TEST EDX,EDX
CMOVS ECX,R9D
ADD RSI,0x1
CMP R10,RSI
JNZ 0x0010153d
LAB_00101558:
TEST EAX,EAX
JLE 0x001016a0
LAB_00101560:
XOR EAX,EAX
XOR EDI,EDI
JMP 0x0010158c
LAB_00101570:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EDX,ESI
TEST EDX,EDX
CMOVS ECX,EDI
ADD RAX,0x1
CMP R8D,EAX
JLE 0x001015a7
LAB_0010158c:
MOVZX ESI,byte ptr [RBX + RAX*0x1]
CMP SIL,0x28
JNZ 0x00101570
ADD EDX,0x1
TEST EDX,EDX
CMOVS ECX,EDI
ADD RAX,0x1
CMP R8D,EAX
JG 0x0010158c
LAB_001015a7:
TEST EDX,EDX
JNZ 0x001015c8
AND ECX,0x1
LEA RAX,[0x102004]
JZ 0x001015c8
LAB_001015b7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015c8:
XOR ECX,ECX
MOV EDX,0x1
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001015f4
LAB_001015d8:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R8D,ECX
JLE 0x0010160f
LAB_001015f4:
MOVZX ESI,byte ptr [RBX + RCX*0x1]
CMP SIL,0x28
JNZ 0x001015d8
ADD EAX,0x1
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R8D,ECX
JG 0x001015f4
LAB_0010160f:
TEST R13D,R13D
JLE 0x00101658
LAB_00101614:
XOR ECX,ECX
XOR EDI,EDI
JMP 0x0010163c
LAB_00101620:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R12D,ECX
JLE 0x00101658
LAB_0010163c:
MOVZX ESI,byte ptr [RBP + RCX*0x1]
CMP SIL,0x28
JNZ 0x00101620
ADD EAX,0x1
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R12D,ECX
JG 0x0010163c
LAB_00101658:
TEST EAX,EAX
JNZ 0x0010166c
AND EDX,0x1
LEA RAX,[0x102004]
JNZ 0x001015b7
LAB_0010166c:
ADD RSP,0x8
LEA RAX,[0x102008]
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101680:
MOV ECX,0x1
XOR EDX,EDX
TEST EAX,EAX
JG 0x00101560
LEA RAX,[0x102004]
JMP 0x001015b7
LAB_001016a0:
TEST EDX,EDX
JNZ 0x001016b4
AND ECX,0x1
LEA RAX,[0x102004]
JNZ 0x001015b7
LAB_001016b4:
MOV EDX,0x1
XOR EAX,EAX
JMP 0x00101614
|
int * func0(char *param_1,char *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
long lVar4;
bool bVar5;
int iVar6;
char *pcVar7;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
if (iVar1 < 1) {
bVar5 = true;
iVar6 = 0;
if (iVar2 < 1) goto LAB_001015b7;
LAB_00101560:
lVar4 = 0;
do {
while (param_2[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_2[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar2 <= (int)lVar4) goto LAB_001015a7;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar2);
LAB_001015a7:
if ((iVar6 == 0) && (bVar5)) goto LAB_001015b7;
lVar4 = 0;
bVar5 = true;
iVar6 = 0;
do {
while (param_2[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_2[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar2 <= (int)lVar4) goto LAB_0010160f;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar2);
LAB_0010160f:
if (0 < iVar1) goto LAB_00101614;
}
else {
bVar5 = true;
iVar6 = 0;
pcVar7 = param_1;
do {
while (*pcVar7 != '(') {
iVar6 = iVar6 - (uint)(*pcVar7 == ')');
if (iVar6 < 0) {
bVar5 = false;
}
pcVar7 = pcVar7 + 1;
if (param_1 + (ulong)(iVar1 - 1) + 1 == pcVar7) goto LAB_00101558;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
pcVar7 = pcVar7 + 1;
} while (param_1 + (ulong)(iVar1 - 1) + 1 != pcVar7);
LAB_00101558:
if (0 < iVar2) goto LAB_00101560;
if ((iVar6 == 0) && (bVar5)) goto LAB_001015b7;
bVar5 = true;
iVar6 = 0;
LAB_00101614:
lVar4 = 0;
do {
while (param_1[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_1[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar1 <= (int)lVar4) goto LAB_00101658;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar1);
}
LAB_00101658:
if ((iVar6 != 0) || (!bVar5)) {
return &DAT_00102008;
}
LAB_001015b7:
return &DAT_00102004;
}
|
1,135 |
func0
|
#include <stdio.h>
#include <string.h>
|
const char *func0(const char *s1, const char *s2) {
int count = 0;
int len1 = strlen(s1);
int len2 = strlen(s2);
int i;
int can = 1;
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
count = 0;
can = 1;
for (i = 0; i < len2; i++) {
if (s2[i] == '(') count++;
if (s2[i] == ')') count--;
if (count < 0) can = 0;
}
for (i = 0; i < len1; i++) {
if (s1[i] == '(') count++;
if (s1[i] == ')') count--;
if (count < 0) can = 0;
}
if (count == 0 && can) return "Yes";
return "No";
}
|
#include <stdio.h>
#include <assert.h>
int main() {
assert(strcmp(func0("()(", ")"), "Yes") == 0);
assert(strcmp(func0(")", ")"), "No") == 0);
assert(strcmp(func0("(()(())", "())())"), "No") == 0);
assert(strcmp(func0(")())", "(()()("), "Yes") == 0);
assert(strcmp(func0("(())))", "(()())(("), "Yes") == 0);
assert(strcmp(func0("()", "())"), "No") == 0);
assert(strcmp(func0("(()(", "()))()"), "Yes") == 0);
assert(strcmp(func0("((((", "((())"), "No") == 0);
assert(strcmp(func0(")(()", "(()("), "No") == 0);
assert(strcmp(func0(")(", ")("), "No") == 0);
assert(strcmp(func0("(", ")"), "Yes") == 0);
assert(strcmp(func0(")", "("), "Yes") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
callq 1060 <strlen@plt>
mov %rbx,%rdi
mov %rax,%r13
mov %eax,%r12d
callq 1060 <strlen@plt>
test %r13d,%r13d
jle 16a0 <func0+0x1c0>
lea -0x1(%r13),%edx
mov %rbp,%rsi
mov $0x1,%ecx
xor %r8d,%r8d
lea 0x1(%rbp,%rdx,1),%r9
xor %edx,%edx
jmp 154d <func0+0x6d>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%edx
test %edx,%edx
cmovs %r8d,%ecx
add $0x1,%rsi
cmp %r9,%rsi
je 1568 <func0+0x88>
movzbl (%rsi),%edi
cmp $0x28,%dil
jne 1530 <func0+0x50>
add $0x1,%edx
test %edx,%edx
cmovs %r8d,%ecx
add $0x1,%rsi
cmp %r9,%rsi
jne 154d <func0+0x6d>
test %eax,%eax
jle 16b8 <func0+0x1d8>
sub $0x1,%eax
mov %rbx,%rsi
xor %r9d,%r9d
lea 0x1(%rbx,%rax,1),%r8
mov %rbx,%rax
jmp 15a5 <func0+0xc5>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%dil
sete %dil
movzbl %dil,%edi
sub %edi,%edx
test %edx,%edx
cmovs %r9d,%ecx
add $0x1,%rax
cmp %rax,%r8
je 15c0 <func0+0xe0>
movzbl (%rax),%edi
cmp $0x28,%dil
jne 1588 <func0+0xa8>
add $0x1,%edx
test %edx,%edx
cmovs %r9d,%ecx
add $0x1,%rax
cmp %rax,%r8
jne 15a5 <func0+0xc5>
test %edx,%edx
jne 15e0 <func0+0x100>
and $0x1,%ecx
lea 0xa36(%rip),%rax
je 15e0 <func0+0x100>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
mov $0x1,%edx
xor %eax,%eax
xor %edi,%edi
jmp 1609 <func0+0x129>
nopl 0x0(%rax,%rax,1)
cmp $0x29,%cl
sete %cl
movzbl %cl,%ecx
sub %ecx,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rsi
cmp %rsi,%r8
je 1622 <func0+0x142>
movzbl (%rsi),%ecx
cmp $0x28,%cl
jne 15f0 <func0+0x110>
add $0x1,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rsi
cmp %rsi,%r8
jne 1609 <func0+0x129>
test %r13d,%r13d
jle 1668 <func0+0x188>
xor %ecx,%ecx
xor %edi,%edi
jmp 164c <func0+0x16c>
nopl (%rax)
cmp $0x29,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rcx
cmp %ecx,%r12d
jle 1668 <func0+0x188>
movzbl 0x0(%rbp,%rcx,1),%esi
cmp $0x28,%sil
jne 1630 <func0+0x150>
add $0x1,%eax
test %eax,%eax
cmovs %edi,%edx
add $0x1,%rcx
cmp %ecx,%r12d
jg 164c <func0+0x16c>
test %eax,%eax
jne 1688 <func0+0x1a8>
and $0x1,%edx
je 1688 <func0+0x1a8>
add $0x8,%rsp
lea 0x988(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopl 0x0(%rax,%rax,1)
add $0x8,%rsp
lea 0x975(%rip),%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
xor %edx,%edx
mov $0x1,%ecx
test %eax,%eax
jg 1570 <func0+0x90>
jmp 1671 <func0+0x191>
nopl 0x0(%rax)
test %edx,%edx
jne 16cc <func0+0x1ec>
and $0x1,%ecx
lea 0x93e(%rip),%rax
jne 15d0 <func0+0xf0>
xor %eax,%eax
mov $0x1,%edx
jmpq 1627 <func0+0x147>
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
call _strlen
mov rdi, rbx; s
mov r13, rax
mov r12d, eax
call _strlen
mov r8d, eax
test r13d, r13d
jle loc_1680
lea edx, [r13-1]
mov rsi, rbp
mov ecx, 1
xor r9d, r9d
lea r10, [rbp+rdx+1]
xor edx, edx
jmp short loc_153D
loc_1520:
cmp dil, 29h ; ')'
setz dil
movzx edi, dil
sub edx, edi
test edx, edx
cmovs ecx, r9d
add rsi, 1
cmp rsi, r10
jz short loc_1558
loc_153D:
movzx edi, byte ptr [rsi]
cmp dil, 28h ; '('
jnz short loc_1520
add edx, 1
test edx, edx
cmovs ecx, r9d
add rsi, 1
cmp rsi, r10
jnz short loc_153D
loc_1558:
test eax, eax
jle loc_16A0
loc_1560:
xor eax, eax
xor edi, edi
jmp short loc_158C
loc_1570:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub edx, esi
test edx, edx
cmovs ecx, edi
add rax, 1
cmp r8d, eax
jle short loc_15A7
loc_158C:
movzx esi, byte ptr [rbx+rax]
cmp sil, 28h ; '('
jnz short loc_1570
add edx, 1
test edx, edx
cmovs ecx, edi
add rax, 1
cmp r8d, eax
jg short loc_158C
loc_15A7:
test edx, edx
jnz short loc_15C8
and ecx, 1
lea rax, s2; "Yes"
jz short loc_15C8
loc_15B7:
add rsp, 8
pop rbx
pop rbp
pop r12
pop r13
retn
loc_15C8:
xor ecx, ecx
mov edx, 1
xor eax, eax
xor edi, edi
jmp short loc_15F4
loc_15D8:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r8d, ecx
jle short loc_160F
loc_15F4:
movzx esi, byte ptr [rbx+rcx]
cmp sil, 28h ; '('
jnz short loc_15D8
add eax, 1
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r8d, ecx
jg short loc_15F4
loc_160F:
test r13d, r13d
jle short loc_1658
loc_1614:
xor ecx, ecx
xor edi, edi
jmp short loc_163C
loc_1620:
cmp sil, 29h ; ')'
setz sil
movzx esi, sil
sub eax, esi
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r12d, ecx
jle short loc_1658
loc_163C:
movzx esi, byte ptr [rbp+rcx+0]
cmp sil, 28h ; '('
jnz short loc_1620
add eax, 1
test eax, eax
cmovs edx, edi
add rcx, 1
cmp r12d, ecx
jg short loc_163C
loc_1658:
test eax, eax
jnz short loc_166C
and edx, 1
lea rax, s2; "Yes"
jnz loc_15B7
loc_166C:
add rsp, 8
lea rax, aNo; "No"
pop rbx
pop rbp
pop r12
pop r13
retn
loc_1680:
mov ecx, 1
xor edx, edx
test eax, eax
jg loc_1560
lea rax, s2; "Yes"
jmp loc_15B7
loc_16A0:
test edx, edx
jnz short loc_16B4
and ecx, 1
lea rax, s2; "Yes"
jnz loc_15B7
loc_16B4:
mov edx, 1
xor eax, eax
jmp loc_1614
|
const char * func0(const char *a1, const char *a2)
{
int v3; // r13d
int v4; // eax
int v5; // r8d
const char *v6; // rsi
char v7; // cl
long long v8; // r10
int v9; // edx
long long v10; // rax
char v11; // si
const char *result; // rax
long long v13; // rcx
char v14; // dl
int v15; // eax
char v16; // si
long long v17; // rcx
char v18; // si
v3 = strlen(a1);
v4 = strlen(a2);
v5 = v4;
if ( v3 <= 0 )
{
v7 = 1;
v9 = 0;
if ( v4 <= 0 )
return "Yes";
}
else
{
v6 = a1;
v7 = 1;
v8 = (long long)&a1[v3 - 1 + 1];
v9 = 0;
do
{
while ( *v6 == 40 )
{
if ( ++v9 < 0 )
v7 = 0;
if ( ++v6 == (const char *)v8 )
goto LABEL_10;
}
v9 -= *v6 == 41;
if ( v9 < 0 )
v7 = 0;
++v6;
}
while ( v6 != (const char *)v8 );
LABEL_10:
if ( v4 <= 0 )
{
if ( !v9 )
{
result = "Yes";
if ( (v7 & 1) != 0 )
return result;
}
v14 = 1;
v15 = 0;
LABEL_31:
v17 = 0LL;
do
{
while ( 1 )
{
v18 = a1[v17];
if ( v18 != 40 )
break;
if ( ++v15 < 0 )
v14 = 0;
if ( v3 <= (int)++v17 )
goto LABEL_39;
}
v15 -= v18 == 41;
if ( v15 < 0 )
v14 = 0;
++v17;
}
while ( v3 > (int)v17 );
LABEL_39:
if ( v15 )
return "No";
result = "Yes";
if ( (v14 & 1) == 0 )
return "No";
return result;
}
}
v10 = 0LL;
do
{
while ( 1 )
{
v11 = a2[v10];
if ( v11 != 40 )
break;
if ( ++v9 < 0 )
v7 = 0;
if ( v5 <= (int)++v10 )
goto LABEL_19;
}
v9 -= v11 == 41;
if ( v9 < 0 )
v7 = 0;
++v10;
}
while ( v5 > (int)v10 );
LABEL_19:
if ( v9 || (result = "Yes", (v7 & 1) == 0) )
{
v13 = 0LL;
v14 = 1;
v15 = 0;
do
{
while ( 1 )
{
v16 = a2[v13];
if ( v16 != 40 )
break;
if ( ++v15 < 0 )
v14 = 0;
if ( v5 <= (int)++v13 )
goto LABEL_30;
}
v15 -= v16 == 41;
if ( v15 < 0 )
v14 = 0;
++v13;
}
while ( v5 > (int)v13 );
LABEL_30:
if ( v3 <= 0 )
goto LABEL_39;
goto LABEL_31;
}
return result;
}
|
func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
CALL 0x00101070
MOV RDI,RBX
MOV R13,RAX
MOV R12D,EAX
CALL 0x00101070
MOV R8D,EAX
TEST R13D,R13D
JLE 0x00101680
LEA EDX,[R13 + -0x1]
MOV RSI,RBP
MOV ECX,0x1
XOR R9D,R9D
LEA R10,[RBP + RDX*0x1 + 0x1]
XOR EDX,EDX
JMP 0x0010153d
LAB_00101520:
CMP DIL,0x29
SETZ DIL
MOVZX EDI,DIL
SUB EDX,EDI
TEST EDX,EDX
CMOVS ECX,R9D
ADD RSI,0x1
CMP RSI,R10
JZ 0x00101558
LAB_0010153d:
MOVZX EDI,byte ptr [RSI]
CMP DIL,0x28
JNZ 0x00101520
ADD EDX,0x1
TEST EDX,EDX
CMOVS ECX,R9D
ADD RSI,0x1
CMP RSI,R10
JNZ 0x0010153d
LAB_00101558:
TEST EAX,EAX
JLE 0x001016a0
LAB_00101560:
XOR EAX,EAX
XOR EDI,EDI
JMP 0x0010158c
LAB_00101570:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EDX,ESI
TEST EDX,EDX
CMOVS ECX,EDI
ADD RAX,0x1
CMP R8D,EAX
JLE 0x001015a7
LAB_0010158c:
MOVZX ESI,byte ptr [RBX + RAX*0x1]
CMP SIL,0x28
JNZ 0x00101570
ADD EDX,0x1
TEST EDX,EDX
CMOVS ECX,EDI
ADD RAX,0x1
CMP R8D,EAX
JG 0x0010158c
LAB_001015a7:
TEST EDX,EDX
JNZ 0x001015c8
AND ECX,0x1
LEA RAX,[0x102004]
JZ 0x001015c8
LAB_001015b7:
ADD RSP,0x8
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_001015c8:
XOR ECX,ECX
MOV EDX,0x1
XOR EAX,EAX
XOR EDI,EDI
JMP 0x001015f4
LAB_001015d8:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R8D,ECX
JLE 0x0010160f
LAB_001015f4:
MOVZX ESI,byte ptr [RBX + RCX*0x1]
CMP SIL,0x28
JNZ 0x001015d8
ADD EAX,0x1
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R8D,ECX
JG 0x001015f4
LAB_0010160f:
TEST R13D,R13D
JLE 0x00101658
LAB_00101614:
XOR ECX,ECX
XOR EDI,EDI
JMP 0x0010163c
LAB_00101620:
CMP SIL,0x29
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R12D,ECX
JLE 0x00101658
LAB_0010163c:
MOVZX ESI,byte ptr [RBP + RCX*0x1]
CMP SIL,0x28
JNZ 0x00101620
ADD EAX,0x1
TEST EAX,EAX
CMOVS EDX,EDI
ADD RCX,0x1
CMP R12D,ECX
JG 0x0010163c
LAB_00101658:
TEST EAX,EAX
JNZ 0x0010166c
AND EDX,0x1
LEA RAX,[0x102004]
JNZ 0x001015b7
LAB_0010166c:
ADD RSP,0x8
LEA RAX,[0x102008]
POP RBX
POP RBP
POP R12
POP R13
RET
LAB_00101680:
MOV ECX,0x1
XOR EDX,EDX
TEST EAX,EAX
JG 0x00101560
LEA RAX,[0x102004]
JMP 0x001015b7
LAB_001016a0:
TEST EDX,EDX
JNZ 0x001016b4
AND ECX,0x1
LEA RAX,[0x102004]
JNZ 0x001015b7
LAB_001016b4:
MOV EDX,0x1
XOR EAX,EAX
JMP 0x00101614
|
int * func0(char *param_1,char *param_2)
{
int iVar1;
int iVar2;
size_t sVar3;
long lVar4;
bool bVar5;
int iVar6;
char *pcVar7;
sVar3 = strlen(param_1);
iVar1 = (int)sVar3;
sVar3 = strlen(param_2);
iVar2 = (int)sVar3;
if (iVar1 < 1) {
bVar5 = true;
iVar6 = 0;
if (iVar2 < 1) goto LAB_001015b7;
LAB_00101560:
lVar4 = 0;
do {
while (param_2[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_2[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar2 <= (int)lVar4) goto LAB_001015a7;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar2);
LAB_001015a7:
if ((iVar6 == 0) && (bVar5)) goto LAB_001015b7;
lVar4 = 0;
bVar5 = true;
iVar6 = 0;
do {
while (param_2[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_2[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar2 <= (int)lVar4) goto LAB_0010160f;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar2);
LAB_0010160f:
if (0 < iVar1) goto LAB_00101614;
}
else {
bVar5 = true;
iVar6 = 0;
pcVar7 = param_1;
do {
while (*pcVar7 != '(') {
iVar6 = iVar6 - (uint)(*pcVar7 == ')');
if (iVar6 < 0) {
bVar5 = false;
}
pcVar7 = pcVar7 + 1;
if (pcVar7 == param_1 + (ulong)(iVar1 - 1) + 1) goto LAB_00101558;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
pcVar7 = pcVar7 + 1;
} while (pcVar7 != param_1 + (ulong)(iVar1 - 1) + 1);
LAB_00101558:
if (0 < iVar2) goto LAB_00101560;
if ((iVar6 == 0) && (bVar5)) goto LAB_001015b7;
bVar5 = true;
iVar6 = 0;
LAB_00101614:
lVar4 = 0;
do {
while (param_1[lVar4] != '(') {
iVar6 = iVar6 - (uint)(param_1[lVar4] == ')');
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
if (iVar1 <= (int)lVar4) goto LAB_00101658;
}
iVar6 = iVar6 + 1;
if (iVar6 < 0) {
bVar5 = false;
}
lVar4 = lVar4 + 1;
} while ((int)lVar4 < iVar1);
}
LAB_00101658:
if ((iVar6 != 0) || (!bVar5)) {
return &DAT_00102008;
}
LAB_001015b7:
return &DAT_00102004;
}
|
1,136 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < k; i++) {
out[i] = arr[arr_size - k + i];
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
assert(issame(out1, expected1, 3));
int arr2[] = {4, -4, 4};
int out2[2];
func0(arr2, 3, 2, out2);
int expected2[] = {4, 4};
assert(issame(out2, expected2, 2));
int arr3[] = {-3, 2, 1, 2, -1, -2, 1};
int out3[1];
func0(arr3, 7, 1, out3);
int expected3[] = {2};
assert(issame(out3, expected3, 1));
int arr4[] = {123, -123, 20, 0, 1, 2, -3};
int out4[3];
func0(arr4, 7, 3, out4);
int expected4[] = {2, 20, 123};
assert(issame(out4, expected4, 3));
int arr5[] = {-123, 20, 0, 1, 2, -3};
int out5[4];
func0(arr5, 6, 4, out5);
int expected5[] = {0, 1, 2, 20};
assert(issame(out5, expected5, 4));
int arr6[] = {5, 15, 0, 3, -13, -8, 0};
int out6[7];
func0(arr6, 7, 7, out6);
int expected6[] = {-13, -8, 0, 0, 3, 5, 15};
assert(issame(out6, expected6, 7));
int arr7[] = {-1, 0, 2, 5, 3, -10};
int out7[2];
func0(arr7, 6, 2, out7);
int expected7[] = {3, 5};
assert(issame(out7, expected7, 2));
int arr8[] = {1, 0, 5, -7};
int out8[1];
func0(arr8, 4, 1, out8);
int expected8[] = {5};
assert(issame(out8, expected8, 1));
int arr9[] = {4, -4};
int out9[2];
func0(arr9, 2, 2, out9);
int expected9[] = {-4, 4};
assert(issame(out9, expected9, 2));
int arr10[] = {-10, 10};
int out10[2];
func0(arr10, 2, 2, out10);
int expected10[] = {-10, 10};
assert(issame(out10, expected10, 2));
int arr11[] = {1, 2, 3, -23, 243, -400, 0};
int out11[0];
func0(arr11, 7, 0, out11); // Empty output expected
int expected11[] = {}; // Empty array
assert(issame(out11, expected11, 0));
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
mov %edx,-0x20(%rbp)
mov %rcx,-0x28(%rbp)
movl $0x0,-0x10(%rbp)
jmpq 124c <func0+0xe3>
movl $0x0,-0xc(%rbp)
jmpq 1236 <func0+0xcd>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jle 1232 <func0+0xc9>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0xc(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x18(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
mov -0xc(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0x1c(%rbp),%eax
sub -0x10(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0xc(%rbp)
jl 1197 <func0+0x2e>
addl $0x1,-0x10(%rbp)
mov -0x1c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x10(%rbp)
jl 118b <func0+0x22>
movl $0x0,-0x8(%rbp)
jmp 129f <func0+0x136>
mov -0x1c(%rbp),%eax
sub -0x20(%rbp),%eax
mov %eax,%edx
mov -0x8(%rbp),%eax
add %edx,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x28(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
addl $0x1,-0x8(%rbp)
mov -0x8(%rbp),%eax
cmp -0x20(%rbp),%eax
jl 1264 <func0+0xfb>
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_20], edx
mov [rbp+var_28], rcx
mov [rbp+var_10], 0
jmp loc_124C
loc_118B:
mov [rbp+var_C], 0
jmp loc_1236
loc_1197:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
add rax, 1
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jle short loc_1232
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_C]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_C]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_18]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
mov eax, [rbp+var_C]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
loc_1232:
add [rbp+var_C], 1
loc_1236:
mov eax, [rbp+var_1C]
sub eax, [rbp+var_10]
sub eax, 1
cmp [rbp+var_C], eax
jl loc_1197
add [rbp+var_10], 1
loc_124C:
mov eax, [rbp+var_1C]
sub eax, 1
cmp [rbp+var_10], eax
jl loc_118B
mov [rbp+var_8], 0
jmp short loc_129F
loc_1264:
mov eax, [rbp+var_1C]
sub eax, [rbp+var_20]
mov edx, eax
mov eax, [rbp+var_8]
add eax, edx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+var_28]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
add [rbp+var_8], 1
loc_129F:
mov eax, [rbp+var_8]
cmp eax, [rbp+var_20]
jl short loc_1264
nop
nop
pop rbp
retn
|
long long func0(long long a1, int a2, int a3, long long a4)
{
long long result; // rax
int i; // [rsp+18h] [rbp-10h]
int j; // [rsp+1Ch] [rbp-Ch]
unsigned int k; // [rsp+20h] [rbp-8h]
int v8; // [rsp+24h] [rbp-4h]
for ( i = 0; i < a2 - 1; ++i )
{
for ( j = 0; j < a2 - i - 1; ++j )
{
if ( *(_DWORD *)(4LL * j + a1) > *(_DWORD *)(4 * (j + 1LL) + a1) )
{
v8 = *(_DWORD *)(4LL * j + a1);
*(_DWORD *)(4LL * j + a1) = *(_DWORD *)(4 * (j + 1LL) + a1);
*(_DWORD *)(a1 + 4 * (j + 1LL)) = v8;
}
}
}
for ( k = 0; ; ++k )
{
result = k;
if ( (int)k >= a3 )
break;
*(_DWORD *)(4LL * (int)k + a4) = *(_DWORD *)(4LL * (int)(a2 - a3 + k) + a1);
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x20],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0010124c
LAB_0010118b:
MOV dword ptr [RBP + -0xc],0x0
JMP 0x00101236
LAB_00101197:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
ADD RAX,0x1
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JLE 0x00101232
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0xc]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
LAB_00101232:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101236:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0x10]
SUB EAX,0x1
CMP dword ptr [RBP + -0xc],EAX
JL 0x00101197
ADD dword ptr [RBP + -0x10],0x1
LAB_0010124c:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x10],EAX
JL 0x0010118b
MOV dword ptr [RBP + -0x8],0x0
JMP 0x0010129f
LAB_00101264:
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,dword ptr [RBP + -0x20]
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,EDX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x28]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0x8],0x1
LAB_0010129f:
MOV EAX,dword ptr [RBP + -0x8]
CMP EAX,dword ptr [RBP + -0x20]
JL 0x00101264
NOP
NOP
POP RBP
RET
|
void func0(long param_1,int param_2,int param_3,long param_4)
{
int4 uVar1;
int4 local_18;
int4 local_14;
int4 local_10;
for (local_18 = 0; local_18 < param_2 + -1; local_18 = local_18 + 1) {
for (local_14 = 0; local_14 < (param_2 - local_18) + -1; local_14 = local_14 + 1) {
if (*(int *)(param_1 + ((long)local_14 + 1) * 4) < *(int *)(param_1 + (long)local_14 * 4)) {
uVar1 = *(int4 *)(param_1 + (long)local_14 * 4);
*(int4 *)(param_1 + (long)local_14 * 4) =
*(int4 *)(param_1 + ((long)local_14 + 1) * 4);
*(int4 *)(((long)local_14 + 1) * 4 + param_1) = uVar1;
}
}
}
for (local_10 = 0; local_10 < param_3; local_10 = local_10 + 1) {
*(int4 *)(param_4 + (long)local_10 * 4) =
*(int4 *)(param_1 + (long)(local_10 + (param_2 - param_3)) * 4);
}
return;
}
|
1,137 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < k; i++) {
out[i] = arr[arr_size - k + i];
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
assert(issame(out1, expected1, 3));
int arr2[] = {4, -4, 4};
int out2[2];
func0(arr2, 3, 2, out2);
int expected2[] = {4, 4};
assert(issame(out2, expected2, 2));
int arr3[] = {-3, 2, 1, 2, -1, -2, 1};
int out3[1];
func0(arr3, 7, 1, out3);
int expected3[] = {2};
assert(issame(out3, expected3, 1));
int arr4[] = {123, -123, 20, 0, 1, 2, -3};
int out4[3];
func0(arr4, 7, 3, out4);
int expected4[] = {2, 20, 123};
assert(issame(out4, expected4, 3));
int arr5[] = {-123, 20, 0, 1, 2, -3};
int out5[4];
func0(arr5, 6, 4, out5);
int expected5[] = {0, 1, 2, 20};
assert(issame(out5, expected5, 4));
int arr6[] = {5, 15, 0, 3, -13, -8, 0};
int out6[7];
func0(arr6, 7, 7, out6);
int expected6[] = {-13, -8, 0, 0, 3, 5, 15};
assert(issame(out6, expected6, 7));
int arr7[] = {-1, 0, 2, 5, 3, -10};
int out7[2];
func0(arr7, 6, 2, out7);
int expected7[] = {3, 5};
assert(issame(out7, expected7, 2));
int arr8[] = {1, 0, 5, -7};
int out8[1];
func0(arr8, 4, 1, out8);
int expected8[] = {5};
assert(issame(out8, expected8, 1));
int arr9[] = {4, -4};
int out9[2];
func0(arr9, 2, 2, out9);
int expected9[] = {-4, 4};
assert(issame(out9, expected9, 2));
int arr10[] = {-10, 10};
int out10[2];
func0(arr10, 2, 2, out10);
int expected10[] = {-10, 10};
assert(issame(out10, expected10, 2));
int arr11[] = {1, 2, 3, -23, 243, -400, 0};
int out11[0];
func0(arr11, 7, 0, out11); // Empty output expected
int expected11[] = {}; // Empty array
assert(issame(out11, expected11, 0));
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbx
mov %edx,%ebx
lea -0x1(%rsi),%r11d
test %r11d,%r11d
jle 11b5 <func0+0x4c>
lea 0x4(%rdi),%rdx
jmp 11a3 <func0+0x3a>
add $0x4,%rax
cmp %r10,%rax
je 119d <func0+0x34>
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 117f <func0+0x16>
mov %r9d,(%rax)
mov %r8d,0x4(%rax)
jmp 117f <func0+0x16>
sub $0x1,%r11d
je 11b5 <func0+0x4c>
test %r11d,%r11d
jle 119d <func0+0x34>
mov %rdi,%rax
lea -0x1(%r11),%r8d
lea (%rdx,%r8,4),%r10
jmp 1188 <func0+0x1f>
test %ebx,%ebx
jle 11e1 <func0+0x78>
lea -0x1(%rbx),%r8d
movslq %esi,%rsi
movslq %ebx,%rbx
sub %rbx,%rsi
lea (%rdi,%rsi,4),%rsi
mov $0x0,%eax
mov (%rsi,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %r8,%rdx
jne 11cf <func0+0x66>
pop %rbx
retq
|
func0:
endbr64
push rbx
mov r9, rdi
mov r11d, esi
mov ebx, edx
mov r10, rcx
cmp esi, 1
jle short loc_11BD
mov r8d, esi
lea rdx, [rdi+4]
jmp short loc_11AA
loc_1187:
add rax, 4
cmp rax, rdi
jz short loc_11A0
loc_1190:
mov ecx, [rax]
mov esi, [rax+4]
cmp ecx, esi
jle short loc_1187
mov [rax], esi
mov [rax+4], ecx
jmp short loc_1187
loc_11A0:
sub r8d, 1
cmp r8d, 1
jz short loc_11BD
loc_11AA:
cmp r8d, 1
jle short loc_11ED
mov rax, r9
lea ecx, [r8-2]
lea rdi, [rdx+rcx*4]
jmp short loc_1190
loc_11BD:
test ebx, ebx
jle short loc_11EB
movsxd rbx, ebx
lea rsi, ds:0[rbx*4]
movsxd r11, r11d
sub r11, rbx
lea rcx, [r9+r11*4]
mov eax, 0
loc_11DB:
mov edx, [rcx+rax]
mov [r10+rax], edx
add rax, 4
cmp rax, rsi
jnz short loc_11DB
loc_11EB:
pop rbx
retn
loc_11ED:
sub r8d, 1
jmp short loc_11AA
|
void func0(int *a1, int a2, int a3, long long a4)
{
int i; // r8d
int *v7; // rax
int v8; // ecx
int v9; // esi
long long v10; // r11
long long j; // rax
if ( a2 > 1 )
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v7 = a1;
do
{
v8 = *v7;
v9 = v7[1];
if ( *v7 > v9 )
{
*v7 = v9;
v7[1] = v8;
}
++v7;
}
while ( v7 != &a1[i - 2 + 1] );
}
}
if ( a3 > 0 )
{
v10 = a2 - (long long)a3;
for ( j = 0LL; j != a3; ++j )
*(_DWORD *)(a4 + j * 4) = a1[v10 + j];
}
}
|
func0:
ENDBR64
PUSH RBX
MOV R9,RDI
MOV R11D,ESI
MOV EBX,EDX
MOV R10,RCX
CMP ESI,0x1
JLE 0x001011bd
MOV R8D,ESI
LEA RDX,[RDI + 0x4]
JMP 0x001011aa
LAB_00101187:
ADD RAX,0x4
CMP RAX,RDI
JZ 0x001011a0
LAB_00101190:
MOV ECX,dword ptr [RAX]
MOV ESI,dword ptr [RAX + 0x4]
CMP ECX,ESI
JLE 0x00101187
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],ECX
JMP 0x00101187
LAB_001011a0:
SUB R8D,0x1
CMP R8D,0x1
JZ 0x001011bd
LAB_001011aa:
CMP R8D,0x1
JLE 0x001011ed
MOV RAX,R9
LEA ECX,[R8 + -0x2]
LEA RDI,[RDX + RCX*0x4]
JMP 0x00101190
LAB_001011bd:
TEST EBX,EBX
JLE 0x001011eb
MOVSXD RBX,EBX
LEA RSI,[RBX*0x4]
MOVSXD R11,R11D
SUB R11,RBX
LEA RCX,[R9 + R11*0x4]
MOV EAX,0x0
LAB_001011db:
MOV EDX,dword ptr [RCX + RAX*0x1]
MOV dword ptr [R10 + RAX*0x1],EDX
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001011db
LAB_001011eb:
POP RBX
RET
LAB_001011ed:
SUB R8D,0x1
JMP 0x001011aa
|
void func0(int *param_1,int param_2,int param_3,long param_4)
{
int iVar1;
int *piVar2;
long lVar3;
int iVar4;
iVar4 = param_2;
if (1 < param_2) {
do {
for (; iVar4 < 2; iVar4 = iVar4 + -1) {
}
piVar2 = param_1;
do {
iVar1 = *piVar2;
if (piVar2[1] < iVar1) {
*piVar2 = piVar2[1];
piVar2[1] = iVar1;
}
piVar2 = piVar2 + 1;
} while (piVar2 != param_1 + (ulong)(iVar4 - 2) + 1);
iVar4 = iVar4 + -1;
} while (iVar4 != 1);
}
if (0 < param_3) {
lVar3 = 0;
do {
*(int4 *)(param_4 + lVar3) =
*(int4 *)((long)param_1 + lVar3 + ((long)param_2 - (long)param_3) * 4);
lVar3 = lVar3 + 4;
} while (lVar3 != (long)param_3 * 4);
}
return;
}
|
1,138 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < k; i++) {
out[i] = arr[arr_size - k + i];
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
assert(issame(out1, expected1, 3));
int arr2[] = {4, -4, 4};
int out2[2];
func0(arr2, 3, 2, out2);
int expected2[] = {4, 4};
assert(issame(out2, expected2, 2));
int arr3[] = {-3, 2, 1, 2, -1, -2, 1};
int out3[1];
func0(arr3, 7, 1, out3);
int expected3[] = {2};
assert(issame(out3, expected3, 1));
int arr4[] = {123, -123, 20, 0, 1, 2, -3};
int out4[3];
func0(arr4, 7, 3, out4);
int expected4[] = {2, 20, 123};
assert(issame(out4, expected4, 3));
int arr5[] = {-123, 20, 0, 1, 2, -3};
int out5[4];
func0(arr5, 6, 4, out5);
int expected5[] = {0, 1, 2, 20};
assert(issame(out5, expected5, 4));
int arr6[] = {5, 15, 0, 3, -13, -8, 0};
int out6[7];
func0(arr6, 7, 7, out6);
int expected6[] = {-13, -8, 0, 0, 3, 5, 15};
assert(issame(out6, expected6, 7));
int arr7[] = {-1, 0, 2, 5, 3, -10};
int out7[2];
func0(arr7, 6, 2, out7);
int expected7[] = {3, 5};
assert(issame(out7, expected7, 2));
int arr8[] = {1, 0, 5, -7};
int out8[1];
func0(arr8, 4, 1, out8);
int expected8[] = {5};
assert(issame(out8, expected8, 1));
int arr9[] = {4, -4};
int out9[2];
func0(arr9, 2, 2, out9);
int expected9[] = {-4, 4};
assert(issame(out9, expected9, 2));
int arr10[] = {-10, 10};
int out10[2];
func0(arr10, 2, 2, out10);
int expected10[] = {-10, 10};
assert(issame(out10, expected10, 2));
int arr11[] = {1, 2, 3, -23, 243, -400, 0};
int out11[0];
func0(arr11, 7, 0, out11); // Empty output expected
int expected11[] = {}; // Empty array
assert(issame(out11, expected11, 0));
return 0;
}
|
O2
|
c
|
func0:
endbr64
lea -0x1(%rsi),%r8d
push %rbx
mov %edx,%ebx
test %r8d,%r8d
jle 1764 <func0+0x54>
lea 0x4(%rdi),%rdx
nopl 0x0(%rax)
sub $0x1,%r8d
mov %rdi,%rax
mov %r8,%r11
lea (%rdx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 1753 <func0+0x43>
mov %r9d,(%rax)
mov %r8d,0x4(%rax)
add $0x4,%rax
cmp %rax,%r10
jne 1740 <func0+0x30>
mov %r11d,%r8d
test %r11d,%r11d
jne 1728 <func0+0x18>
test %ebx,%ebx
jle 1792 <func0+0x82>
sub %ebx,%esi
lea -0x1(%rbx),%r8d
movslq %esi,%rax
lea (%rdi,%rax,4),%rsi
xor %eax,%eax
nopw 0x0(%rax,%rax,1)
mov (%rsi,%rax,4),%edx
mov %edx,(%rcx,%rax,4)
mov %rax,%rdx
add $0x1,%rax
cmp %rdx,%r8
jne 1780 <func0+0x70>
pop %rbx
retq
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
mov r8, rdi
mov r10d, esi
mov ebx, edx
mov r9, rcx
cmp esi, 1
jle short loc_172F
mov edi, esi
lea r11, [r8+4]
nop dword ptr [rax+rax+00h]
loc_16F0:
cmp edi, 1
jle short loc_1768
lea edx, [rdi-2]
mov rax, r8
lea rsi, [r11+rdx*4]
nop
loc_1700:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd edx, xmm0
movd ecx, xmm1
cmp ecx, edx
jge short loc_171E
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_171E:
add rax, 4
cmp rax, rsi
jnz short loc_1700
sub edi, 1
cmp edi, 1
jnz short loc_16F0
loc_172F:
test ebx, ebx
jle short loc_1760
sub r10d, ebx
movsxd rcx, ebx
movsxd rax, r10d
shl rcx, 2
lea rsi, [r8+rax*4]
xor eax, eax
nop word ptr [rax+rax+00000000h]
loc_1750:
mov edx, [rsi+rax]
mov [r9+rax], edx
add rax, 4
cmp rcx, rax
jnz short loc_1750
loc_1760:
pop rbx
retn
loc_1768:
sub edi, 1
jmp short loc_16F0
|
void func0(__m128i *a1, int a2, int a3, long long a4)
{
int i; // edi
__m128i *v6; // rax
__m128i v7; // xmm0
long long j; // rax
if ( a2 > 1 )
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v6 = a1;
do
{
v7 = _mm_loadl_epi64(v6);
if ( _mm_cvtsi128_si32(_mm_shuffle_epi32(v7, 229)) < _mm_cvtsi128_si32(v7) )
v6->m128i_i64[0] = _mm_shuffle_epi32(v7, 225).m128i_u64[0];
v6 = (__m128i *)((char *)v6 + 4);
}
while ( v6 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) );
}
}
if ( a3 > 0 )
{
for ( j = 0LL; j != a3; ++j )
*(_DWORD *)(a4 + j * 4) = a1->m128i_i32[a2 - a3 + j];
}
}
|
func0:
ENDBR64
PUSH RBX
MOV R8,RDI
MOV R10D,ESI
MOV EBX,EDX
MOV R9,RCX
CMP ESI,0x1
JLE 0x0010172f
MOV EDI,ESI
LEA R11,[R8 + 0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016f0:
CMP EDI,0x1
JLE 0x00101768
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[R11 + RDX*0x4]
NOP
LAB_00101700:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD EDX,XMM0
MOVD ECX,XMM1
CMP ECX,EDX
JGE 0x0010171e
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_0010171e:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x00101700
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001016f0
LAB_0010172f:
TEST EBX,EBX
JLE 0x00101760
SUB R10D,EBX
MOVSXD RCX,EBX
MOVSXD RAX,R10D
SHL RCX,0x2
LEA RSI,[R8 + RAX*0x4]
XOR EAX,EAX
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101750:
MOV EDX,dword ptr [RSI + RAX*0x1]
MOV dword ptr [R9 + RAX*0x1],EDX
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101750
LAB_00101760:
POP RBX
RET
LAB_00101768:
SUB EDI,0x1
JMP 0x001016f0
|
void func0(int8 *param_1,int param_2,int param_3,long param_4)
{
int8 *puVar1;
long lVar2;
int iVar3;
int iVar4;
int iVar5;
iVar3 = param_2;
if (1 < param_2) {
do {
for (; iVar3 < 2; iVar3 = iVar3 + -1) {
}
puVar1 = param_1;
do {
iVar4 = (int)*puVar1;
iVar5 = (int)((ulong)*puVar1 >> 0x20);
if (iVar5 < iVar4) {
*puVar1 = CONCAT44(iVar4,iVar5);
}
puVar1 = (int8 *)((long)puVar1 + 4);
} while (puVar1 != (int8 *)((long)param_1 + (ulong)(iVar3 - 2) * 4 + 4));
iVar3 = iVar3 + -1;
} while (iVar3 != 1);
}
if (0 < param_3) {
lVar2 = 0;
do {
*(int4 *)(param_4 + lVar2) =
*(int4 *)((long)param_1 + lVar2 + (long)(param_2 - param_3) * 4);
lVar2 = lVar2 + 4;
} while ((long)param_3 * 4 != lVar2);
}
return;
}
|
1,139 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int* arr, int arr_size, int k, int* out) {
for (int i = 0; i < arr_size - 1; i++) {
for (int j = 0; j < arr_size - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
for (int i = 0; i < k; i++) {
out[i] = arr[arr_size - k + i];
}
}
|
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int arr1[] = {-3, -4, 5};
int out1[3];
func0(arr1, 3, 3, out1);
int expected1[] = {-4, -3, 5};
assert(issame(out1, expected1, 3));
int arr2[] = {4, -4, 4};
int out2[2];
func0(arr2, 3, 2, out2);
int expected2[] = {4, 4};
assert(issame(out2, expected2, 2));
int arr3[] = {-3, 2, 1, 2, -1, -2, 1};
int out3[1];
func0(arr3, 7, 1, out3);
int expected3[] = {2};
assert(issame(out3, expected3, 1));
int arr4[] = {123, -123, 20, 0, 1, 2, -3};
int out4[3];
func0(arr4, 7, 3, out4);
int expected4[] = {2, 20, 123};
assert(issame(out4, expected4, 3));
int arr5[] = {-123, 20, 0, 1, 2, -3};
int out5[4];
func0(arr5, 6, 4, out5);
int expected5[] = {0, 1, 2, 20};
assert(issame(out5, expected5, 4));
int arr6[] = {5, 15, 0, 3, -13, -8, 0};
int out6[7];
func0(arr6, 7, 7, out6);
int expected6[] = {-13, -8, 0, 0, 3, 5, 15};
assert(issame(out6, expected6, 7));
int arr7[] = {-1, 0, 2, 5, 3, -10};
int out7[2];
func0(arr7, 6, 2, out7);
int expected7[] = {3, 5};
assert(issame(out7, expected7, 2));
int arr8[] = {1, 0, 5, -7};
int out8[1];
func0(arr8, 4, 1, out8);
int expected8[] = {5};
assert(issame(out8, expected8, 1));
int arr9[] = {4, -4};
int out9[2];
func0(arr9, 2, 2, out9);
int expected9[] = {-4, 4};
assert(issame(out9, expected9, 2));
int arr10[] = {-10, 10};
int out10[2];
func0(arr10, 2, 2, out10);
int expected10[] = {-10, 10};
assert(issame(out10, expected10, 2));
int arr11[] = {1, 2, 3, -23, 243, -400, 0};
int out11[0];
func0(arr11, 7, 0, out11); // Empty output expected
int expected11[] = {}; // Empty array
assert(issame(out11, expected11, 0));
return 0;
}
|
O3
|
c
|
func0:
endbr64
lea -0x1(%rsi),%r8d
push %rbx
mov %edx,%ebx
test %r8d,%r8d
jle 1734 <func0+0x54>
lea 0x4(%rdi),%rdx
nopl 0x0(%rax)
sub $0x1,%r8d
mov %rdi,%rax
mov %r8,%r11
lea (%rdx,%r8,4),%r10
nopw %cs:0x0(%rax,%rax,1)
mov (%rax),%r8d
mov 0x4(%rax),%r9d
cmp %r9d,%r8d
jle 1723 <func0+0x43>
mov %r9d,(%rax)
mov %r8d,0x4(%rax)
add $0x4,%rax
cmp %r10,%rax
jne 1710 <func0+0x30>
mov %r11d,%r8d
test %r11d,%r11d
jne 16f8 <func0+0x18>
test %ebx,%ebx
jle 17da <func0+0xfa>
sub %ebx,%esi
lea -0x1(%rbx),%eax
movslq %esi,%r8
lea (%rdi,%r8,4),%rdx
lea 0x10(%rdi,%r8,4),%r8
cmp %r8,%rcx
lea 0x10(%rcx),%r8
setae %r9b
cmp %r8,%rdx
setae %r8b
or %r8b,%r9b
je 17dc <func0+0xfc>
cmp $0x3,%eax
jbe 17dc <func0+0xfc>
mov %ebx,%r8d
xor %eax,%eax
shr $0x2,%r8d
shl $0x4,%r8
nopw %cs:0x0(%rax,%rax,1)
movdqu (%rdx,%rax,1),%xmm0
movups %xmm0,(%rcx,%rax,1)
add $0x10,%rax
cmp %r8,%rax
jne 1780 <func0+0xa0>
mov %ebx,%eax
and $0xfffffffc,%eax
test $0x3,%bl
je 17da <func0+0xfa>
lea (%rsi,%rax,1),%edx
movslq %edx,%rdx
mov (%rdi,%rdx,4),%r8d
mov %eax,%edx
mov %r8d,(%rcx,%rdx,4)
lea 0x1(%rax),%edx
cmp %edx,%ebx
jle 17da <func0+0xfa>
lea (%rdx,%rsi,1),%r8d
add $0x2,%eax
movslq %edx,%rdx
movslq %r8d,%r8
mov (%rdi,%r8,4),%r8d
mov %r8d,(%rcx,%rdx,4)
cmp %eax,%ebx
jle 17da <func0+0xfa>
lea (%rsi,%rax,1),%edx
cltq
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
mov %edx,(%rcx,%rax,4)
pop %rbx
retq
mov %eax,%esi
xor %eax,%eax
mov (%rdx,%rax,4),%edi
mov %edi,(%rcx,%rax,4)
mov %rax,%rdi
add $0x1,%rax
cmp %rsi,%rdi
jne 17e0 <func0+0x100>
pop %rbx
retq
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
movsxd r10, esi
push rbx
mov r8, rdi
mov r11d, edx
mov r9, rcx
cmp r10d, 1
jle short loc_16F7
mov edi, r10d
lea rbx, [r8+4]
xchg ax, ax
loc_16B0:
cmp edi, 1
jle loc_1758
lea edx, [rdi-2]
mov rax, r8
lea rsi, [rbx+rdx*4]
nop dword ptr [rax+rax+00h]
loc_16C8:
movq xmm0, qword ptr [rax]
pshufd xmm1, xmm0, 0E5h
movd ecx, xmm0
movd edx, xmm1
cmp ecx, edx
jle short loc_16E6
pshufd xmm0, xmm0, 0E1h
movq qword ptr [rax], xmm0
loc_16E6:
add rax, 4
cmp rax, rsi
jnz short loc_16C8
sub edi, 1
cmp edi, 1
jnz short loc_16B0
loc_16F7:
test r11d, r11d
jle short loc_1750
mov esi, r10d
lea eax, [r11-1]
movsxd rcx, r11d
sub esi, r11d
cmp eax, 2
jbe short loc_1729
sub r10, rcx
mov rdx, r9
lea rax, ds:4[r10*4]
lea rdi, [r8+rax]
sub rdx, rdi
cmp rdx, 8
ja short loc_1760
loc_1729:
movsxd rsi, esi
shl rcx, 2
xor eax, eax
lea rsi, [r8+rsi*4]
nop word ptr [rax+rax+00000000h]
loc_1740:
mov edx, [rsi+rax]
mov [r9+rax], edx
add rax, 4
cmp rcx, rax
jnz short loc_1740
loc_1750:
pop rbx
retn
loc_1758:
sub edi, 1
jmp loc_16B0
loc_1760:
mov edx, r11d
lea rcx, [r8+rax-4]
xor eax, eax
shr edx, 2
shl rdx, 4
nop dword ptr [rax+00000000h]
loc_1778:
movdqu xmm2, xmmword ptr [rcx+rax]
movups xmmword ptr [r9+rax], xmm2
add rax, 10h
cmp rax, rdx
jnz short loc_1778
mov eax, r11d
and eax, 0FFFFFFFCh
test r11b, 3
jz short loc_1750
lea edx, [rsi+rax]
mov ecx, eax
movsxd rdx, edx
lea rdi, ds:0[rcx*4]
mov edx, [r8+rdx*4]
mov [r9+rcx*4], edx
lea edx, [rax+1]
cmp r11d, edx
jle short loc_1750
add edx, esi
add eax, 2
movsxd rdx, edx
mov edx, [r8+rdx*4]
mov [r9+rdi+4], edx
cmp r11d, eax
jle short loc_1750
add eax, esi
cdqe
mov eax, [r8+rax*4]
mov [r9+rdi+8], eax
pop rbx
retn
|
void func0(__m128i *a1, int a2, int a3, long long a4)
{
long long v4; // r10
int i; // edi
__m128i *v8; // rax
__m128i v9; // xmm0
int v10; // esi
long long v11; // r10
long long v12; // rax
__int8 *v13; // rsi
long long v14; // rax
unsigned int v15; // eax
long long v16; // rdi
unsigned int v17; // edx
int v18; // eax
v4 = a2;
if ( a2 > 1 )
{
for ( i = a2; i != 1; --i )
{
while ( i <= 1 )
--i;
v8 = a1;
do
{
v9 = _mm_loadl_epi64(v8);
if ( _mm_cvtsi128_si32(v9) > _mm_cvtsi128_si32(_mm_shuffle_epi32(v9, 229)) )
v8->m128i_i64[0] = _mm_shuffle_epi32(v9, 225).m128i_u64[0];
v8 = (__m128i *)((char *)v8 + 4);
}
while ( v8 != (__m128i *)((char *)a1->m128i_i64 + 4 * (unsigned int)(i - 2) + 4) );
}
}
if ( a3 > 0 )
{
v10 = a2 - a3;
if ( (unsigned int)(a3 - 1) > 2
&& (v11 = v4 - a3, (unsigned long long)(a4 - ((_QWORD)a1->m128i_i64 + 4 * v11 + 4)) > 8) )
{
v14 = 0LL;
do
{
*(__m128i *)(a4 + v14) = _mm_loadu_si128((__m128i *)((char *)a1 + 4 * v11 + v14));
v14 += 16LL;
}
while ( v14 != 16LL * ((unsigned int)a3 >> 2) );
v15 = a3 & 0xFFFFFFFC;
if ( (a3 & 3) != 0 )
{
v16 = 4LL * v15;
*(_DWORD *)(a4 + v16) = a1->m128i_i32[v10 + v15];
v17 = v15 + 1;
if ( a3 > (int)(v15 + 1) )
{
v18 = v15 + 2;
*(_DWORD *)(a4 + v16 + 4) = a1->m128i_i32[v10 + v17];
if ( a3 > v18 )
*(_DWORD *)(a4 + v16 + 8) = a1->m128i_i32[v10 + v18];
}
}
}
else
{
v12 = 0LL;
v13 = &a1->m128i_i8[4 * v10];
do
{
*(_DWORD *)(a4 + v12) = *(_DWORD *)&v13[v12];
v12 += 4LL;
}
while ( 4LL * a3 != v12 );
}
}
}
|
func0:
ENDBR64
MOVSXD R10,ESI
PUSH RBX
MOV R8,RDI
MOV R11D,EDX
MOV R9,RCX
CMP R10D,0x1
JLE 0x001016f7
MOV EDI,R10D
LEA RBX,[R8 + 0x4]
NOP
LAB_001016b0:
CMP EDI,0x1
JLE 0x00101758
LEA EDX,[RDI + -0x2]
MOV RAX,R8
LEA RSI,[RBX + RDX*0x4]
NOP dword ptr [RAX + RAX*0x1]
LAB_001016c8:
MOVQ XMM0,qword ptr [RAX]
PSHUFD XMM1,XMM0,0xe5
MOVD ECX,XMM0
MOVD EDX,XMM1
CMP ECX,EDX
JLE 0x001016e6
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [RAX],XMM0
LAB_001016e6:
ADD RAX,0x4
CMP RAX,RSI
JNZ 0x001016c8
SUB EDI,0x1
CMP EDI,0x1
JNZ 0x001016b0
LAB_001016f7:
TEST R11D,R11D
JLE 0x00101750
MOV ESI,R10D
LEA EAX,[R11 + -0x1]
MOVSXD RCX,R11D
SUB ESI,R11D
CMP EAX,0x2
JBE 0x00101729
SUB R10,RCX
MOV RDX,R9
LEA RAX,[0x4 + R10*0x4]
LEA RDI,[R8 + RAX*0x1]
SUB RDX,RDI
CMP RDX,0x8
JA 0x00101760
LAB_00101729:
MOVSXD RSI,ESI
SHL RCX,0x2
XOR EAX,EAX
LEA RSI,[R8 + RSI*0x4]
NOP word ptr CS:[RAX + RAX*0x1]
LAB_00101740:
MOV EDX,dword ptr [RSI + RAX*0x1]
MOV dword ptr [R9 + RAX*0x1],EDX
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x00101740
LAB_00101750:
POP RBX
RET
LAB_00101758:
SUB EDI,0x1
JMP 0x001016b0
LAB_00101760:
MOV EDX,R11D
LEA RCX,[R8 + RAX*0x1 + -0x4]
XOR EAX,EAX
SHR EDX,0x2
SHL RDX,0x4
NOP dword ptr [RAX]
LAB_00101778:
MOVDQU XMM2,xmmword ptr [RCX + RAX*0x1]
MOVUPS xmmword ptr [R9 + RAX*0x1],XMM2
ADD RAX,0x10
CMP RAX,RDX
JNZ 0x00101778
MOV EAX,R11D
AND EAX,0xfffffffc
TEST R11B,0x3
JZ 0x00101750
LEA EDX,[RSI + RAX*0x1]
MOV ECX,EAX
MOVSXD RDX,EDX
LEA RDI,[RCX*0x4]
MOV EDX,dword ptr [R8 + RDX*0x4]
MOV dword ptr [R9 + RCX*0x4],EDX
LEA EDX,[RAX + 0x1]
CMP R11D,EDX
JLE 0x00101750
ADD EDX,ESI
ADD EAX,0x2
MOVSXD RDX,EDX
MOV EDX,dword ptr [R8 + RDX*0x4]
MOV dword ptr [R9 + RDI*0x1 + 0x4],EDX
CMP R11D,EAX
JLE 0x00101750
ADD EAX,ESI
CDQE
MOV EAX,dword ptr [R8 + RAX*0x4]
MOV dword ptr [R9 + RDI*0x1 + 0x8],EAX
POP RBX
RET
|
void func0(int8 *param_1,int param_2,uint param_3,long param_4)
{
int8 uVar1;
uint uVar2;
int8 *puVar3;
long lVar4;
long lVar5;
int iVar6;
int iVar7;
int iVar8;
iVar6 = param_2;
if (1 < param_2) {
do {
for (; iVar6 < 2; iVar6 = iVar6 + -1) {
}
puVar3 = param_1;
do {
iVar7 = (int)*puVar3;
iVar8 = (int)((ulong)*puVar3 >> 0x20);
if (iVar8 < iVar7) {
*puVar3 = CONCAT44(iVar7,iVar8);
}
puVar3 = (int8 *)((long)puVar3 + 4);
} while (puVar3 != (int8 *)((long)param_1 + (ulong)(iVar6 - 2) * 4 + 4));
iVar6 = iVar6 + -1;
} while (iVar6 != 1);
}
if (0 < (int)param_3) {
iVar6 = param_2 - param_3;
if ((param_3 - 1 < 3) ||
(lVar4 = ((long)param_2 - (long)(int)param_3) * 4,
(ulong)(param_4 - ((long)param_1 + lVar4 + 4)) < 9)) {
lVar4 = 0;
do {
*(int4 *)(param_4 + lVar4) = *(int4 *)((long)param_1 + lVar4 + (long)iVar6 * 4);
lVar4 = lVar4 + 4;
} while ((long)(int)param_3 * 4 != lVar4);
}
else {
lVar5 = 0;
do {
puVar3 = (int8 *)((long)param_1 + lVar5 + lVar4);
uVar1 = puVar3[1];
*(int8 *)(param_4 + lVar5) = *puVar3;
((int8 *)(param_4 + lVar5))[1] = uVar1;
lVar5 = lVar5 + 0x10;
} while (lVar5 != (ulong)(param_3 >> 2) << 4);
uVar2 = param_3 & 0xfffffffc;
if ((param_3 & 3) != 0) {
lVar4 = (ulong)uVar2 * 4;
*(int4 *)(param_4 + (ulong)uVar2 * 4) =
*(int4 *)((long)param_1 + (long)(int)(iVar6 + uVar2) * 4);
if ((int)(uVar2 + 1) < (int)param_3) {
*(int4 *)(param_4 + 4 + lVar4) =
*(int4 *)((long)param_1 + (long)(int)(uVar2 + 1 + iVar6) * 4);
if ((int)(uVar2 + 2) < (int)param_3) {
*(int4 *)(param_4 + 8 + lVar4) =
*(int4 *)((long)param_1 + (long)(int)(uVar2 + 2 + iVar6) * 4);
return;
}
}
}
}
}
return;
}
|
1,140 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[] = {2, 4, 8};
assert(func0(test5, 3) == 0);
int test6[] = {30, 13, 23, 32};
assert(func0(test6, 4) == 23);
int test7[] = {3, 13, 2, 9};
assert(func0(test7, 4) == 3);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11cf <func0+0x66>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 11cb <func0+0x62>
mov -0x4(%rbp),%eax
add %eax,%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
add %eax,%eax
cmp %eax,-0x1c(%rbp)
jg 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11D5
loc_1188:
mov eax, [rbp+var_4]
add eax, eax
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_11D1
mov eax, [rbp+var_4]
add eax, eax
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11D1:
add [rbp+var_4], 1
loc_11D5:
mov eax, [rbp+var_4]
add eax, eax
cmp [rbp+var_1C], eax
jg short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; a2 > 2 * i; ++i )
{
if ( *(_DWORD *)(8LL * i + a1) % 2 == 1 )
v3 += *(_DWORD *)(8LL * i + a1);
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011d5
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x001011d1
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011d1:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,EAX
CMP dword ptr [RBP + -0x1c],EAX
JG 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c * 2 < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)(local_c * 2) * 4) % 2 == 1) {
local_10 = local_10 + *(int *)(param_1 + (long)(local_c * 2) * 4);
}
}
return local_10;
}
|
1,141 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[] = {2, 4, 8};
assert(func0(test5, 3) == 0);
int test6[] = {30, 13, 23, 32};
assert(func0(test6, 4) == 23);
int test7[] = {3, 13, 2, 9};
assert(func0(test7, 4) == 3);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11a8 <func0+0x3f>
mov %rdi,%rcx
sub $0x1,%esi
shr %esi
mov %esi,%esi
lea 0x8(%rdi,%rsi,8),%r8
mov $0x0,%esi
mov (%rcx),%eax
mov %eax,%edi
shr $0x1f,%edi
lea (%rax,%rdi,1),%edx
and $0x1,%edx
sub %edi,%edx
add %esi,%eax
cmp $0x1,%edx
cmove %eax,%esi
add $0x8,%rcx
cmp %r8,%rcx
jne 1185 <func0+0x1c>
mov %esi,%eax
retq
mov $0x0,%esi
jmp 11a5 <func0+0x3c>
|
func0:
endbr64
test esi, esi
jle short loc_11A8
mov rcx, rdi
sub esi, 1
shr esi, 1
mov esi, esi
lea r8, [rdi+rsi*8+8]
mov esi, 0
loc_1185:
mov eax, [rcx]
mov edi, eax
shr edi, 1Fh
lea edx, [rax+rdi]
and edx, 1
sub edx, edi
add eax, esi
cmp edx, 1
cmovz esi, eax
add rcx, 8
cmp rcx, r8
jnz short loc_1185
loc_11A5:
mov eax, esi
retn
loc_11A8:
mov esi, 0
jmp short loc_11A5
|
long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rcx
long long v3; // r8
unsigned int v4; // esi
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = (long long)&a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
v4 = 0;
do
{
if ( *v2 % 2 == 1 )
v4 += *v2;
v2 += 2;
}
while ( v2 != (_DWORD *)v3 );
}
return v4;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011a8
MOV RCX,RDI
SUB ESI,0x1
SHR ESI,0x1
MOV ESI,ESI
LEA R8,[RDI + RSI*0x8 + 0x8]
MOV ESI,0x0
LAB_00101185:
MOV EAX,dword ptr [RCX]
MOV EDI,EAX
SHR EDI,0x1f
LEA EDX,[RAX + RDI*0x1]
AND EDX,0x1
SUB EDX,EDI
ADD EAX,ESI
CMP EDX,0x1
CMOVZ ESI,EAX
ADD RCX,0x8
CMP RCX,R8
JNZ 0x00101185
LAB_001011a5:
MOV EAX,ESI
RET
LAB_001011a8:
MOV ESI,0x0
JMP 0x001011a5
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
iVar2 = 0;
do {
if (*param_1 % 2 == 1) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
}
return iVar2;
}
|
1,142 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[] = {2, 4, 8};
assert(func0(test5, 3) == 0);
int test6[] = {30, 13, 23, 32};
assert(func0(test6, 4) == 23);
int test7[] = {3, 13, 2, 9};
assert(func0(test7, 4) == 3);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
sub $0x1,%esi
xor %r8d,%r8d
shr %esi
lea 0x8(%rdi,%rsi,8),%rsi
nopl (%rax)
mov (%rdi),%eax
mov %eax,%ecx
shr $0x1f,%ecx
lea (%rax,%rcx,1),%edx
add %r8d,%eax
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
cmove %eax,%r8d
add $0x8,%rdi
cmp %rsi,%rdi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
xchg %ax,%ax
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_13D0
sub esi, 1
xor ecx, ecx
shr esi, 1
lea r8, [rdi+rsi*8+8]
nop dword ptr [rax+00h]
loc_13A8:
mov eax, [rdi]
mov esi, eax
shr esi, 1Fh
lea edx, [rax+rsi]
add eax, ecx
and edx, 1
sub edx, esi
cmp edx, 1
cmovz ecx, eax
add rdi, 8
cmp rdi, r8
jnz short loc_13A8
mov eax, ecx
retn
loc_13D0:
xor ecx, ecx
mov eax, ecx
retn
|
long long func0(_DWORD *a1, int a2)
{
unsigned int v2; // ecx
long long v3; // r8
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = (long long)&a1[2 * ((unsigned int)(a2 - 1) >> 1) + 2];
do
{
if ( *a1 % 2 == 1 )
v2 += *a1;
a1 += 2;
}
while ( a1 != (_DWORD *)v3 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001013d0
SUB ESI,0x1
XOR ECX,ECX
SHR ESI,0x1
LEA R8,[RDI + RSI*0x8 + 0x8]
NOP dword ptr [RAX]
LAB_001013a8:
MOV EAX,dword ptr [RDI]
MOV ESI,EAX
SHR ESI,0x1f
LEA EDX,[RAX + RSI*0x1]
ADD EAX,ECX
AND EDX,0x1
SUB EDX,ESI
CMP EDX,0x1
CMOVZ ECX,EAX
ADD RDI,0x8
CMP RDI,R8
JNZ 0x001013a8
MOV EAX,ECX
RET
LAB_001013d0:
XOR ECX,ECX
MOV EAX,ECX
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1 + (ulong)(param_2 - 1U >> 1) * 2 + 2;
do {
if (*param_1 % 2 == 1) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 2;
} while (param_1 != piVar1);
return iVar2;
}
return 0;
}
|
1,143 |
func0
|
#include <stdio.h>
|
int func0(int* lst, int size) {
int sum = 0;
for (int i = 0; i * 2 < size; i++)
if (lst[i * 2] % 2 == 1) sum += lst[i * 2];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {5, 8, 7, 1};
assert(func0(test1, 4) == 12);
int test2[] = {3, 3, 3, 3, 3};
assert(func0(test2, 5) == 9);
int test3[] = {30, 13, 24, 321};
assert(func0(test3, 4) == 0);
int test4[] = {5, 9};
assert(func0(test4, 2) == 5);
int test5[] = {2, 4, 8};
assert(func0(test5, 3) == 0);
int test6[] = {30, 13, 23, 32};
assert(func0(test6, 4) == 23);
int test7[] = {3, 13, 2, 9};
assert(func0(test7, 4) == 3);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1270 <func0+0x130>
lea -0x1(%rsi),%edx
cmp $0x7,%edx
jbe 1273 <func0+0x133>
shr $0x3,%edx
movdqa 0xead(%rip),%xmm4
mov %rdi,%rax
pxor %xmm2,%xmm2
mov %edx,%ecx
shl $0x5,%rcx
add %rdi,%rcx
nopl 0x0(%rax,%rax,1)
movdqu (%rax),%xmm1
movdqu 0x10(%rax),%xmm5
add $0x20,%rax
shufps $0x88,%xmm5,%xmm1
movdqa %xmm1,%xmm3
movdqa %xmm1,%xmm0
psrld $0x1f,%xmm3
paddd %xmm3,%xmm0
pand %xmm4,%xmm0
psubd %xmm3,%xmm0
pcmpeqd %xmm4,%xmm0
pand %xmm1,%xmm0
paddd %xmm0,%xmm2
cmp %rcx,%rax
jne 1178 <func0+0x38>
movdqa %xmm2,%xmm0
lea 0x0(,%rdx,4),%r9d
shl $0x3,%edx
psrldq $0x8,%xmm0
paddd %xmm0,%xmm2
movdqa %xmm2,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm2
movd %xmm2,%eax
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
mov %edx,%r8d
shr $0x1f,%r8d
lea (%rdx,%r8,1),%ecx
add %eax,%edx
and $0x1,%ecx
sub %r8d,%ecx
cmp $0x1,%ecx
cmove %edx,%eax
lea 0x2(%r9,%r9,1),%edx
cmp %esi,%edx
jge 1272 <func0+0x132>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
mov %ecx,%r9d
shr $0x1f,%r9d
lea (%rcx,%r9,1),%r8d
add %eax,%ecx
and $0x1,%r8d
sub %r9d,%r8d
cmp $0x1,%r8d
cmove %ecx,%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 1272 <func0+0x132>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
mov %ecx,%r9d
shr $0x1f,%r9d
lea (%rcx,%r9,1),%r8d
add %eax,%ecx
and $0x1,%r8d
sub %r9d,%r8d
cmp $0x1,%r8d
cmove %ecx,%eax
add $0x4,%edx
cmp %edx,%esi
jle 1272 <func0+0x132>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
mov %edx,%esi
shr $0x1f,%esi
lea (%rdx,%rsi,1),%ecx
add %eax,%edx
and $0x1,%ecx
sub %esi,%ecx
cmp $0x1,%ecx
cmove %edx,%eax
retq
xor %eax,%eax
retq
xor %r9d,%r9d
xor %eax,%eax
xor %edx,%edx
jmpq 11dc <func0+0x9c>
|
func0:
endbr64
test esi, esi
jle loc_1298
lea edx, [rsi-1]
mov r9d, edx
shr r9d, 1
cmp edx, 7
jbe loc_129B
shr edx, 3
movdqa xmm4, cs:xmmword_2010
mov rax, rdi
pxor xmm2, xmm2
mov ecx, edx
shl rcx, 5
add rcx, rdi
nop dword ptr [rax+00000000h]
loc_1180:
movdqu xmm1, xmmword ptr [rax]
movdqu xmm5, xmmword ptr [rax+10h]
add rax, 20h ; ' '
shufps xmm1, xmm5, 88h
movdqa xmm3, xmm1
movdqa xmm0, xmm1
psrld xmm3, 1Fh
paddd xmm0, xmm3
pand xmm0, xmm4
psubd xmm0, xmm3
pcmpeqd xmm0, xmm4
pand xmm0, xmm1
paddd xmm2, xmm0
cmp rcx, rax
jnz short loc_1180
movdqa xmm0, xmm2
lea ecx, ds:0[rdx*4]
shl edx, 3
psrldq xmm0, 8
mov r8d, ecx
paddd xmm0, xmm2
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movhlps xmm1, xmm2
paddd xmm1, xmm2
movd eax, xmm0
loc_11ED:
sub r9d, ecx
cmp r9d, 1
jbe short loc_1251
lea rax, [rdi+rcx*8]
pxor xmm2, xmm2
and r9d, 0FFFFFFFEh
movq xmm4, qword ptr cs:xmmword_2010
movq xmm0, qword ptr [rax+8]
movq xmm3, qword ptr [rax]
lea edx, [rdx+r9*2]
add r8d, r9d
punpckldq xmm3, xmm0
pcmpgtd xmm2, xmm3
movdqa xmm0, xmm3
pand xmm2, xmm4
paddd xmm0, xmm2
pand xmm0, xmm4
psubd xmm0, xmm2
pcmpeqd xmm0, xmm4
pand xmm0, xmm3
paddd xmm0, xmm1
movd eax, xmm0
pshufd xmm6, xmm0, 0E5h
movd ecx, xmm6
add eax, ecx
loc_1251:
movsxd rdx, edx
mov edx, [rdi+rdx*4]
mov r9d, edx
shr r9d, 1Fh
lea ecx, [rdx+r9]
add edx, eax
and ecx, 1
sub ecx, r9d
cmp ecx, 1
cmovz eax, edx
lea edx, [r8+r8+2]
cmp esi, edx
jle short locret_129A
movsxd rdx, edx
mov edx, [rdi+rdx*4]
mov esi, edx
shr esi, 1Fh
lea ecx, [rdx+rsi]
add edx, eax
and ecx, 1
sub ecx, esi
cmp ecx, 1
cmovz eax, edx
retn
loc_1298:
xor eax, eax
locret_129A:
retn
loc_129B:
pxor xmm1, xmm1
xor ecx, ecx
xor r8d, r8d
xor eax, eax
xor edx, edx
jmp loc_11ED
|
long long func0(const __m128i *a1, int a2)
{
unsigned int v2; // edx
__m128i si128; // xmm4
const __m128i *v4; // rax
__m128 v5; // xmm2
__m128 v6; // xmm1
__m128 v7; // xmm5
__m128i v8; // xmm1
__m128i v9; // xmm3
long long v10; // rcx
int v11; // edx
int v12; // r8d
__m128i v13; // xmm0
__m128 v14; // xmm1
__m128i v15; // xmm0
__m128i v16; // xmm1
long long result; // rax
unsigned int v18; // r9d
unsigned int v19; // r9d
__m128i v20; // xmm4
__m128i v21; // xmm3
__m128i v22; // xmm2
__m128i v23; // xmm0
int v24; // edx
unsigned int v25; // r9d
char v26; // cl
unsigned int v27; // edx
int v28; // edx
int v29; // edx
unsigned int v30; // esi
char v31; // cl
unsigned int v32; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 7 )
{
v16 = 0LL;
v10 = 0LL;
v12 = 0;
result = 0LL;
v11 = 0;
}
else
{
v2 = (unsigned int)(a2 - 1) >> 3;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v4 = a1;
v5 = 0LL;
do
{
v6 = (__m128)_mm_loadu_si128(v4);
v7 = (__m128)_mm_loadu_si128(v4 + 1);
v4 += 2;
v8 = (__m128i)_mm_shuffle_ps(v6, v7, 136);
v9 = _mm_srli_epi32(v8, 0x1Fu);
v5 = (__m128)_mm_add_epi32(
(__m128i)v5,
_mm_and_si128(
_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v8, v9), si128), v9), si128),
v8));
}
while ( &a1[2 * v2] != v4 );
v10 = 2 * v2;
v11 = 8 * v2;
v12 = v10 * 2;
v13 = _mm_add_epi32(_mm_srli_si128((__m128i)v5, 8), (__m128i)v5);
v14 = (__m128)_mm_srli_si128(v13, 4);
v15 = _mm_add_epi32(v13, (__m128i)v14);
v16 = _mm_add_epi32((__m128i)_mm_movehl_ps(v14, v5), (__m128i)v5);
result = (unsigned int)_mm_cvtsi128_si32(v15);
}
v18 = ((unsigned int)(a2 - 1) >> 1) - v10 * 2;
if ( v18 > 1 )
{
v19 = v18 & 0xFFFFFFFE;
v20 = _mm_loadl_epi64((const __m128i *)&xmmword_2010);
v11 += 2 * v19;
v12 += v19;
v21 = _mm_unpacklo_epi32(_mm_loadl_epi64(&a1[v10]), _mm_loadl_epi64((const __m128i *)&a1[v10].m128i_u64[1]));
v22 = _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v21), v20);
v23 = _mm_add_epi32(
_mm_and_si128(_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v21, v22), v20), v22), v20), v21),
v16);
result = (unsigned int)(_mm_cvtsi128_si32(_mm_shuffle_epi32(v23, 229)) + _mm_cvtsi128_si32(v23));
}
v24 = a1->m128i_i32[v11];
v25 = (unsigned int)v24 >> 31;
v26 = v24 + (v24 < 0);
v27 = result + v24;
if ( (v26 & 1) - v25 == 1 )
result = v27;
v28 = 2 * v12 + 2;
if ( a2 > v28 )
{
v29 = a1->m128i_i32[v28];
v30 = (unsigned int)v29 >> 31;
v31 = v29 + (v29 < 0);
v32 = result + v29;
if ( (v31 & 1) - v30 == 1 )
return v32;
}
return result;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101298
LEA EDX,[RSI + -0x1]
MOV R9D,EDX
SHR R9D,0x1
CMP EDX,0x7
JBE 0x0010129b
SHR EDX,0x3
MOVDQA XMM4,xmmword ptr [0x00102010]
MOV RAX,RDI
PXOR XMM2,XMM2
MOV ECX,EDX
SHL RCX,0x5
ADD RCX,RDI
NOP dword ptr [RAX]
LAB_00101180:
MOVDQU XMM1,xmmword ptr [RAX]
MOVDQU XMM5,xmmword ptr [RAX + 0x10]
ADD RAX,0x20
SHUFPS XMM1,XMM5,0x88
MOVDQA XMM3,XMM1
MOVDQA XMM0,XMM1
PSRLD XMM3,0x1f
PADDD XMM0,XMM3
PAND XMM0,XMM4
PSUBD XMM0,XMM3
PCMPEQD XMM0,XMM4
PAND XMM0,XMM1
PADDD XMM2,XMM0
CMP RCX,RAX
JNZ 0x00101180
MOVDQA XMM0,XMM2
LEA ECX,[RDX*0x4]
SHL EDX,0x3
PSRLDQ XMM0,0x8
MOV R8D,ECX
PADDD XMM0,XMM2
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVHLPS XMM1,XMM2
PADDD XMM1,XMM2
MOVD EAX,XMM0
LAB_001011ed:
SUB R9D,ECX
CMP R9D,0x1
JBE 0x00101251
LEA RAX,[RDI + RCX*0x8]
PXOR XMM2,XMM2
AND R9D,0xfffffffe
MOVQ XMM4,qword ptr [0x00102010]
MOVQ XMM0,qword ptr [RAX + 0x8]
MOVQ XMM3,qword ptr [RAX]
LEA EDX,[RDX + R9*0x2]
ADD R8D,R9D
PUNPCKLDQ XMM3,XMM0
PCMPGTD XMM2,XMM3
MOVDQA XMM0,XMM3
PAND XMM2,XMM4
PADDD XMM0,XMM2
PAND XMM0,XMM4
PSUBD XMM0,XMM2
PCMPEQD XMM0,XMM4
PAND XMM0,XMM3
PADDD XMM0,XMM1
MOVD EAX,XMM0
PSHUFD XMM6,XMM0,0xe5
MOVD ECX,XMM6
ADD EAX,ECX
LAB_00101251:
MOVSXD RDX,EDX
MOV EDX,dword ptr [RDI + RDX*0x4]
MOV R9D,EDX
SHR R9D,0x1f
LEA ECX,[RDX + R9*0x1]
ADD EDX,EAX
AND ECX,0x1
SUB ECX,R9D
CMP ECX,0x1
CMOVZ EAX,EDX
LEA EDX,[R8 + R8*0x1 + 0x2]
CMP ESI,EDX
JLE 0x0010129a
MOVSXD RDX,EDX
MOV EDX,dword ptr [RDI + RDX*0x4]
MOV ESI,EDX
SHR ESI,0x1f
LEA ECX,[RDX + RSI*0x1]
ADD EDX,EAX
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
CMOVZ EAX,EDX
RET
LAB_00101298:
XOR EAX,EAX
LAB_0010129a:
RET
LAB_0010129b:
PXOR XMM1,XMM1
XOR ECX,ECX
XOR R8D,R8D
XOR EAX,EAX
XOR EDX,EDX
JMP 0x001011ed
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,int param_2)
{
int8 uVar1;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint *puVar6;
ulong uVar7;
uint uVar8;
int iVar9;
uint uVar10;
uint uVar11;
int iVar12;
int auVar13 [16];
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int auVar18 [16];
int auVar19 [16];
if (param_2 < 1) {
iVar12 = 0;
}
else {
uVar11 = param_2 - 1;
if (uVar11 < 8) {
iVar16 = 0;
iVar17 = 0;
uVar7 = 0;
uVar10 = 0;
iVar12 = 0;
iVar9 = 0;
}
else {
uVar8 = uVar11 >> 3;
iVar14 = 0;
iVar15 = 0;
iVar16 = 0;
iVar17 = 0;
puVar6 = param_1;
do {
uVar10 = *puVar6;
uVar3 = puVar6[2];
uVar4 = puVar6[4];
uVar5 = puVar6[6];
puVar6 = puVar6 + 8;
iVar14 = iVar14 + (-(uint)((uVar10 - ((int)uVar10 >> 0x1f) & (uint)DAT_00102010) +
((int)uVar10 >> 0x1f) == (uint)DAT_00102010) & uVar10);
iVar15 = iVar15 + (-(uint)((uVar3 - ((int)uVar3 >> 0x1f) & DAT_00102010._4_4_) +
((int)uVar3 >> 0x1f) == DAT_00102010._4_4_) & uVar3);
iVar16 = iVar16 + (-(uint)((uVar4 - ((int)uVar4 >> 0x1f) & _UNK_00102018) +
((int)uVar4 >> 0x1f) == _UNK_00102018) & uVar4);
iVar17 = iVar17 + (-(uint)((uVar5 - ((int)uVar5 >> 0x1f) & _UNK_0010201c) +
((int)uVar5 >> 0x1f) == _UNK_0010201c) & uVar5);
} while (param_1 + (ulong)uVar8 * 8 != puVar6);
uVar10 = uVar8 * 4;
uVar7 = (ulong)uVar10;
iVar9 = uVar8 << 3;
iVar12 = iVar16 + iVar14 + iVar17 + iVar15;
iVar16 = iVar16 + iVar14;
iVar17 = iVar17 + iVar15;
}
uVar11 = (uVar11 >> 1) - (int)uVar7;
if (1 < uVar11) {
uVar11 = uVar11 & 0xfffffffe;
uVar1 = *(int8 *)(param_1 + uVar7 * 2 + 2);
uVar2 = *(int8 *)(param_1 + uVar7 * 2);
iVar9 = iVar9 + uVar11 * 2;
uVar10 = uVar10 + uVar11;
auVar19._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar19._0_8_ = uVar2;
auVar19._12_4_ = (int)((ulong)uVar1 >> 0x20);
iVar12 = (int)uVar1;
auVar18._8_8_ = auVar19._8_8_;
auVar18._0_4_ = (int)uVar2;
auVar18._4_4_ = iVar12;
uVar11 = -(uint)(auVar18._0_4_ < 0) & (uint)DAT_00102010;
uVar8 = -(uint)(iVar12 < 0) & DAT_00102010._4_4_;
auVar13._0_4_ =
-(uint)((auVar18._0_4_ + uVar11 & (uint)DAT_00102010) - uVar11 == (uint)DAT_00102010);
auVar13._4_4_ = -(uint)((iVar12 + uVar8 & DAT_00102010._4_4_) - uVar8 == DAT_00102010._4_4_);
auVar13._8_4_ = 0xffffffff;
auVar13._12_4_ = 0xffffffff;
iVar12 = SUB164(auVar13 & auVar18,0) + iVar16 + SUB164(auVar13 & auVar18,4) + iVar17;
}
if ((int)param_1[iVar9] % 2 == 1) {
iVar12 = param_1[iVar9] + iVar12;
}
iVar9 = uVar10 * 2 + 2;
if (iVar9 < param_2) {
if ((int)param_1[iVar9] % 2 == 1) {
iVar12 = param_1[iVar9] + iVar12;
}
return iVar12;
}
}
return iVar12;
}
|
1,144 |
func0
|
#include <stdio.h>
|
int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, 3, 4000, 5, 6, 7, 8, 9};
assert(func0(test4, 4) == 24);
int test5[] = {1};
assert(func0(test5, 1) == 1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11db <func0+0x72>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0xffffff9d,%eax
jl 11d7 <func0+0x6e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp $0x63,%eax
jg 11d7 <func0+0x6e>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1188 <func0+0x1f>
mov -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_8], 0
mov [rbp+var_4], 0
jmp short loc_11DB
loc_1188:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp eax, 0FFFFFF9Dh
jl short loc_11D7
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
cmp eax, 63h ; 'c'
jg short loc_11D7
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
add [rbp+var_8], eax
loc_11D7:
add [rbp+var_4], 1
loc_11DB:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_1188
mov eax, [rbp+var_8]
pop rbp
retn
|
long long func0(long long a1, int a2)
{
unsigned int v3; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(int *)(4LL * i + a1) >= -99 && *(int *)(4LL * i + a1) <= 99 )
v3 += *(_DWORD *)(4LL * i + a1);
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001011db
LAB_00101188:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,-0x63
JL 0x001011d7
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]
CMP EAX,0x63
JG 0x001011d7
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
ADD dword ptr [RBP + -0x8],EAX
LAB_001011d7:
ADD dword ptr [RBP + -0x4],0x1
LAB_001011db:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101188
MOV EAX,dword ptr [RBP + -0x8]
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
if ((-100 < *(int *)(param_1 + (long)local_c * 4)) &&
(*(int *)(param_1 + (long)local_c * 4) < 100)) {
local_10 = local_10 + *(int *)(param_1 + (long)local_c * 4);
}
}
return local_10;
}
|
1,145 |
func0
|
#include <stdio.h>
|
int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, 3, 4000, 5, 6, 7, 8, 9};
assert(func0(test4, 4) == 24);
int test5[] = {1};
assert(func0(test5, 1) == 1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 119d <func0+0x34>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rdi
mov $0x0,%ecx
mov (%rdx),%eax
lea 0x63(%rax),%esi
add %ecx,%eax
cmp $0xc7,%esi
cmovb %eax,%ecx
add $0x4,%rdx
cmp %rdi,%rdx
jne 1181 <func0+0x18>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 119a <func0+0x31>
|
func0:
endbr64
test esi, esi
jle short loc_119C
mov rdx, rdi
movsxd rsi, esi
lea rdi, [rdi+rsi*4]
mov ecx, 0
loc_1180:
mov eax, [rdx]
lea esi, [rax+63h]
add eax, ecx
cmp esi, 0C7h
cmovb ecx, eax
add rdx, 4
cmp rdx, rdi
jnz short loc_1180
loc_1199:
mov eax, ecx
retn
loc_119C:
mov ecx, 0
jmp short loc_1199
|
long long func0(_DWORD *a1, int a2)
{
_DWORD *v2; // rdx
_DWORD *v3; // rdi
unsigned int v4; // ecx
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
if ( (unsigned int)(*v2 + 99) < 0xC7 )
v4 += *v2;
++v2;
}
while ( v2 != v3 );
}
return v4;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x0010119c
MOV RDX,RDI
MOVSXD RSI,ESI
LEA RDI,[RDI + RSI*0x4]
MOV ECX,0x0
LAB_00101180:
MOV EAX,dword ptr [RDX]
LEA ESI,[RAX + 0x63]
ADD EAX,ECX
CMP ESI,0xc7
CMOVC ECX,EAX
ADD RDX,0x4
CMP RDX,RDI
JNZ 0x00101180
LAB_00101199:
MOV EAX,ECX
RET
LAB_0010119c:
MOV ECX,0x0
JMP 0x00101199
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (param_2 < 1) {
iVar2 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar2 = 0;
do {
if (*param_1 + 99U < 199) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar2;
}
|
1,146 |
func0
|
#include <stdio.h>
|
int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, 3, 4000, 5, 6, 7, 8, 9};
assert(func0(test4, 4) == 24);
int test5[] = {1};
assert(func0(test5, 1) == 1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 1180 <func0+0x40>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%rcx
nopl 0x0(%rax,%rax,1)
mov (%rdi),%eax
lea 0x63(%rax),%edx
add %r8d,%eax
cmp $0xc7,%edx
cmovb %eax,%r8d
add $0x4,%rdi
cmp %rcx,%rdi
jne 1158 <func0+0x18>
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1258
movsxd rsi, esi
xor edx, edx
lea rsi, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1238:
mov eax, [rdi]
lea ecx, [rax+63h]
add eax, edx
cmp ecx, 0C7h
cmovb edx, eax
add rdi, 4
cmp rsi, rdi
jnz short loc_1238
mov eax, edx
retn
loc_1258:
xor edx, edx
mov eax, edx
retn
|
long long func0(_DWORD *a1, int a2)
{
unsigned int v2; // edx
_DWORD *v3; // rsi
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
if ( (unsigned int)(*a1 + 99) < 0xC7 )
v2 += *a1;
++a1;
}
while ( v3 != a1 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101258
MOVSXD RSI,ESI
XOR EDX,EDX
LEA RSI,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101238:
MOV EAX,dword ptr [RDI]
LEA ECX,[RAX + 0x63]
ADD EAX,EDX
CMP ECX,0xc7
CMOVC EDX,EAX
ADD RDI,0x4
CMP RSI,RDI
JNZ 0x00101238
MOV EAX,EDX
RET
LAB_00101258:
XOR EDX,EDX
MOV EAX,EDX
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
if (0 < param_2) {
iVar2 = 0;
piVar1 = param_1 + param_2;
do {
if (*param_1 + 99U < 199) {
iVar2 = *param_1 + iVar2;
}
param_1 = param_1 + 1;
} while (piVar1 != param_1);
return iVar2;
}
return 0;
}
|
1,147 |
func0
|
#include <stdio.h>
|
int func0(int arr[], int k) {
int sum = 0;
for (int i = 0; i < k; i++)
if (arr[i] >= -99 && arr[i] <= 99)
sum += arr[i];
return sum;
}
|
#include <assert.h>
int main() {
int test1[] = {1, -2, -3, 41, 57, 76, 87, 88, 99};
assert(func0(test1, 3) == -4);
int test2[] = {111, 121, 3, 4000, 5, 6};
assert(func0(test2, 2) == 0);
int test3[] = {11, 21, 3, 90, 5, 6, 7, 8, 9};
assert(func0(test3, 4) == 125);
int test4[] = {111, 21, 3, 4000, 5, 6, 7, 8, 9};
assert(func0(test4, 4) == 24);
int test5[] = {1};
assert(func0(test5, 1) == 1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 1340 <func0+0x110>
lea -0x1(%rsi),%eax
cmp $0x3,%eax
jbe 1349 <func0+0x119>
mov %esi,%edx
mov %rdi,%rax
pxor %xmm1,%xmm1
movdqa 0xe37(%rip),%xmm3
movdqa 0xe1f(%rip),%xmm2
shr $0x2,%edx
movdqa 0xe04(%rip),%xmm4
shl $0x4,%rdx
add %rdi,%rdx
psubd %xmm3,%xmm2
nopw 0x0(%rax,%rax,1)
movdqu (%rax),%xmm0
movdqu (%rax),%xmm5
add $0x10,%rax
paddd %xmm4,%xmm0
psubd %xmm3,%xmm0
pcmpgtd %xmm2,%xmm0
pandn %xmm5,%xmm0
paddd %xmm0,%xmm1
cmp %rdx,%rax
jne 1280 <func0+0x50>
movdqa %xmm1,%xmm0
mov %esi,%edx
psrldq $0x8,%xmm0
and $0xfffffffc,%edx
paddd %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrldq $0x4,%xmm0
paddd %xmm0,%xmm1
movd %xmm1,%eax
test $0x3,%sil
je 1348 <func0+0x118>
movslq %edx,%rcx
mov (%rdi,%rcx,4),%ecx
lea 0x63(%rcx),%r8d
add %eax,%ecx
cmp $0xc7,%r8d
cmovb %ecx,%eax
lea 0x1(%rdx),%ecx
cmp %esi,%ecx
jge 1342 <func0+0x112>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
lea 0x63(%rcx),%r8d
add %eax,%ecx
cmp $0xc7,%r8d
cmovb %ecx,%eax
lea 0x2(%rdx),%ecx
cmp %ecx,%esi
jle 1342 <func0+0x112>
movslq %ecx,%rcx
mov (%rdi,%rcx,4),%ecx
lea 0x63(%rcx),%r8d
add %eax,%ecx
cmp $0xc7,%r8d
cmovb %ecx,%eax
add $0x3,%edx
cmp %edx,%esi
jle 1342 <func0+0x112>
movslq %edx,%rdx
mov (%rdi,%rdx,4),%edx
lea 0x63(%rdx),%ecx
add %eax,%edx
cmp $0xc7,%ecx
cmovb %edx,%eax
retq
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
retq
nopl 0x0(%rax,%rax,1)
retq
xor %edx,%edx
xor %eax,%eax
jmpq 12ce <func0+0x9e>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
mov ecx, esi
test esi, esi
jle loc_1230
lea eax, [rsi-1]
cmp eax, 2
jbe loc_1239
mov edx, esi
mov rax, rdi
pxor xmm1, xmm1
movdqa xmm4, cs:xmmword_2010
shr edx, 2
movdqa xmm3, cs:xmmword_2020
movdqa xmm2, cs:xmmword_2030
shl rdx, 4
add rdx, rdi
nop dword ptr [rax]
loc_1188:
movdqu xmm0, xmmword ptr [rax]
movdqu xmm5, xmmword ptr [rax]
add rax, 10h
paddd xmm0, xmm4
psubd xmm0, xmm3
pcmpgtd xmm0, xmm2
pandn xmm0, xmm5
paddd xmm1, xmm0
cmp rdx, rax
jnz short loc_1188
movdqa xmm0, xmm1
mov edx, ecx
psrldq xmm0, 8
and edx, 0FFFFFFFCh
paddd xmm1, xmm0
movdqa xmm0, xmm1
psrldq xmm0, 4
paddd xmm1, xmm0
movd eax, xmm1
test cl, 3
jz short locret_1238
loc_11D5:
movsxd rsi, edx
lea r8, ds:0[rsi*4]
mov esi, [rdi+rsi*4]
lea r9d, [rsi+63h]
add esi, eax
cmp r9d, 0C7h
cmovb eax, esi
lea esi, [rdx+1]
cmp ecx, esi
jle short locret_1232
mov esi, [rdi+r8+4]
lea r9d, [rsi+63h]
add esi, eax
cmp r9d, 0C7h
cmovb eax, esi
add edx, 2
cmp edx, ecx
jge short locret_1232
mov edx, [rdi+r8+8]
lea ecx, [rdx+63h]
add edx, eax
cmp ecx, 0C7h
cmovb eax, edx
retn
loc_1230:
xor eax, eax
locret_1232:
retn
locret_1238:
retn
loc_1239:
xor edx, edx
xor eax, eax
jmp short loc_11D5
|
long long func0(const __m128i *a1, int a2)
{
const __m128i *v3; // rax
__m128i v4; // xmm1
__m128i si128; // xmm4
__m128i v6; // xmm3
__m128i v7; // xmm2
__m128i v8; // xmm0
int v9; // edx
__m128i v10; // xmm1
long long result; // rax
long long v12; // r8
__int32 v13; // esi
unsigned int v14; // r9d
unsigned int v15; // esi
__int32 v16; // esi
unsigned int v17; // r9d
unsigned int v18; // esi
__int32 v19; // edx
unsigned int v20; // ecx
unsigned int v21; // edx
if ( a2 <= 0 )
return 0LL;
if ( (unsigned int)(a2 - 1) <= 2 )
{
v9 = 0;
result = 0LL;
}
else
{
v3 = a1;
v4 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_2010);
v6 = _mm_load_si128((const __m128i *)&xmmword_2020);
v7 = _mm_load_si128((const __m128i *)&xmmword_2030);
do
{
v8 = _mm_loadu_si128(v3++);
v4 = _mm_add_epi32(v4, _mm_andnot_si128(_mm_cmpgt_epi32(_mm_sub_epi32(_mm_add_epi32(v8, si128), v6), v7), v8));
}
while ( &a1[(unsigned int)a2 >> 2] != v3 );
v9 = a2 & 0x7FFFFFFC;
v10 = _mm_add_epi32(v4, _mm_srli_si128(v4, 8));
result = (unsigned int)_mm_cvtsi128_si32(_mm_add_epi32(v10, _mm_srli_si128(v10, 4)));
if ( (a2 & 3) == 0 )
return result;
}
v12 = v9;
v13 = a1->m128i_i32[v12];
v14 = v13 + 99;
v15 = result + v13;
if ( v14 < 0xC7 )
result = v15;
if ( a2 > v9 + 1 )
{
v16 = a1->m128i_i32[v12 + 1];
v17 = v16 + 99;
v18 = result + v16;
if ( v17 < 0xC7 )
result = v18;
if ( v9 + 2 < a2 )
{
v19 = a1->m128i_i32[v12 + 2];
v20 = v19 + 99;
v21 = result + v19;
if ( v20 < 0xC7 )
return v21;
}
}
return result;
}
|
func0:
ENDBR64
MOV ECX,ESI
TEST ESI,ESI
JLE 0x00101230
LEA EAX,[RSI + -0x1]
CMP EAX,0x2
JBE 0x00101239
MOV EDX,ESI
MOV RAX,RDI
PXOR XMM1,XMM1
MOVDQA XMM4,xmmword ptr [0x00102010]
SHR EDX,0x2
MOVDQA XMM3,xmmword ptr [0x00102020]
MOVDQA XMM2,xmmword ptr [0x00102030]
SHL RDX,0x4
ADD RDX,RDI
NOP dword ptr [RAX]
LAB_00101188:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQU XMM5,xmmword ptr [RAX]
ADD RAX,0x10
PADDD XMM0,XMM4
PSUBD XMM0,XMM3
PCMPGTD XMM0,XMM2
PANDN XMM0,XMM5
PADDD XMM1,XMM0
CMP RDX,RAX
JNZ 0x00101188
MOVDQA XMM0,XMM1
MOV EDX,ECX
PSRLDQ XMM0,0x8
AND EDX,0xfffffffc
PADDD XMM1,XMM0
MOVDQA XMM0,XMM1
PSRLDQ XMM0,0x4
PADDD XMM1,XMM0
MOVD EAX,XMM1
TEST CL,0x3
JZ 0x00101238
LAB_001011d5:
MOVSXD RSI,EDX
LEA R8,[RSI*0x4]
MOV ESI,dword ptr [RDI + RSI*0x4]
LEA R9D,[RSI + 0x63]
ADD ESI,EAX
CMP R9D,0xc7
CMOVC EAX,ESI
LEA ESI,[RDX + 0x1]
CMP ECX,ESI
JLE 0x00101232
MOV ESI,dword ptr [RDI + R8*0x1 + 0x4]
LEA R9D,[RSI + 0x63]
ADD ESI,EAX
CMP R9D,0xc7
CMOVC EAX,ESI
ADD EDX,0x2
CMP EDX,ECX
JGE 0x00101232
MOV EDX,dword ptr [RDI + R8*0x1 + 0x8]
LEA ECX,[RDX + 0x63]
ADD EDX,EAX
CMP ECX,0xc7
CMOVC EAX,EDX
RET
LAB_00101230:
XOR EAX,EAX
LAB_00101232:
RET
LAB_00101238:
RET
LAB_00101239:
XOR EDX,EDX
XOR EAX,EAX
JMP 0x001011d5
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int func0(uint *param_1,uint param_2)
{
uint *puVar1;
uint *puVar2;
uint *puVar3;
uint uVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *puVar8;
uint uVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
if ((int)param_2 < 1) {
iVar10 = 0;
}
else {
if (param_2 - 1 < 3) {
uVar9 = 0;
iVar10 = 0;
}
else {
iVar10 = 0;
iVar11 = 0;
iVar12 = 0;
iVar13 = 0;
puVar8 = param_1;
do {
uVar9 = *puVar8;
puVar1 = puVar8 + 1;
puVar2 = puVar8 + 2;
puVar3 = puVar8 + 3;
uVar4 = *puVar8;
puVar5 = puVar8 + 1;
puVar6 = puVar8 + 2;
puVar7 = puVar8 + 3;
puVar8 = puVar8 + 4;
iVar10 = iVar10 + (~-(uint)(_DAT_00102030 < (int)((uVar9 + _DAT_00102010) - _DAT_00102020))
& uVar4);
iVar11 = iVar11 + (~-(uint)(_UNK_00102034 < (int)((*puVar1 + _UNK_00102014) - _UNK_00102024)
) & *puVar5);
iVar12 = iVar12 + (~-(uint)(_UNK_00102038 < (int)((*puVar2 + _UNK_00102018) - _UNK_00102028)
) & *puVar6);
iVar13 = iVar13 + (~-(uint)(_UNK_0010203c < (int)((*puVar3 + _UNK_0010201c) - _UNK_0010202c)
) & *puVar7);
} while (param_1 + (ulong)(param_2 >> 2) * 4 != puVar8);
uVar9 = param_2 & 0xfffffffc;
iVar10 = iVar10 + iVar12 + iVar11 + iVar13;
if ((param_2 & 3) == 0) {
return iVar10;
}
}
if (param_1[(int)uVar9] + 99 < 199) {
iVar10 = param_1[(int)uVar9] + iVar10;
}
if ((int)(uVar9 + 1) < (int)param_2) {
if (param_1[(long)(int)uVar9 + 1] + 99 < 199) {
iVar10 = param_1[(long)(int)uVar9 + 1] + iVar10;
}
if ((int)(uVar9 + 2) < (int)param_2) {
if (param_1[(long)(int)uVar9 + 2] + 99 < 199) {
iVar10 = param_1[(long)(int)uVar9 + 2] + iVar10;
}
return iVar10;
}
}
}
return iVar10;
}
|
1,148 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++] = n;
n = n * 3 + 1;
} else {
n = n / 2;
}
}
for (int i = 1; i < *size; i++) {
int key = out[i];
int j = i - 1;
while (j >= 0 && out[j] > key) {
out[j + 1] = out[j];
j = j - 1;
}
out[j + 1] = key;
}
}
|
#include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 11, 13, 17};
result = (int*)malloc(100 * sizeof(int));
func0(14, result, &size);
assert(issame(result, size, expected1, 6));
free(result);
// Test 2
int expected2[] = {1, 5};
result = (int*)malloc(100 * sizeof(int));
func0(5, result, &size);
assert(issame(result, size, expected2, 2));
free(result);
// Test 3
int expected3[] = {1, 3, 5};
result = (int*)malloc(100 * sizeof(int));
func0(12, result, &size);
assert(issame(result, size, expected3, 3));
free(result);
// Test 4
int expected4[] = {1};
result = (int*)malloc(100 * sizeof(int));
func0(1, result, &size);
assert(issame(result, size, expected4, 1));
free(result);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %edi,-0x14(%rbp)
mov %rsi,-0x20(%rbp)
mov %rdx,-0x28(%rbp)
movl $0xa,-0x10(%rbp)
mov -0x28(%rbp),%rax
movl $0x1,(%rax)
mov -0x20(%rbp),%rax
movl $0x1,(%rax)
jmpq 1286 <func0+0xbd>
mov -0x14(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 1277 <func0+0xae>
mov -0x28(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0x10(%rbp)
jg 1241 <func0+0x78>
shll -0x10(%rbp)
mov -0x10(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
mov %rdx,%rsi
mov %rax,%rdi
callq 10d0 <realloc@plt>
mov %rax,-0x20(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
lea 0x1(%rax),%ecx
mov -0x28(%rbp),%rdx
mov %ecx,(%rdx)
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x14(%rbp),%eax
mov %eax,(%rdx)
mov -0x14(%rbp),%edx
mov %edx,%eax
add %eax,%eax
add %edx,%eax
add $0x1,%eax
mov %eax,-0x14(%rbp)
jmp 1286 <func0+0xbd>
mov -0x14(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,-0x14(%rbp)
cmpl $0x1,-0x14(%rbp)
jne 1200 <func0+0x37>
movl $0x1,-0xc(%rbp)
jmpq 1337 <func0+0x16e>
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0x4(%rbp)
mov -0xc(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x8(%rbp)
jmp 12f5 <func0+0x12c>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov -0x8(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
lea 0x0(,%rdx,4),%rcx
mov -0x20(%rbp),%rdx
add %rcx,%rdx
mov (%rax),%eax
mov %eax,(%rdx)
subl $0x1,-0x8(%rbp)
cmpl $0x0,-0x8(%rbp)
js 1316 <func0+0x14d>
mov -0x8(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0x4(%rbp)
jl 12c0 <func0+0xf7>
mov -0x8(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,4),%rdx
mov -0x20(%rbp),%rax
add %rax,%rdx
mov -0x4(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0xc(%rbp)
mov -0x28(%rbp),%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jl 129c <func0+0xd3>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_14], edi
mov [rbp+ptr], rsi
mov [rbp+var_28], rdx
mov [rbp+var_10], 0Ah
mov rax, [rbp+var_28]
mov dword ptr [rax], 1
mov rax, [rbp+ptr]
mov dword ptr [rax], 1
jmp loc_128C
loc_1200:
mov edx, [rbp+var_14]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_127D
mov rax, [rbp+var_28]
mov eax, [rax]
cmp [rbp+var_10], eax
jg short loc_1247
shl [rbp+var_10], 1
mov eax, [rbp+var_10]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
mov rsi, rdx; size
mov rdi, rax; ptr
call _realloc
mov [rbp+ptr], rax
loc_1247:
mov rax, [rbp+var_28]
mov eax, [rax]
lea ecx, [rax+1]
mov rdx, [rbp+var_28]
mov [rdx], ecx
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_14]
mov [rdx], eax
mov edx, [rbp+var_14]
mov eax, edx
add eax, eax
add eax, edx
add eax, 1
mov [rbp+var_14], eax
jmp short loc_128C
loc_127D:
mov eax, [rbp+var_14]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov [rbp+var_14], eax
loc_128C:
cmp [rbp+var_14], 1
jnz loc_1200
mov [rbp+var_C], 1
jmp loc_133D
loc_12A2:
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
mov [rbp+var_4], eax
mov eax, [rbp+var_C]
sub eax, 1
mov [rbp+var_8], eax
jmp short loc_12FB
loc_12C6:
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov edx, [rbp+var_8]
movsxd rdx, edx
add rdx, 1
lea rcx, ds:0[rdx*4]
mov rdx, [rbp+ptr]
add rdx, rcx
mov eax, [rax]
mov [rdx], eax
sub [rbp+var_8], 1
loc_12FB:
cmp [rbp+var_8], 0
js short loc_131C
mov eax, [rbp+var_8]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rax, rdx
mov eax, [rax]
cmp [rbp+var_4], eax
jl short loc_12C6
loc_131C:
mov eax, [rbp+var_8]
cdqe
add rax, 1
lea rdx, ds:0[rax*4]
mov rax, [rbp+ptr]
add rdx, rax
mov eax, [rbp+var_4]
mov [rdx], eax
add [rbp+var_C], 1
loc_133D:
mov rax, [rbp+var_28]
mov eax, [rax]
cmp [rbp+var_C], eax
jl loc_12A2
nop
nop
leave
retn
|
long long func0(int a1, _DWORD *a2, int *a3)
{
int v3; // eax
long long result; // rax
void *ptr; // [rsp+10h] [rbp-20h]
int v8; // [rsp+20h] [rbp-10h]
int i; // [rsp+24h] [rbp-Ch]
int j; // [rsp+28h] [rbp-8h]
int v11; // [rsp+2Ch] [rbp-4h]
ptr = a2;
v8 = 10;
*a3 = 1;
*a2 = 1;
while ( a1 != 1 )
{
if ( a1 % 2 == 1 )
{
if ( v8 <= *a3 )
{
v8 *= 2;
ptr = realloc(ptr, 4LL * v8);
}
v3 = (*a3)++;
*((_DWORD *)ptr + v3) = a1;
a1 = 3 * a1 + 1;
}
else
{
a1 /= 2;
}
}
for ( i = 1; ; ++i )
{
result = (unsigned int)*a3;
if ( i >= (int)result )
break;
v11 = *((_DWORD *)ptr + i);
for ( j = i - 1; j >= 0 && v11 < *((_DWORD *)ptr + j); --j )
*((_DWORD *)ptr + j + 1) = *((_DWORD *)ptr + j);
*((_DWORD *)ptr + j + 1) = v11;
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x14],EDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x10],0xa
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0x1
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x1
JMP 0x0010128c
LAB_00101200:
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x0010127d
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x10],EAX
JG 0x00101247
SHL dword ptr [RBP + -0x10],0x1
MOV EAX,dword ptr [RBP + -0x10]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,RDX
MOV RDI,RAX
CALL 0x001010d0
MOV qword ptr [RBP + -0x20],RAX
LAB_00101247:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
LEA ECX,[RAX + 0x1]
MOV RDX,qword ptr [RBP + -0x28]
MOV dword ptr [RDX],ECX
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RDX],EAX
MOV EDX,dword ptr [RBP + -0x14]
MOV EAX,EDX
ADD EAX,EAX
ADD EAX,EDX
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0010128c
LAB_0010127d:
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
LAB_0010128c:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x00101200
MOV dword ptr [RBP + -0xc],0x1
JMP 0x0010133d
LAB_001012a2:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0xc]
SUB EAX,0x1
MOV dword ptr [RBP + -0x8],EAX
JMP 0x001012fb
LAB_001012c6:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EDX,dword ptr [RBP + -0x8]
MOVSXD RDX,EDX
ADD RDX,0x1
LEA RCX,[RDX*0x4]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RDX],EAX
SUB dword ptr [RBP + -0x8],0x1
LAB_001012fb:
CMP dword ptr [RBP + -0x8],0x0
JS 0x0010131c
MOV EAX,dword ptr [RBP + -0x8]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0x4],EAX
JL 0x001012c6
LAB_0010131c:
MOV EAX,dword ptr [RBP + -0x8]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x20]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RDX],EAX
ADD dword ptr [RBP + -0xc],0x1
LAB_0010133d:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JL 0x001012a2
NOP
NOP
LEAVE
RET
|
void func0(int param_1,int4 *param_2,int *param_3)
{
int iVar1;
int4 *local_28;
int local_1c;
int local_18;
int local_14;
int local_10;
local_18 = 10;
*param_3 = 1;
*param_2 = 1;
local_28 = param_2;
local_1c = param_1;
while (local_1c != 1) {
if (local_1c % 2 == 1) {
if (local_18 <= *param_3) {
local_18 = local_18 << 1;
local_28 = (int4 *)realloc(local_28,(long)local_18 * 4);
}
iVar1 = *param_3;
*param_3 = iVar1 + 1;
local_28[iVar1] = local_1c;
local_1c = local_1c * 3 + 1;
}
else {
local_1c = local_1c / 2;
}
}
for (local_14 = 1; local_14 < *param_3; local_14 = local_14 + 1) {
iVar1 = local_28[local_14];
local_10 = local_14;
while ((local_10 = local_10 + -1, -1 < local_10 && (iVar1 < (int)local_28[local_10]))) {
local_28[(long)local_10 + 1] = local_28[local_10];
}
local_28[(long)local_10 + 1] = iVar1;
}
return;
}
|
1,149 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++] = n;
n = n * 3 + 1;
} else {
n = n / 2;
}
}
for (int i = 1; i < *size; i++) {
int key = out[i];
int j = i - 1;
while (j >= 0 && out[j] > key) {
out[j + 1] = out[j];
j = j - 1;
}
out[j + 1] = key;
}
}
|
#include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 11, 13, 17};
result = (int*)malloc(100 * sizeof(int));
func0(14, result, &size);
assert(issame(result, size, expected1, 6));
free(result);
// Test 2
int expected2[] = {1, 5};
result = (int*)malloc(100 * sizeof(int));
func0(5, result, &size);
assert(issame(result, size, expected2, 2));
free(result);
// Test 3
int expected3[] = {1, 3, 5};
result = (int*)malloc(100 * sizeof(int));
func0(12, result, &size);
assert(issame(result, size, expected3, 3));
free(result);
// Test 4
int expected4[] = {1};
result = (int*)malloc(100 * sizeof(int));
func0(1, result, &size);
assert(issame(result, size, expected4, 1));
free(result);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r12
push %rbp
push %rbx
mov %rsi,%rax
mov %rdx,%rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 123f <func0+0x76>
mov %edi,%ebp
mov $0xa,%r12d
jmp 1214 <func0+0x4b>
add %r12d,%r12d
movslq %r12d,%rsi
shl $0x2,%rsi
mov %rax,%rdi
callq 10d0 <realloc@plt>
jmp 122c <func0+0x63>
mov %ebp,%edi
shr $0x1f,%edi
add %edi,%ebp
sar %ebp
cmp $0x1,%ebp
je 123f <func0+0x76>
mov %ebp,%ecx
shr $0x1f,%ecx
lea 0x0(%rbp,%rcx,1),%edx
and $0x1,%edx
sub %ecx,%edx
cmp $0x1,%edx
jne 1206 <func0+0x3d>
cmp %r12d,(%rbx)
jge 11f2 <func0+0x29>
mov (%rbx),%edx
lea 0x1(%rdx),%ecx
mov %ecx,(%rbx)
movslq %edx,%rdx
mov %ebp,(%rax,%rdx,4)
lea 0x1(%rbp,%rbp,2),%ebp
jmp 120f <func0+0x46>
cmpl $0x1,(%rbx)
jle 128c <func0+0xc3>
mov %rax,%r9
mov $0x0,%r8d
jmp 1266 <func0+0x9d>
movslq %ecx,%rcx
mov %edi,0x4(%rax,%rcx,4)
add $0x1,%r8
add $0x4,%r9
lea 0x1(%r8),%edx
cmp %edx,(%rbx)
jle 128c <func0+0xc3>
mov 0x4(%r9),%edi
mov %r8d,%ecx
mov %r9,%rdx
test %r8d,%r8d
js 124f <func0+0x86>
mov (%rdx),%esi
cmp %edi,%esi
jle 124f <func0+0x86>
mov %esi,0x4(%rdx)
sub $0x1,%ecx
sub $0x4,%rdx
cmp $0xffffffff,%ecx
jne 1275 <func0+0xac>
jmp 124f <func0+0x86>
pop %rbx
pop %rbp
pop %r12
retq
|
func0:
endbr64
push r12
push rbp
push rbx
mov ebp, edi
mov rdi, rsi; ptr
mov rbx, rdx
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebp, 1
jz short loc_122A
mov r12d, 0Ah
jmp short loc_1207
loc_11F2:
cmp [rbx], r12d
jge short loc_123A
loc_11F7:
mov eax, [rbx]
lea edx, [rax+1]
mov [rbx], edx
cdqe
mov [rdi+rax*4], ebp
lea ebp, [rbp+rbp*2+1]
loc_1207:
mov edx, ebp
shr edx, 1Fh
lea eax, [rbp+rdx+0]
and eax, 1
sub eax, edx
cmp eax, 1
jz short loc_11F2
mov eax, ebp
shr eax, 1Fh
add eax, ebp
sar eax, 1
mov ebp, eax
cmp eax, 1
jnz short loc_1207
loc_122A:
cmp dword ptr [rbx], 1
jle short loc_128D
mov r9, rdi
mov r8d, 0
jmp short loc_1267
loc_123A:
add r12d, r12d
movsxd rsi, r12d
shl rsi, 2; size
call _realloc
mov rdi, rax
jmp short loc_11F7
loc_124E:
add edx, 1
movsxd rdx, edx
mov [rdi+rdx*4], esi
add r8, 1
add r9, 4
lea eax, [r8+1]
cmp [rbx], eax
jle short loc_128D
loc_1267:
mov esi, [r9+4]
mov edx, r8d
mov rax, r9
test r8d, r8d
js short loc_124E
loc_1276:
mov ecx, [rax]
cmp ecx, esi
jle short loc_124E
mov [rax+4], ecx
sub edx, 1
sub rax, 4
cmp edx, 0FFFFFFFFh
jnz short loc_1276
jmp short loc_124E
loc_128D:
pop rbx
pop rbp
pop r12
retn
|
void func0(int a1, _DWORD *a2, int *a3)
{
void *v4; // rdi
int v6; // r12d
int v7; // eax
_DWORD *v8; // r9
int v9; // r8d
int v10; // esi
int v11; // edx
_DWORD *v12; // rax
v4 = a2;
*a3 = 1;
*a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 )
{
if ( *a3 >= v6 )
{
v6 *= 2;
v4 = realloc(v4, 4LL * v6);
}
v7 = (*a3)++;
*((_DWORD *)v4 + v7) = a1;
a1 = 3 * a1 + 1;
}
a1 /= 2;
}
while ( a1 != 1 );
}
if ( *a3 > 1 )
{
v8 = v4;
v9 = 0;
do
{
v10 = v8[1];
v11 = v9;
v12 = v8;
if ( v9 >= 0 )
{
do
{
if ( *v12 <= v10 )
break;
v12[1] = *v12;
--v11;
--v12;
}
while ( v11 != -1 );
}
*((_DWORD *)v4 + v11 + 1) = v10;
++v9;
++v8;
}
while ( *a3 > v9 + 1 );
}
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV EBP,EDI
MOV RDI,RSI
MOV RBX,RDX
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBP,0x1
JZ 0x0010122a
MOV R12D,0xa
JMP 0x00101207
LAB_001011f2:
CMP dword ptr [RBX],R12D
JGE 0x0010123a
LAB_001011f7:
MOV EAX,dword ptr [RBX]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBX],EDX
CDQE
MOV dword ptr [RDI + RAX*0x4],EBP
LEA EBP,[RBP + RBP*0x2 + 0x1]
LAB_00101207:
MOV EDX,EBP
SHR EDX,0x1f
LEA EAX,[RBP + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x001011f2
MOV EAX,EBP
SHR EAX,0x1f
ADD EAX,EBP
SAR EAX,0x1
MOV EBP,EAX
CMP EAX,0x1
JNZ 0x00101207
LAB_0010122a:
CMP dword ptr [RBX],0x1
JLE 0x0010128d
MOV R9,RDI
MOV R8D,0x0
JMP 0x00101267
LAB_0010123a:
ADD R12D,R12D
MOVSXD RSI,R12D
SHL RSI,0x2
CALL 0x001010d0
MOV RDI,RAX
JMP 0x001011f7
LAB_0010124e:
ADD EDX,0x1
MOVSXD RDX,EDX
MOV dword ptr [RDI + RDX*0x4],ESI
ADD R8,0x1
ADD R9,0x4
LEA EAX,[R8 + 0x1]
CMP dword ptr [RBX],EAX
JLE 0x0010128d
LAB_00101267:
MOV ESI,dword ptr [R9 + 0x4]
MOV EDX,R8D
MOV RAX,R9
TEST R8D,R8D
JS 0x0010124e
LAB_00101276:
MOV ECX,dword ptr [RAX]
CMP ECX,ESI
JLE 0x0010124e
MOV dword ptr [RAX + 0x4],ECX
SUB EDX,0x1
SUB RAX,0x4
CMP EDX,-0x1
JNZ 0x00101276
JMP 0x0010124e
LAB_0010128d:
POP RBX
POP RBP
POP R12
RET
|
void func0(int param_1,int *param_2,int *param_3)
{
int iVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; param_1 % 2 == 1; param_1 = param_1 * 3 + 1) {
if (iVar5 <= *param_3) {
iVar5 = iVar5 * 2;
param_2 = (int *)realloc(param_2,(long)iVar5 << 2);
}
iVar1 = *param_3;
*param_3 = iVar1 + 1;
param_2[iVar1] = param_1;
}
param_1 = param_1 / 2;
} while (param_1 != 1);
}
if (1 < *param_3) {
piVar4 = param_2;
iVar5 = 0;
do {
iVar1 = piVar4[1];
piVar2 = piVar4;
iVar3 = iVar5;
if (-1 < iVar5) {
do {
if (*piVar2 <= iVar1) break;
piVar2[1] = *piVar2;
iVar3 = iVar3 + -1;
piVar2 = piVar2 + -1;
} while (iVar3 != -1);
}
param_2[iVar3 + 1] = iVar1;
piVar4 = piVar4 + 1;
iVar1 = iVar5 + 2;
iVar5 = iVar5 + 1;
} while (iVar1 < *param_3);
}
return;
}
|
1,150 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++] = n;
n = n * 3 + 1;
} else {
n = n / 2;
}
}
for (int i = 1; i < *size; i++) {
int key = out[i];
int j = i - 1;
while (j >= 0 && out[j] > key) {
out[j + 1] = out[j];
j = j - 1;
}
out[j + 1] = key;
}
}
|
#include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 11, 13, 17};
result = (int*)malloc(100 * sizeof(int));
func0(14, result, &size);
assert(issame(result, size, expected1, 6));
free(result);
// Test 2
int expected2[] = {1, 5};
result = (int*)malloc(100 * sizeof(int));
func0(5, result, &size);
assert(issame(result, size, expected2, 2));
free(result);
// Test 3
int expected3[] = {1, 3, 5};
result = (int*)malloc(100 * sizeof(int));
func0(12, result, &size);
assert(issame(result, size, expected3, 3));
free(result);
// Test 4
int expected4[] = {1};
result = (int*)malloc(100 * sizeof(int));
func0(1, result, &size);
assert(issame(result, size, expected4, 1));
free(result);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r12
mov %rsi,%r11
push %rbp
mov %rdx,%rbp
push %rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 152e <func0+0xee>
movslq (%rdx),%rdx
mov %edi,%ebx
mov $0xa,%r12d
jmp 147e <func0+0x3e>
mov %ebx,%edi
shr $0x1f,%edi
add %edi,%ebx
sar %ebx
cmp $0x1,%ebx
je 14ac <func0+0x6c>
mov %ebx,%eax
shr $0x1f,%eax
lea (%rbx,%rax,1),%ecx
and $0x1,%ecx
sub %eax,%ecx
cmp $0x1,%ecx
jne 1470 <func0+0x30>
cmp %edx,%r12d
jle 1510 <func0+0xd0>
lea 0x1(%rdx),%eax
mov %eax,0x0(%rbp)
mov %ebx,(%r11,%rdx,4)
lea 0x1(%rbx,%rbx,2),%ebx
movslq 0x0(%rbp),%rdx
cmp $0x1,%ebx
jne 147e <func0+0x3e>
lea 0x4(%r11),%r10
xor %eax,%eax
cmp $0x1,%edx
jle 1504 <func0+0xc4>
nopw 0x0(%rax,%rax,1)
lea -0x4(%r10),%r8
lea 0x0(,%rax,4),%rdx
mov (%r10),%r9d
mov %r10,%rcx
sub %rdx,%r8
nopl (%rax)
mov -0x4(%rcx),%esi
mov %rcx,%rdi
cmp %r9d,%esi
jle 14f1 <func0+0xb1>
mov %esi,(%rcx)
lea -0x4(%rdi),%rcx
cmp %rcx,%r8
jne 14d8 <func0+0x98>
mov %r11,%rdi
add $0x1,%rax
mov %r9d,(%rdi)
add $0x4,%r10
lea 0x1(%rax),%edx
cmp 0x0(%rbp),%edx
jl 14c0 <func0+0x80>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
add %r12d,%r12d
mov %r11,%rdi
movslq %r12d,%rsi
shl $0x2,%rsi
callq 10d0 <realloc@plt>
movslq 0x0(%rbp),%rdx
mov %rax,%r11
jmpq 1495 <func0+0x55>
mov (%rdx),%edx
jmpq 14ac <func0+0x6c>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r12
push rbp
mov rbp, rdx
push rbx
mov ebx, edi
mov rdi, rsi; ptr
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebx, 1
jz short loc_1472
mov r12d, 0Ah
nop word ptr [rax+rax+00000000h]
loc_1450:
mov edx, ebx
shr edx, 1Fh
lea eax, [rbx+rdx]
and eax, 1
sub eax, edx
cmp eax, 1
jz short loc_14C0
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
cmp eax, 1
jnz short loc_1450
loc_1472:
cmp dword ptr [rbp+0], 1
mov esi, 1
jle short loc_14B8
nop dword ptr [rax]
loc_1480:
mov ecx, [rdi+rsi*4]
lea rax, [rsi-1]
jmp short loc_149D
loc_1490:
mov [rdi+rax*4+4], edx
sub rax, 1
cmp eax, 0FFFFFFFFh
jz short loc_14E8
loc_149D:
mov edx, [rdi+rax*4]
cmp edx, ecx
jg short loc_1490
add eax, 1
cdqe
lea rax, [rdi+rax*4]
loc_14AD:
mov [rax], ecx
add rsi, 1
cmp [rbp+0], esi
jg short loc_1480
loc_14B8:
pop rbx
pop rbp
pop r12
retn
loc_14C0:
movsxd rax, dword ptr [rbp+0]
cmp r12d, eax
jle short loc_14F0
loc_14C9:
lea edx, [rax+1]
mov [rbp+0], edx
mov [rdi+rax*4], ebx
lea ebx, [rbx+rbx*2+1]
test bl, 1
jnz short loc_14C0
sar ebx, 1
jmp loc_1450
loc_14E8:
mov rax, rdi
jmp short loc_14AD
loc_14F0:
add r12d, r12d
movsxd rsi, r12d
shl rsi, 2; size
call _realloc
mov rdi, rax
movsxd rax, dword ptr [rbp+0]
jmp short loc_14C9
|
void func0(int a1, char *a2, int *a3)
{
char *v5; // rdi
int v6; // r12d
long long v7; // rsi
int v8; // ecx
long long v9; // rax
int v10; // edx
char *v11; // rax
long long v12; // rax
v5 = a2;
*a3 = 1;
*(_DWORD *)a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 )
{
do
{
v12 = *a3;
if ( v6 <= (int)v12 )
{
v6 *= 2;
v5 = (char *)realloc(v5, 4LL * v6);
v12 = *a3;
}
*a3 = v12 + 1;
*(_DWORD *)&v5[4 * v12] = a1;
a1 = 3 * a1 + 1;
}
while ( (a1 & 1) != 0 );
a1 >>= 1;
}
a1 /= 2;
}
while ( a1 != 1 );
}
v7 = 1LL;
if ( *a3 > 1 )
{
do
{
v8 = *(_DWORD *)&v5[4 * v7];
v9 = v7 - 1;
do
{
v10 = *(_DWORD *)&v5[4 * v9];
if ( v10 <= v8 )
{
v11 = &v5[4 * (int)v9 + 4];
goto LABEL_10;
}
*(_DWORD *)&v5[4 * v9-- + 4] = v10;
}
while ( (_DWORD)v9 != -1 );
v11 = v5;
LABEL_10:
*(_DWORD *)v11 = v8;
++v7;
}
while ( *a3 > (int)v7 );
}
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV EBX,EDI
MOV RDI,RSI
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBX,0x1
JZ 0x00101472
MOV R12D,0xa
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV EDX,EBX
SHR EDX,0x1f
LEA EAX,[RBX + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x001014c0
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
CMP EAX,0x1
JNZ 0x00101450
LAB_00101472:
CMP dword ptr [RBP],0x1
MOV ESI,0x1
JLE 0x001014b8
NOP dword ptr [RAX]
LAB_00101480:
MOV ECX,dword ptr [RDI + RSI*0x4]
LEA RAX,[RSI + -0x1]
JMP 0x0010149d
LAB_00101490:
MOV dword ptr [RDI + RAX*0x4 + 0x4],EDX
SUB RAX,0x1
CMP EAX,-0x1
JZ 0x001014e8
LAB_0010149d:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ECX
JG 0x00101490
ADD EAX,0x1
CDQE
LEA RAX,[RDI + RAX*0x4]
LAB_001014ad:
MOV dword ptr [RAX],ECX
ADD RSI,0x1
CMP dword ptr [RBP],ESI
JG 0x00101480
LAB_001014b8:
POP RBX
POP RBP
POP R12
RET
LAB_001014c0:
MOVSXD RAX,dword ptr [RBP]
CMP R12D,EAX
JLE 0x001014f0
LAB_001014c9:
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
MOV dword ptr [RDI + RAX*0x4],EBX
LEA EBX,[RBX + RBX*0x2 + 0x1]
TEST BL,0x1
JNZ 0x001014c0
SAR EBX,0x1
JMP 0x00101450
LAB_001014e8:
MOV RAX,RDI
JMP 0x001014ad
LAB_001014f0:
ADD R12D,R12D
MOVSXD RSI,R12D
SHL RSI,0x2
CALL 0x001010d0
MOV RDI,RAX
MOVSXD RAX,dword ptr [RBP]
JMP 0x001014c9
|
void func0(uint param_1,int *param_2,int *param_3)
{
int iVar1;
long lVar2;
int *piVar3;
long lVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; (int)param_1 % 2 == 1; param_1 = (int)param_1 >> 1) {
do {
iVar1 = *param_3;
if (iVar5 <= iVar1) {
iVar5 = iVar5 * 2;
param_2 = (int *)realloc(param_2,(long)iVar5 << 2);
iVar1 = *param_3;
}
*param_3 = iVar1 + 1;
param_2[iVar1] = param_1;
param_1 = param_1 * 3 + 1;
} while ((param_1 & 1) != 0);
}
param_1 = (int)param_1 / 2;
} while (param_1 != 1);
}
lVar4 = 1;
if (1 < *param_3) {
do {
iVar5 = param_2[lVar4];
lVar2 = lVar4 + -1;
do {
if (param_2[lVar2] <= iVar5) {
piVar3 = param_2 + ((int)lVar2 + 1);
break;
}
param_2[lVar2 + 1] = param_2[lVar2];
lVar2 = lVar2 + -1;
piVar3 = param_2;
} while ((int)lVar2 != -1);
*piVar3 = iVar5;
lVar4 = lVar4 + 1;
} while ((int)lVar4 < *param_3);
}
return;
}
|
1,151 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
void func0(int n, int *out, int *size) {
int capacity = 10;
*size = 1;
out[0] = 1;
while (n != 1) {
if (n % 2 == 1) {
if (*size >= capacity) {
capacity *= 2;
out = (int*)realloc(out, capacity * sizeof(int));
}
out[(*size)++] = n;
n = n * 3 + 1;
} else {
n = n / 2;
}
}
for (int i = 1; i < *size; i++) {
int key = out[i];
int j = i - 1;
while (j >= 0 && out[j] > key) {
out[j + 1] = out[j];
j = j - 1;
}
out[j + 1] = key;
}
}
|
#include <assert.h>
#include <stdlib.h>
int issame(int *a, int size_a, int *b, int size_b) {
if (size_a != size_b) return 0;
for (int i = 0; i < size_a; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int *result;
// Test 1
int expected1[] = {1, 5, 7, 11, 13, 17};
result = (int*)malloc(100 * sizeof(int));
func0(14, result, &size);
assert(issame(result, size, expected1, 6));
free(result);
// Test 2
int expected2[] = {1, 5};
result = (int*)malloc(100 * sizeof(int));
func0(5, result, &size);
assert(issame(result, size, expected2, 2));
free(result);
// Test 3
int expected3[] = {1, 3, 5};
result = (int*)malloc(100 * sizeof(int));
func0(12, result, &size);
assert(issame(result, size, expected3, 3));
free(result);
// Test 4
int expected4[] = {1};
result = (int*)malloc(100 * sizeof(int));
func0(1, result, &size);
assert(issame(result, size, expected4, 1));
free(result);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r12
mov %rsi,%r11
push %rbp
mov %rdx,%rbp
push %rbx
movl $0x1,(%rdx)
movl $0x1,(%rsi)
cmp $0x1,%edi
je 152e <func0+0xee>
movslq (%rdx),%rdx
mov %edi,%ebx
mov $0xa,%r12d
jmp 147e <func0+0x3e>
mov %ebx,%edi
shr $0x1f,%edi
add %edi,%ebx
sar %ebx
cmp $0x1,%ebx
je 14ac <func0+0x6c>
mov %ebx,%eax
shr $0x1f,%eax
lea (%rbx,%rax,1),%ecx
and $0x1,%ecx
sub %eax,%ecx
cmp $0x1,%ecx
jne 1470 <func0+0x30>
cmp %edx,%r12d
jle 1510 <func0+0xd0>
lea 0x1(%rdx),%eax
mov %eax,0x0(%rbp)
mov %ebx,(%r11,%rdx,4)
lea 0x1(%rbx,%rbx,2),%ebx
movslq 0x0(%rbp),%rdx
cmp $0x1,%ebx
jne 147e <func0+0x3e>
lea 0x4(%r11),%r10
xor %eax,%eax
cmp $0x1,%edx
jle 1504 <func0+0xc4>
nopw 0x0(%rax,%rax,1)
lea -0x4(%r10),%r8
lea 0x0(,%rax,4),%rdx
mov (%r10),%r9d
mov %r10,%rcx
sub %rdx,%r8
nopl (%rax)
mov -0x4(%rcx),%esi
mov %rcx,%rdi
cmp %r9d,%esi
jle 14f1 <func0+0xb1>
mov %esi,(%rcx)
lea -0x4(%rdi),%rcx
cmp %r8,%rcx
jne 14d8 <func0+0x98>
mov %r11,%rdi
add $0x1,%rax
mov %r9d,(%rdi)
add $0x4,%r10
lea 0x1(%rax),%edx
cmp %edx,0x0(%rbp)
jg 14c0 <func0+0x80>
pop %rbx
pop %rbp
pop %r12
retq
nopl 0x0(%rax)
add %r12d,%r12d
mov %r11,%rdi
movslq %r12d,%rsi
shl $0x2,%rsi
callq 10d0 <realloc@plt>
movslq 0x0(%rbp),%rdx
mov %rax,%r11
jmpq 1495 <func0+0x55>
mov (%rdx),%edx
jmpq 14ac <func0+0x6c>
data16 nopw %cs:0x0(%rax,%rax,1)
|
func0:
endbr64
push r12
push rbp
mov rbp, rdx
push rbx
mov ebx, edi
mov rdi, rsi; ptr
mov dword ptr [rdx], 1
mov dword ptr [rsi], 1
cmp ebx, 1
jz short loc_1472
mov r12d, 0Ah
nop word ptr [rax+rax+00000000h]
loc_1450:
mov edx, ebx
shr edx, 1Fh
lea eax, [rbx+rdx]
and eax, 1
sub eax, edx
cmp eax, 1
jz short loc_14C0
mov eax, ebx
shr eax, 1Fh
add eax, ebx
sar eax, 1
mov ebx, eax
cmp eax, 1
jnz short loc_1450
loc_1472:
cmp dword ptr [rbp+0], 1
mov esi, 1
jle short loc_14B8
nop dword ptr [rax]
loc_1480:
mov ecx, [rdi+rsi*4]
lea rax, [rsi-1]
jmp short loc_149D
loc_1490:
mov [rdi+rax*4+4], edx
sub rax, 1
cmp eax, 0FFFFFFFFh
jz short loc_14E8
loc_149D:
mov edx, [rdi+rax*4]
cmp edx, ecx
jg short loc_1490
add eax, 1
cdqe
lea rax, [rdi+rax*4]
loc_14AD:
mov [rax], ecx
add rsi, 1
cmp [rbp+0], esi
jg short loc_1480
loc_14B8:
pop rbx
pop rbp
pop r12
retn
loc_14C0:
movsxd rax, dword ptr [rbp+0]
cmp r12d, eax
jle short loc_14F0
loc_14C9:
lea edx, [rax+1]
mov [rbp+0], edx
mov [rdi+rax*4], ebx
lea ebx, [rbx+rbx*2+1]
test bl, 1
jnz short loc_14C0
sar ebx, 1
jmp loc_1450
loc_14E8:
mov rax, rdi
jmp short loc_14AD
loc_14F0:
add r12d, r12d
movsxd rsi, r12d
shl rsi, 2; size
call _realloc
mov rdi, rax
movsxd rax, dword ptr [rbp+0]
jmp short loc_14C9
|
void func0(int a1, char *a2, int *a3)
{
char *v5; // rdi
int v6; // r12d
long long v7; // rsi
int v8; // ecx
long long v9; // rax
int v10; // edx
char *v11; // rax
long long v12; // rax
v5 = a2;
*a3 = 1;
*(_DWORD *)a2 = 1;
if ( a1 != 1 )
{
v6 = 10;
do
{
while ( a1 % 2 == 1 )
{
do
{
v12 = *a3;
if ( v6 <= (int)v12 )
{
v6 *= 2;
v5 = (char *)realloc(v5, 4LL * v6);
v12 = *a3;
}
*a3 = v12 + 1;
*(_DWORD *)&v5[4 * v12] = a1;
a1 = 3 * a1 + 1;
}
while ( (a1 & 1) != 0 );
a1 >>= 1;
}
a1 /= 2;
}
while ( a1 != 1 );
}
v7 = 1LL;
if ( *a3 > 1 )
{
do
{
v8 = *(_DWORD *)&v5[4 * v7];
v9 = v7 - 1;
do
{
v10 = *(_DWORD *)&v5[4 * v9];
if ( v10 <= v8 )
{
v11 = &v5[4 * (int)v9 + 4];
goto LABEL_10;
}
*(_DWORD *)&v5[4 * v9-- + 4] = v10;
}
while ( (_DWORD)v9 != -1 );
v11 = v5;
LABEL_10:
*(_DWORD *)v11 = v8;
++v7;
}
while ( *a3 > (int)v7 );
}
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
MOV RBP,RDX
PUSH RBX
MOV EBX,EDI
MOV RDI,RSI
MOV dword ptr [RDX],0x1
MOV dword ptr [RSI],0x1
CMP EBX,0x1
JZ 0x00101472
MOV R12D,0xa
NOP word ptr [RAX + RAX*0x1]
LAB_00101450:
MOV EDX,EBX
SHR EDX,0x1f
LEA EAX,[RBX + RDX*0x1]
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
JZ 0x001014c0
MOV EAX,EBX
SHR EAX,0x1f
ADD EAX,EBX
SAR EAX,0x1
MOV EBX,EAX
CMP EAX,0x1
JNZ 0x00101450
LAB_00101472:
CMP dword ptr [RBP],0x1
MOV ESI,0x1
JLE 0x001014b8
NOP dword ptr [RAX]
LAB_00101480:
MOV ECX,dword ptr [RDI + RSI*0x4]
LEA RAX,[RSI + -0x1]
JMP 0x0010149d
LAB_00101490:
MOV dword ptr [RDI + RAX*0x4 + 0x4],EDX
SUB RAX,0x1
CMP EAX,-0x1
JZ 0x001014e8
LAB_0010149d:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,ECX
JG 0x00101490
ADD EAX,0x1
CDQE
LEA RAX,[RDI + RAX*0x4]
LAB_001014ad:
MOV dword ptr [RAX],ECX
ADD RSI,0x1
CMP dword ptr [RBP],ESI
JG 0x00101480
LAB_001014b8:
POP RBX
POP RBP
POP R12
RET
LAB_001014c0:
MOVSXD RAX,dword ptr [RBP]
CMP R12D,EAX
JLE 0x001014f0
LAB_001014c9:
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP],EDX
MOV dword ptr [RDI + RAX*0x4],EBX
LEA EBX,[RBX + RBX*0x2 + 0x1]
TEST BL,0x1
JNZ 0x001014c0
SAR EBX,0x1
JMP 0x00101450
LAB_001014e8:
MOV RAX,RDI
JMP 0x001014ad
LAB_001014f0:
ADD R12D,R12D
MOVSXD RSI,R12D
SHL RSI,0x2
CALL 0x001010d0
MOV RDI,RAX
MOVSXD RAX,dword ptr [RBP]
JMP 0x001014c9
|
void func0(uint param_1,int *param_2,int *param_3)
{
int iVar1;
long lVar2;
int *piVar3;
long lVar4;
int iVar5;
*param_3 = 1;
*param_2 = 1;
if (param_1 != 1) {
iVar5 = 10;
do {
for (; (int)param_1 % 2 == 1; param_1 = (int)param_1 >> 1) {
do {
iVar1 = *param_3;
if (iVar5 <= iVar1) {
iVar5 = iVar5 * 2;
param_2 = (int *)realloc(param_2,(long)iVar5 << 2);
iVar1 = *param_3;
}
*param_3 = iVar1 + 1;
param_2[iVar1] = param_1;
param_1 = param_1 * 3 + 1;
} while ((param_1 & 1) != 0);
}
param_1 = (int)param_1 / 2;
} while (param_1 != 1);
}
lVar4 = 1;
if (1 < *param_3) {
do {
iVar5 = param_2[lVar4];
lVar2 = lVar4 + -1;
do {
if (param_2[lVar2] <= iVar5) {
piVar3 = param_2 + ((int)lVar2 + 1);
break;
}
param_2[lVar2 + 1] = param_2[lVar2];
lVar2 = lVar2 + -1;
piVar3 = param_2;
} while ((int)lVar2 != -1);
*piVar3 = iVar5;
lVar4 = lVar4 + 1;
} while ((int)lVar4 < *param_3);
}
return;
}
|
1,152 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[0], date[1], '\0'};
char str_day[3] = {date[3], date[4], '\0'};
char str_year[5] = {date[6], date[7], date[8], date[9], '\0'};
mm = atoi(str_month);
dd = atoi(str_day);
yy = atoi(str_year);
if (mm < 1 || mm > 12) return 0;
if (dd < 1 || dd > 31) return 0;
if ((mm == 4 || mm == 6 || mm == 9 || mm == 11) && dd == 31) return 0;
if (mm == 2 && dd > 29) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000") == 0);
assert(func0("06-06-2005") == 1);
assert(func0("21-31-2000") == 0);
assert(func0("04-12-2003") == 1);
assert(func0("04122003") == 0);
assert(func0("20030412") == 0);
assert(func0("2003-04") == 0);
assert(func0("2003-04-12") == 0);
assert(func0("04-2003") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 1080 <strlen@plt>
cmp $0xa,%rax
je 11e4 <func0+0x3b>
mov $0x0,%eax
jmpq 1346 <func0+0x19d>
movl $0x0,-0x24(%rbp)
jmp 124d <func0+0xa4>
cmpl $0x2,-0x24(%rbp)
je 11f9 <func0+0x50>
cmpl $0x5,-0x24(%rbp)
jne 1217 <func0+0x6e>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2d,%al
je 1249 <func0+0xa0>
mov $0x0,%eax
jmpq 1346 <func0+0x19d>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2f,%al
jle 123f <func0+0x96>
mov -0x24(%rbp),%eax
movslq %eax,%rdx
mov -0x38(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x39,%al
jle 1249 <func0+0xa0>
mov $0x0,%eax
jmpq 1346 <func0+0x19d>
addl $0x1,-0x24(%rbp)
cmpl $0x9,-0x24(%rbp)
jle 11ed <func0+0x44>
mov -0x38(%rbp),%rax
movzbl (%rax),%eax
mov %al,-0x13(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
mov %al,-0x12(%rbp)
movb $0x0,-0x11(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x3(%rax),%eax
mov %al,-0x10(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x4(%rax),%eax
mov %al,-0xf(%rbp)
movb $0x0,-0xe(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x6(%rax),%eax
mov %al,-0xd(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x7(%rax),%eax
mov %al,-0xc(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x8(%rax),%eax
mov %al,-0xb(%rbp)
mov -0x38(%rbp),%rax
movzbl 0x9(%rax),%eax
mov %al,-0xa(%rbp)
movb $0x0,-0x9(%rbp)
lea -0x13(%rbp),%rax
mov %rax,%rdi
callq 10b0 <atoi@plt>
mov %eax,-0x20(%rbp)
lea -0x10(%rbp),%rax
mov %rax,%rdi
callq 10b0 <atoi@plt>
mov %eax,-0x1c(%rbp)
lea -0xd(%rbp),%rax
mov %rax,%rdi
callq 10b0 <atoi@plt>
mov %eax,-0x18(%rbp)
cmpl $0x0,-0x20(%rbp)
jle 12ef <func0+0x146>
cmpl $0xc,-0x20(%rbp)
jle 12f6 <func0+0x14d>
mov $0x0,%eax
jmp 1346 <func0+0x19d>
cmpl $0x0,-0x1c(%rbp)
jle 1302 <func0+0x159>
cmpl $0x1f,-0x1c(%rbp)
jle 1309 <func0+0x160>
mov $0x0,%eax
jmp 1346 <func0+0x19d>
cmpl $0x4,-0x20(%rbp)
je 1321 <func0+0x178>
cmpl $0x6,-0x20(%rbp)
je 1321 <func0+0x178>
cmpl $0x9,-0x20(%rbp)
je 1321 <func0+0x178>
cmpl $0xb,-0x20(%rbp)
jne 132e <func0+0x185>
cmpl $0x1f,-0x1c(%rbp)
jne 132e <func0+0x185>
mov $0x0,%eax
jmp 1346 <func0+0x19d>
cmpl $0x2,-0x20(%rbp)
jne 1341 <func0+0x198>
cmpl $0x1d,-0x1c(%rbp)
jle 1341 <func0+0x198>
mov $0x0,%eax
jmp 1346 <func0+0x19d>
mov $0x1,%eax
mov -0x8(%rbp),%rcx
xor %fs:0x28,%rcx
je 135a <func0+0x1b1>
callq 1090 <__stack_chk_fail@plt>
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+s], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rax, 0Ah
jz short loc_11E4
mov eax, 0
jmp loc_135B
loc_11E4:
mov [rbp+var_24], 0
jmp short loc_124D
loc_11ED:
cmp [rbp+var_24], 2
jz short loc_11F9
cmp [rbp+var_24], 5
jnz short loc_1217
loc_11F9:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Dh ; '-'
jz short loc_1249
mov eax, 0
jmp loc_135B
loc_1217:
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Fh ; '/'
jle short loc_123F
mov eax, [rbp+var_24]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 39h ; '9'
jle short loc_1249
loc_123F:
mov eax, 0
jmp loc_135B
loc_1249:
add [rbp+var_24], 1
loc_124D:
cmp [rbp+var_24], 9
jle short loc_11ED
mov rax, [rbp+s]
movzx eax, byte ptr [rax]
mov [rbp+nptr], al
mov rax, [rbp+s]
add rax, 1
movzx eax, byte ptr [rax]
mov [rbp+var_12], al
mov [rbp+var_11], 0
mov rax, [rbp+s]
add rax, 3
movzx eax, byte ptr [rax]
mov [rbp+var_10], al
mov rax, [rbp+s]
add rax, 4
movzx eax, byte ptr [rax]
mov [rbp+var_F], al
mov [rbp+var_E], 0
mov rax, [rbp+s]
add rax, 6
movzx eax, byte ptr [rax]
mov [rbp+var_D], al
mov rax, [rbp+s]
add rax, 7
movzx eax, byte ptr [rax]
mov [rbp+var_C], al
mov rax, [rbp+s]
add rax, 8
movzx eax, byte ptr [rax]
mov [rbp+var_B], al
mov rax, [rbp+s]
add rax, 9
movzx eax, byte ptr [rax]
mov [rbp+var_A], al
mov [rbp+var_9], 0
lea rax, [rbp+nptr]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_20], eax
lea rax, [rbp+var_10]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_1C], eax
lea rax, [rbp+var_D]
mov rdi, rax; nptr
call _atoi
mov [rbp+var_18], eax
cmp [rbp+var_20], 0
jle short loc_1304
cmp [rbp+var_20], 0Ch
jle short loc_130B
loc_1304:
mov eax, 0
jmp short loc_135B
loc_130B:
cmp [rbp+var_1C], 0
jle short loc_1317
cmp [rbp+var_1C], 1Fh
jle short loc_131E
loc_1317:
mov eax, 0
jmp short loc_135B
loc_131E:
cmp [rbp+var_20], 4
jz short loc_1336
cmp [rbp+var_20], 6
jz short loc_1336
cmp [rbp+var_20], 9
jz short loc_1336
cmp [rbp+var_20], 0Bh
jnz short loc_1343
loc_1336:
cmp [rbp+var_1C], 1Fh
jnz short loc_1343
mov eax, 0
jmp short loc_135B
loc_1343:
cmp [rbp+var_20], 2
jnz short loc_1356
cmp [rbp+var_1C], 1Dh
jle short loc_1356
mov eax, 0
jmp short loc_135B
loc_1356:
mov eax, 1
loc_135B:
mov rdx, [rbp+var_8]
sub rdx, fs:28h
jz short locret_136F
call ___stack_chk_fail
locret_136F:
leave
retn
|
_BOOL8 func0(long long a1)
{
int i; // [rsp+1Ch] [rbp-24h]
int v3; // [rsp+20h] [rbp-20h]
int v4; // [rsp+24h] [rbp-1Ch]
char nptr[3]; // [rsp+2Dh] [rbp-13h] BYREF
char v6[3]; // [rsp+30h] [rbp-10h] BYREF
char v7[5]; // [rsp+33h] [rbp-Dh] BYREF
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(0x28u);
if ( strlen((const char *)a1) != 10 )
return 0LL;
for ( i = 0; i <= 9; ++i )
{
if ( i == 2 || i == 5 )
{
if ( *(_BYTE *)(i + a1) != 45 )
return 0LL;
}
else if ( *(char *)(i + a1) <= 47 || *(char *)(i + a1) > 57 )
{
return 0LL;
}
}
nptr[0] = *(_BYTE *)a1;
nptr[1] = *(_BYTE *)(a1 + 1);
nptr[2] = 0;
v6[0] = *(_BYTE *)(a1 + 3);
v6[1] = *(_BYTE *)(a1 + 4);
v6[2] = 0;
v7[0] = *(_BYTE *)(a1 + 6);
v7[1] = *(_BYTE *)(a1 + 7);
v7[2] = *(_BYTE *)(a1 + 8);
v7[3] = *(_BYTE *)(a1 + 9);
v7[4] = 0;
v3 = atoi(nptr);
v4 = atoi(v6);
atoi(v7);
if ( v3 <= 0 || v3 > 12 )
return 0LL;
if ( v4 <= 0 || v4 > 31 )
return 0LL;
if ( (v3 == 4 || v3 == 6 || v3 == 9 || v3 == 11) && v4 == 31 )
return 0LL;
return v3 != 2 || v4 <= 29;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101080
CMP RAX,0xa
JZ 0x001011e4
MOV EAX,0x0
JMP 0x0010135b
LAB_001011e4:
MOV dword ptr [RBP + -0x24],0x0
JMP 0x0010124d
LAB_001011ed:
CMP dword ptr [RBP + -0x24],0x2
JZ 0x001011f9
CMP dword ptr [RBP + -0x24],0x5
JNZ 0x00101217
LAB_001011f9:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2d
JZ 0x00101249
MOV EAX,0x0
JMP 0x0010135b
LAB_00101217:
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2f
JLE 0x0010123f
MOV EAX,dword ptr [RBP + -0x24]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x39
JLE 0x00101249
LAB_0010123f:
MOV EAX,0x0
JMP 0x0010135b
LAB_00101249:
ADD dword ptr [RBP + -0x24],0x1
LAB_0010124d:
CMP dword ptr [RBP + -0x24],0x9
JLE 0x001011ed
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x13],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x12],AL
MOV byte ptr [RBP + -0x11],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x3
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x10],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0xf],AL
MOV byte ptr [RBP + -0xe],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x6
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0xd],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x7
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x8
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x9
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0xa],AL
MOV byte ptr [RBP + -0x9],0x0
LEA RAX,[RBP + -0x13]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x20],EAX
LEA RAX,[RBP + -0x10]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x1c],EAX
LEA RAX,[RBP + -0xd]
MOV RDI,RAX
CALL 0x001010b0
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x20],0x0
JLE 0x00101304
CMP dword ptr [RBP + -0x20],0xc
JLE 0x0010130b
LAB_00101304:
MOV EAX,0x0
JMP 0x0010135b
LAB_0010130b:
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x00101317
CMP dword ptr [RBP + -0x1c],0x1f
JLE 0x0010131e
LAB_00101317:
MOV EAX,0x0
JMP 0x0010135b
LAB_0010131e:
CMP dword ptr [RBP + -0x20],0x4
JZ 0x00101336
CMP dword ptr [RBP + -0x20],0x6
JZ 0x00101336
CMP dword ptr [RBP + -0x20],0x9
JZ 0x00101336
CMP dword ptr [RBP + -0x20],0xb
JNZ 0x00101343
LAB_00101336:
CMP dword ptr [RBP + -0x1c],0x1f
JNZ 0x00101343
MOV EAX,0x0
JMP 0x0010135b
LAB_00101343:
CMP dword ptr [RBP + -0x20],0x2
JNZ 0x00101356
CMP dword ptr [RBP + -0x1c],0x1d
JLE 0x00101356
MOV EAX,0x0
JMP 0x0010135b
LAB_00101356:
MOV EAX,0x1
LAB_0010135b:
MOV RDX,qword ptr [RBP + -0x8]
SUB RDX,qword ptr FS:[0x28]
JZ 0x0010136f
CALL 0x00101090
LAB_0010136f:
LEAVE
RET
|
int8 func0(char *param_1)
{
int iVar1;
int iVar2;
size_t sVar3;
int8 uVar4;
long in_FS_OFFSET;
int local_2c;
char local_1b;
char local_1a;
int local_19;
char local_18;
char local_17;
int local_16;
char local_15;
char local_14;
char local_13;
char local_12;
int local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
if (sVar3 == 10) {
for (local_2c = 0; local_2c < 10; local_2c = local_2c + 1) {
if ((local_2c == 2) || (local_2c == 5)) {
if (param_1[local_2c] != '-') {
uVar4 = 0;
goto LAB_0010135b;
}
}
else if ((param_1[local_2c] < '0') || ('9' < param_1[local_2c])) {
uVar4 = 0;
goto LAB_0010135b;
}
}
local_1b = *param_1;
local_1a = param_1[1];
local_19 = 0;
local_18 = param_1[3];
local_17 = param_1[4];
local_16 = 0;
local_15 = param_1[6];
local_14 = param_1[7];
local_13 = param_1[8];
local_12 = param_1[9];
local_11 = 0;
iVar1 = atoi(&local_1b);
iVar2 = atoi(&local_18);
atoi(&local_15);
if ((iVar1 < 1) || (0xc < iVar1)) {
uVar4 = 0;
}
else if ((iVar2 < 1) || (0x1f < iVar2)) {
uVar4 = 0;
}
else if (((((iVar1 == 4) || (iVar1 == 6)) || (iVar1 == 9)) || (iVar1 == 0xb)) && (iVar2 == 0x1f)
) {
uVar4 = 0;
}
else if ((iVar1 == 2) && (0x1d < iVar2)) {
uVar4 = 0;
}
else {
uVar4 = 1;
}
}
else {
uVar4 = 0;
}
LAB_0010135b:
if (local_10 != *(long *)(in_FS_OFFSET + 0x28)) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar4;
}
|
1,153 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[0], date[1], '\0'};
char str_day[3] = {date[3], date[4], '\0'};
char str_year[5] = {date[6], date[7], date[8], date[9], '\0'};
mm = atoi(str_month);
dd = atoi(str_day);
yy = atoi(str_year);
if (mm < 1 || mm > 12) return 0;
if (dd < 1 || dd > 31) return 0;
if ((mm == 4 || mm == 6 || mm == 9 || mm == 11) && dd == 31) return 0;
if (mm == 2 && dd > 29) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000") == 0);
assert(func0("06-06-2005") == 1);
assert(func0("21-31-2000") == 0);
assert(func0("04-12-2003") == 1);
assert(func0("04122003") == 0);
assert(func0("20030412") == 0);
assert(func0("2003-04") == 0);
assert(func0("2003-04-12") == 0);
assert(func0("04-2003") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rdx
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
mov $0x0,%eax
cmp $0xfffffffffffffff4,%rcx
jne 12cb <func0+0x142>
mov $0x0,%eax
jmp 11d9 <func0+0x50>
cmpb $0x2d,(%rdx,%rax,1)
jne 12e2 <func0+0x159>
add $0x1,%rax
cmp $0xa,%rax
je 11f9 <func0+0x70>
cmp $0x2,%eax
je 11c5 <func0+0x3c>
cmp $0x5,%eax
je 11c5 <func0+0x3c>
movzbl (%rdx,%rax,1),%ebx
lea -0x30(%rbx),%ecx
cmp $0x9,%cl
jbe 11cf <func0+0x46>
mov $0x0,%eax
jmpq 12cb <func0+0x142>
movzbl (%rdx),%eax
mov %al,0xd(%rsp)
movzbl 0x1(%rdx),%eax
mov %al,0xe(%rsp)
movb $0x0,0xf(%rsp)
movzbl 0x3(%rdx),%eax
mov %al,0x10(%rsp)
movzbl 0x4(%rdx),%eax
mov %al,0x11(%rsp)
movb $0x0,0x12(%rsp)
movzbl 0x6(%rdx),%eax
mov %al,0x13(%rsp)
movzbl 0x7(%rdx),%eax
mov %al,0x14(%rsp)
movzbl 0x8(%rdx),%eax
mov %al,0x15(%rsp)
movzbl 0x9(%rdx),%eax
mov %al,0x16(%rsp)
movb $0x0,0x17(%rsp)
lea 0xd(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%rbx
lea 0x10(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
mov %rax,%rbp
lea 0x13(%rsp),%rdi
mov $0xa,%edx
mov $0x0,%esi
callq 1090 <strtol@plt>
lea -0x1(%rbx),%edx
mov $0x0,%eax
cmp $0xb,%edx
ja 12cb <func0+0x142>
lea -0x1(%rbp),%edx
cmp $0x1e,%edx
ja 12cb <func0+0x142>
mov %ebx,%eax
and $0xfffffffd,%eax
cmp $0x4,%eax
je 12ad <func0+0x124>
cmp $0x9,%eax
jne 12b7 <func0+0x12e>
mov $0x0,%eax
cmp $0x1f,%ebp
je 12cb <func0+0x142>
cmp $0x2,%ebx
sete %al
cmp $0x1d,%ebp
setg %dl
and %edx,%eax
xor $0x1,%eax
movzbl %al,%eax
mov 0x18(%rsp),%rsi
xor %fs:0x28,%rsi
jne 12e9 <func0+0x160>
add $0x28,%rsp
pop %rbx
pop %rbp
retq
mov $0x0,%eax
jmp 12cb <func0+0x142>
callq 1070 <__stack_chk_fail@plt>
|
func0:
endbr64
push rbp
push rbx
sub rsp, 28h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
mov rdx, rax
mov eax, 0
cmp rdx, 0Ah
jnz loc_12E9
mov eax, 0
jmp short loc_11F2
loc_11E4:
cmp byte ptr [rbx+rax], 2Dh ; '-'
jnz loc_1300
add rax, 1
loc_11F2:
cmp eax, 2
jz short loc_11E4
cmp eax, 5
jz short loc_11E4
movzx ecx, byte ptr [rbx+rax]
lea edx, [rcx-30h]
cmp dl, 9
ja loc_1307
add rax, 1
cmp rax, 0Ah
jnz short loc_11F2
movzx eax, byte ptr [rbx]
mov [rsp+38h+nptr], al
movzx eax, byte ptr [rbx+1]
mov [rsp+38h+var_2A], al
mov [rsp+38h+var_29], 0
movzx eax, byte ptr [rbx+3]
mov [rsp+38h+var_28], al
movzx eax, byte ptr [rbx+4]
mov [rsp+38h+var_27], al
mov [rsp+38h+var_26], 0
movzx eax, byte ptr [rbx+6]
mov [rsp+38h+var_25], al
movzx eax, byte ptr [rbx+7]
mov [rsp+38h+var_24], al
movzx eax, byte ptr [rbx+8]
mov [rsp+38h+var_23], al
movzx eax, byte ptr [rbx+9]
mov [rsp+38h+var_22], al
mov [rsp+38h+var_21], 0
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov rbx, rax
lea rdi, [rsp+38h+var_28]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
mov rbp, rax
lea rdi, [rsp+38h+var_25]; nptr
mov edx, 0Ah; base
mov esi, 0; endptr
call _strtol
lea edx, [rbx-1]
mov eax, 0
cmp edx, 0Bh
ja short loc_12E9
lea edx, [rbp-1]
cmp edx, 1Eh
ja short loc_12E9
cmp ebx, 0Bh
ja short loc_12D5
mov eax, 0A50h
bt rax, rbx
jnb short loc_12D5
mov eax, 0
cmp ebp, 1Fh
jz short loc_12E9
loc_12D5:
cmp ebx, 2
setz al
cmp ebp, 1Dh
setnle dl
and eax, edx
xor eax, 1
movzx eax, al
loc_12E9:
mov rdx, [rsp+38h+var_20]
sub rdx, fs:28h
jnz short loc_130E
add rsp, 28h
pop rbx
pop rbp
retn
loc_1300:
mov eax, 0
jmp short loc_12E9
loc_1307:
mov eax, 0
jmp short loc_12E9
loc_130E:
call ___stack_chk_fail
|
_BOOL8 func0(long long a1)
{
size_t v1; // rdx
_BOOL8 result; // rax
long long i; // rax
unsigned long long v4; // rbx
int v5; // ebp
long long v6; // rax
char nptr[3]; // [rsp+Dh] [rbp-2Bh] BYREF
char v8[3]; // [rsp+10h] [rbp-28h] BYREF
char v9[5]; // [rsp+13h] [rbp-25h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-20h]
v10 = __readfsqword(0x28u);
v1 = strlen((const char *)a1);
result = 0LL;
if ( v1 == 10 )
{
for ( i = 0LL; i != 10; ++i )
{
while ( (_DWORD)i == 2 || (_DWORD)i == 5 )
{
if ( *(_BYTE *)(a1 + i) != 45 )
return 0LL;
++i;
}
if ( (unsigned __int8)(*(_BYTE *)(a1 + i) - 48) > 9u )
return 0LL;
}
nptr[0] = *(_BYTE *)a1;
nptr[1] = *(_BYTE *)(a1 + 1);
nptr[2] = 0;
v8[0] = *(_BYTE *)(a1 + 3);
v8[1] = *(_BYTE *)(a1 + 4);
v8[2] = 0;
v9[0] = *(_BYTE *)(a1 + 6);
v9[1] = *(_BYTE *)(a1 + 7);
v9[2] = *(_BYTE *)(a1 + 8);
v9[3] = *(_BYTE *)(a1 + 9);
v9[4] = 0;
v4 = strtol(nptr, 0LL, 10);
v5 = strtol(v8, 0LL, 10);
strtol(v9, 0LL, 10);
result = 0LL;
if ( (unsigned int)(v4 - 1) <= 0xB && (unsigned int)(v5 - 1) <= 0x1E )
{
if ( (unsigned int)v4 > 0xB )
return v5 <= 29 || (_DWORD)v4 != 2;
v6 = 2640LL;
if ( !_bittest64(&v6, v4) )
return v5 <= 29 || (_DWORD)v4 != 2;
result = 0LL;
if ( v5 != 31 )
return v5 <= 29 || (_DWORD)v4 != 2;
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
MOV RDX,RAX
MOV EAX,0x0
CMP RDX,0xa
JNZ 0x001012e9
MOV EAX,0x0
JMP 0x001011f2
LAB_001011e4:
CMP byte ptr [RBX + RAX*0x1],0x2d
JNZ 0x00101300
ADD RAX,0x1
LAB_001011f2:
CMP EAX,0x2
JZ 0x001011e4
CMP EAX,0x5
JZ 0x001011e4
MOVZX ECX,byte ptr [RBX + RAX*0x1]
LEA EDX,[RCX + -0x30]
CMP DL,0x9
JA 0x00101307
ADD RAX,0x1
CMP RAX,0xa
JNZ 0x001011f2
MOVZX EAX,byte ptr [RBX]
MOV byte ptr [RSP + 0xd],AL
MOVZX EAX,byte ptr [RBX + 0x1]
MOV byte ptr [RSP + 0xe],AL
MOV byte ptr [RSP + 0xf],0x0
MOVZX EAX,byte ptr [RBX + 0x3]
MOV byte ptr [RSP + 0x10],AL
MOVZX EAX,byte ptr [RBX + 0x4]
MOV byte ptr [RSP + 0x11],AL
MOV byte ptr [RSP + 0x12],0x0
MOVZX EAX,byte ptr [RBX + 0x6]
MOV byte ptr [RSP + 0x13],AL
MOVZX EAX,byte ptr [RBX + 0x7]
MOV byte ptr [RSP + 0x14],AL
MOVZX EAX,byte ptr [RBX + 0x8]
MOV byte ptr [RSP + 0x15],AL
MOVZX EAX,byte ptr [RBX + 0x9]
MOV byte ptr [RSP + 0x16],AL
MOV byte ptr [RSP + 0x17],0x0
LEA RDI,[RSP + 0xd]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010b0
MOV RBX,RAX
LEA RDI,[RSP + 0x10]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010b0
MOV RBP,RAX
LEA RDI,[RSP + 0x13]
MOV EDX,0xa
MOV ESI,0x0
CALL 0x001010b0
LEA EDX,[RBX + -0x1]
MOV EAX,0x0
CMP EDX,0xb
JA 0x001012e9
LEA EDX,[RBP + -0x1]
CMP EDX,0x1e
JA 0x001012e9
CMP EBX,0xb
JA 0x001012d5
MOV EAX,0xa50
BT RAX,RBX
JNC 0x001012d5
MOV EAX,0x0
CMP EBP,0x1f
JZ 0x001012e9
LAB_001012d5:
CMP EBX,0x2
SETZ AL
CMP EBP,0x1d
SETG DL
AND EAX,EDX
XOR EAX,0x1
MOVZX EAX,AL
LAB_001012e9:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010130e
ADD RSP,0x28
POP RBX
POP RBP
RET
LAB_00101300:
MOV EAX,0x0
JMP 0x001012e9
LAB_00101307:
MOV EAX,0x0
JMP 0x001012e9
LAB_0010130e:
CALL 0x00101090
|
bool func0(char *param_1)
{
uint uVar1;
int iVar2;
bool bVar3;
size_t sVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
char local_2b;
char local_2a;
int local_29;
char local_28;
char local_27;
int local_26;
char local_25;
char local_24;
char local_23;
char local_22;
int local_21;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar4 = strlen(param_1);
bVar3 = false;
if (sVar4 == 10) {
lVar5 = 0;
do {
for (; ((int)lVar5 == 2 || ((int)lVar5 == 5)); lVar5 = lVar5 + 1) {
if (param_1[lVar5] != '-') {
bVar3 = false;
goto LAB_001012e9;
}
}
if (9 < (byte)(param_1[lVar5] - 0x30U)) {
bVar3 = false;
goto LAB_001012e9;
}
lVar5 = lVar5 + 1;
} while (lVar5 != 10);
local_2b = *param_1;
local_2a = param_1[1];
local_29 = 0;
local_28 = param_1[3];
local_27 = param_1[4];
local_26 = 0;
local_25 = param_1[6];
local_24 = param_1[7];
local_23 = param_1[8];
local_22 = param_1[9];
local_21 = 0;
uVar6 = strtol(&local_2b,(char **)0x0,10);
lVar5 = strtol(&local_28,(char **)0x0,10);
strtol(&local_25,(char **)0x0,10);
uVar1 = (uint)uVar6;
bVar3 = false;
if ((uVar1 - 1 < 0xc) && (iVar2 = (int)lVar5, iVar2 - 1U < 0x1f)) {
if ((0xb < uVar1) ||
(((0xa50UL >> (uVar6 & 0x3f) & 1) == 0 || (bVar3 = false, iVar2 != 0x1f)))) {
bVar3 = uVar1 != 2 || iVar2 < 0x1e;
}
}
}
LAB_001012e9:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar3;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,154 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[0], date[1], '\0'};
char str_day[3] = {date[3], date[4], '\0'};
char str_year[5] = {date[6], date[7], date[8], date[9], '\0'};
mm = atoi(str_month);
dd = atoi(str_day);
yy = atoi(str_year);
if (mm < 1 || mm > 12) return 0;
if (dd < 1 || dd > 31) return 0;
if ((mm == 4 || mm == 6 || mm == 9 || mm == 11) && dd == 31) return 0;
if (mm == 2 && dd > 29) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000") == 0);
assert(func0("06-06-2005") == 1);
assert(func0("21-31-2000") == 0);
assert(func0("04-12-2003") == 1);
assert(func0("04122003") == 0);
assert(func0("20030412") == 0);
assert(func0("2003-04") == 0);
assert(func0("2003-04-12") == 0);
assert(func0("04-2003") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp $0xa,%r8
jne 1550 <func0+0x60>
xor %eax,%eax
jmp 153a <func0+0x4a>
nopl 0x0(%rax)
sub $0x30,%edx
cmp $0x9,%dl
ja 154d <func0+0x5d>
add $0x1,%rax
cmp $0xa,%rax
je 1570 <func0+0x80>
movzbl (%rbx,%rax,1),%edx
cmp $0x2,%eax
je 1548 <func0+0x58>
cmp $0x5,%eax
jne 1528 <func0+0x38>
cmp $0x2d,%dl
je 1530 <func0+0x40>
xor %eax,%eax
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 161d <func0+0x12d>
add $0x28,%rsp
pop %rbx
pop %rbp
retq
nopl 0x0(%rax,%rax,1)
movzwl (%rbx),%eax
lea 0xd(%rsp),%rdi
mov $0xa,%edx
xor %esi,%esi
movb $0x0,0xf(%rsp)
mov %ax,0xd(%rsp)
movzwl 0x3(%rbx),%eax
movb $0x0,0x12(%rsp)
mov %ax,0x10(%rsp)
mov 0x6(%rbx),%eax
movb $0x0,0x17(%rsp)
mov %eax,0x13(%rsp)
callq 10b0 <strtol@plt>
lea 0x10(%rsp),%rdi
mov $0xa,%edx
xor %esi,%esi
mov %rax,%rbx
callq 10b0 <strtol@plt>
mov $0xa,%edx
lea 0x13(%rsp),%rdi
xor %esi,%esi
mov %rax,%rbp
callq 10b0 <strtol@plt>
lea -0x1(%rbx),%edx
xor %eax,%eax
cmp $0xb,%edx
ja 1550 <func0+0x60>
lea -0x1(%rbp),%edx
cmp $0x1e,%edx
ja 1550 <func0+0x60>
mov %ebx,%eax
and $0xfffffffd,%eax
cmp $0x4,%eax
je 15f9 <func0+0x109>
cmp $0x9,%eax
jne 1604 <func0+0x114>
xor %eax,%eax
cmp $0x1f,%ebp
je 1550 <func0+0x60>
cmp $0x2,%ebx
sete %al
cmp $0x1d,%ebp
setg %dl
and %edx,%eax
xor $0x1,%eax
movzbl %al,%eax
jmpq 1550 <func0+0x60>
callq 1090 <__stack_chk_fail@plt>
nopw %cs:0x0(%rax,%rax,1)
nopl 0x0(%rax)
|
func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
cmp rax, 0Ah
jnz short loc_1550
xor eax, eax
mov ecx, 24h ; '$'
jmp short loc_1537
loc_1528:
cmp dl, 2Dh ; '-'
jnz short loc_1550
loc_152D:
add rax, 1
cmp rax, 0Ah
jz short loc_1570
loc_1537:
bt rcx, rax
movzx edx, byte ptr [rbx+rax]
jb short loc_1528
sub edx, 30h ; '0'
cmp dl, 9
jbe short loc_152D
nop dword ptr [rax+00000000h]
loc_1550:
xor eax, eax
loc_1552:
mov rdx, [rsp+38h+var_20]
sub rdx, fs:28h
jnz loc_1621
add rsp, 28h
pop rbx
pop rbp
retn
loc_1570:
movzx eax, word ptr [rbx]
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov [rsp+38h+var_2E], 0
mov word ptr [rsp+38h+nptr], ax
movzx eax, word ptr [rbx+3]
mov [rsp+38h+var_2A], 0
mov word ptr [rsp+38h+var_2C], ax
mov eax, [rbx+6]
mov [rsp+38h+var_24], 0
mov dword ptr [rsp+38h+var_28], eax
call _strtol
lea rdi, [rsp+38h+var_2C]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov rbx, rax
call _strtol
lea rdi, [rsp+38h+var_28]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov rbp, rax
call _strtol
lea eax, [rbx-1]
cmp eax, 0Bh
ja loc_1550
lea eax, [rbp-1]
cmp eax, 1Eh
ja loc_1550
cmp ebx, 0Bh
ja short loc_1608
mov eax, 0A50h
bt rax, rbx
jnb short loc_1608
xor eax, eax
cmp ebp, 1Fh
setnz al
jmp loc_1552
loc_1608:
cmp ebx, 2
setz al
cmp ebp, 1Dh
setnle dl
and eax, edx
xor eax, 1
movzx eax, al
jmp loc_1552
loc_1621:
call ___stack_chk_fail
|
_BOOL8 func0(__int16 *a1)
{
unsigned long long v1; // rax
long long v2; // rcx
char v3; // dl
__int16 v5; // ax
__int16 v6; // ax
int v7; // eax
unsigned long long v8; // rbx
int v9; // ebp
long long v10; // rax
char nptr[2]; // [rsp+8h] [rbp-30h] BYREF
char v12; // [rsp+Ah] [rbp-2Eh]
char v13[2]; // [rsp+Ch] [rbp-2Ch] BYREF
char v14; // [rsp+Eh] [rbp-2Ah]
char v15[4]; // [rsp+10h] [rbp-28h] BYREF
char v16; // [rsp+14h] [rbp-24h]
unsigned long long v17; // [rsp+18h] [rbp-20h]
v17 = __readfsqword(0x28u);
if ( strlen((const char *)a1) != 10 )
return 0LL;
v1 = 0LL;
v2 = 36LL;
do
{
v3 = *((_BYTE *)a1 + v1);
if ( _bittest64(&v2, v1) )
{
if ( v3 != 45 )
return 0LL;
}
else if ( (unsigned __int8)(v3 - 48) > 9u )
{
return 0LL;
}
++v1;
}
while ( v1 != 10 );
v5 = *a1;
v12 = 0;
*(_WORD *)nptr = v5;
v6 = *(__int16 *)((char *)a1 + 3);
v14 = 0;
*(_WORD *)v13 = v6;
v7 = *(_DWORD *)(a1 + 3);
v16 = 0;
*(_DWORD *)v15 = v7;
v8 = strtol(nptr, 0LL, 10);
v9 = strtol(v13, 0LL, 10);
strtol(v15, 0LL, 10);
if ( (unsigned int)(v8 - 1) > 0xB || (unsigned int)(v9 - 1) > 0x1E )
return 0LL;
if ( (unsigned int)v8 <= 0xB )
{
v10 = 2640LL;
if ( _bittest64(&v10, v8) )
return v9 != 31;
}
return v9 <= 29 || (_DWORD)v8 != 2;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
CMP RAX,0xa
JNZ 0x00101550
XOR EAX,EAX
MOV ECX,0x24
JMP 0x00101537
LAB_00101528:
CMP DL,0x2d
JNZ 0x00101550
LAB_0010152d:
ADD RAX,0x1
CMP RAX,0xa
JZ 0x00101570
LAB_00101537:
BT RCX,RAX
MOVZX EDX,byte ptr [RBX + RAX*0x1]
JC 0x00101528
SUB EDX,0x30
CMP DL,0x9
JBE 0x0010152d
NOP dword ptr [RAX]
LAB_00101550:
XOR EAX,EAX
LAB_00101552:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x00101621
ADD RSP,0x28
POP RBX
POP RBP
RET
LAB_00101570:
MOVZX EAX,word ptr [RBX]
LEA RDI,[RSP + 0x8]
MOV EDX,0xa
XOR ESI,ESI
MOV byte ptr [RSP + 0xa],0x0
MOV word ptr [RSP + 0x8],AX
MOVZX EAX,word ptr [RBX + 0x3]
MOV byte ptr [RSP + 0xe],0x0
MOV word ptr [RSP + 0xc],AX
MOV EAX,dword ptr [RBX + 0x6]
MOV byte ptr [RSP + 0x14],0x0
MOV dword ptr [RSP + 0x10],EAX
CALL 0x001010b0
LEA RDI,[RSP + 0xc]
MOV EDX,0xa
XOR ESI,ESI
MOV RBX,RAX
CALL 0x001010b0
LEA RDI,[RSP + 0x10]
MOV EDX,0xa
XOR ESI,ESI
MOV RBP,RAX
CALL 0x001010b0
LEA EAX,[RBX + -0x1]
CMP EAX,0xb
JA 0x00101550
LEA EAX,[RBP + -0x1]
CMP EAX,0x1e
JA 0x00101550
CMP EBX,0xb
JA 0x00101608
MOV EAX,0xa50
BT RAX,RBX
JNC 0x00101608
XOR EAX,EAX
CMP EBP,0x1f
SETNZ AL
JMP 0x00101552
LAB_00101608:
CMP EBX,0x2
SETZ AL
CMP EBP,0x1d
SETG DL
AND EAX,EDX
XOR EAX,0x1
MOVZX EAX,AL
JMP 0x00101552
LAB_00101621:
CALL 0x00101090
|
bool func0(char *param_1)
{
uint uVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
bool bVar6;
int2 local_30;
int local_2e;
int2 local_2c;
int local_2a;
int4 local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
if (sVar3 == 10) {
uVar4 = 0;
do {
if ((0x24UL >> (uVar4 & 0x3f) & 1) == 0) {
if (9 < (byte)(param_1[uVar4] - 0x30U)) goto LAB_00101550;
}
else if (param_1[uVar4] != '-') goto LAB_00101550;
uVar4 = uVar4 + 1;
} while (uVar4 != 10);
local_30 = *(int2 *)param_1;
local_2e = 0;
local_2c = *(int2 *)(param_1 + 3);
local_2a = 0;
local_28 = *(int4 *)(param_1 + 6);
local_24 = 0;
uVar4 = strtol((char *)&local_30,(char **)0x0,10);
lVar5 = strtol((char *)&local_2c,(char **)0x0,10);
strtol((char *)&local_28,(char **)0x0,10);
uVar1 = (uint)uVar4;
if ((uVar1 - 1 < 0xc) && (iVar2 = (int)lVar5, iVar2 - 1U < 0x1f)) {
if ((uVar1 < 0xc) && ((0xa50UL >> (uVar4 & 0x3f) & 1) != 0)) {
bVar6 = iVar2 != 0x1f;
}
else {
bVar6 = uVar1 != 2 || iVar2 < 0x1e;
}
goto LAB_00101552;
}
}
LAB_00101550:
bVar6 = false;
LAB_00101552:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,155 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
|
int func0(const char *date) {
int mm, dd, yy;
if (strlen(date) != 10) return 0;
for (int i = 0; i < 10; i++) {
if (i == 2 || i == 5) {
if (date[i] != '-') return 0;
} else {
if (date[i] < '0' || date[i] > '9') return 0;
}
}
char str_month[3] = {date[0], date[1], '\0'};
char str_day[3] = {date[3], date[4], '\0'};
char str_year[5] = {date[6], date[7], date[8], date[9], '\0'};
mm = atoi(str_month);
dd = atoi(str_day);
yy = atoi(str_year);
if (mm < 1 || mm > 12) return 0;
if (dd < 1 || dd > 31) return 0;
if ((mm == 4 || mm == 6 || mm == 9 || mm == 11) && dd == 31) return 0;
if (mm == 2 && dd > 29) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("03-11-2000") == 1);
assert(func0("15-01-2012") == 0);
assert(func0("04-0-2040") == 0);
assert(func0("06-04-2020") == 1);
assert(func0("01-01-2007") == 1);
assert(func0("03-32-2011") == 0);
assert(func0("") == 0);
assert(func0("04-31-3000") == 0);
assert(func0("06-06-2005") == 1);
assert(func0("21-31-2000") == 0);
assert(func0("04-12-2003") == 1);
assert(func0("04122003") == 0);
assert(func0("20030412") == 0);
assert(func0("2003-04") == 0);
assert(func0("2003-04-12") == 0);
assert(func0("04-2003") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x28,%rsp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
callq 1080 <strlen@plt>
mov %rax,%r8
xor %eax,%eax
cmp $0xa,%r8
jne 1650 <func0+0x160>
movzbl (%rbx),%ecx
lea -0x30(%rcx),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
movzbl 0x1(%rbx),%esi
lea -0x30(%rsi),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
cmpb $0x2d,0x2(%rbx)
jne 1650 <func0+0x160>
movzbl 0x3(%rbx),%ecx
lea -0x30(%rcx),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
movzbl 0x4(%rbx),%esi
lea -0x30(%rsi),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
cmpb $0x2d,0x5(%rbx)
jne 1650 <func0+0x160>
movzbl 0x6(%rbx),%ecx
lea -0x30(%rcx),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
movzbl 0x7(%rbx),%esi
lea -0x30(%rsi),%edx
cmp $0x9,%dl
ja 1650 <func0+0x160>
movzbl 0x8(%rbx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 1667 <func0+0x177>
movzbl 0x9(%rbx),%eax
sub $0x30,%eax
cmp $0x9,%al
ja 1667 <func0+0x177>
movzwl (%rbx),%eax
lea 0xd(%rsp),%rdi
mov $0xa,%edx
xor %esi,%esi
movb $0x0,0xf(%rsp)
mov %ax,0xd(%rsp)
movzwl 0x3(%rbx),%eax
movb $0x0,0x12(%rsp)
mov %ax,0x10(%rsp)
mov 0x6(%rbx),%eax
movb $0x0,0x17(%rsp)
mov %eax,0x13(%rsp)
callq 10b0 <strtol@plt>
lea 0x10(%rsp),%rdi
mov $0xa,%edx
xor %esi,%esi
mov %rax,%rbx
callq 10b0 <strtol@plt>
mov $0xa,%edx
lea 0x13(%rsp),%rdi
xor %esi,%esi
mov %rax,%rbp
callq 10b0 <strtol@plt>
lea -0x1(%rbx),%edx
xor %eax,%eax
cmp $0xb,%edx
ja 1650 <func0+0x160>
lea -0x1(%rbp),%edx
cmp $0x1e,%edx
ja 1650 <func0+0x160>
mov %ebx,%eax
and $0xfffffffd,%eax
cmp $0x4,%eax
je 1633 <func0+0x143>
cmp $0x9,%eax
jne 163a <func0+0x14a>
xor %eax,%eax
cmp $0x1f,%ebp
je 1650 <func0+0x160>
cmp $0x2,%ebx
sete %al
cmp $0x1d,%ebp
setg %dl
and %edx,%eax
xor $0x1,%eax
movzbl %al,%eax
xchg %ax,%ax
mov 0x18(%rsp),%rcx
xor %fs:0x28,%rcx
jne 166b <func0+0x17b>
add $0x28,%rsp
pop %rbx
pop %rbp
retq
xor %eax,%eax
jmp 1650 <func0+0x160>
callq 1090 <__stack_chk_fail@plt>
|
func0:
endbr64
push rbp
push rbx
mov rbx, rdi
sub rsp, 28h
mov rax, fs:28h
mov [rsp+38h+var_20], rax
xor eax, eax
call _strlen
cmp rax, 0Ah
jnz loc_1638
movzx eax, byte ptr [rbx]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+1]
movzx edx, word ptr [rbx]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
cmp byte ptr [rbx+2], 2Dh ; '-'
jnz loc_1638
movzx eax, byte ptr [rbx+3]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+4]
movzx ecx, word ptr [rbx+3]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
cmp byte ptr [rbx+5], 2Dh ; '-'
jnz loc_1638
movzx eax, byte ptr [rbx+6]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+7]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+8]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
movzx eax, byte ptr [rbx+9]
mov esi, [rbx+6]
sub eax, 30h ; '0'
cmp al, 9
ja loc_1638
mov word ptr [rsp+38h+nptr], dx
lea rdi, [rsp+38h+nptr]; nptr
mov edx, 0Ah; base
mov dword ptr [rsp+38h+var_28], esi
xor esi, esi; endptr
mov word ptr [rsp+38h+var_2C], cx
mov [rsp+38h+var_2E], 0
mov [rsp+38h+var_2A], 0
mov [rsp+38h+var_24], 0
call _strtol
lea rdi, [rsp+38h+var_2C]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov rbx, rax
call _strtol
lea rdi, [rsp+38h+var_28]; nptr
mov edx, 0Ah; base
xor esi, esi; endptr
mov rbp, rax
call _strtol
lea eax, [rbx-1]
cmp eax, 0Bh
ja short loc_1638
lea eax, [rbp-1]
cmp eax, 1Eh
ja short loc_1638
cmp ebx, 0Bh
ja short loc_1658
mov eax, 0A50h
bt rax, rbx
jnb short loc_1658
xor eax, eax
cmp ebp, 1Fh
setnz al
jmp short loc_163A
loc_1638:
xor eax, eax
loc_163A:
mov rdx, [rsp+38h+var_20]
sub rdx, fs:28h
jnz short loc_166E
add rsp, 28h
pop rbx
pop rbp
retn
loc_1658:
cmp ebx, 2
setz al
cmp ebp, 1Dh
setnle dl
and eax, edx
xor eax, 1
movzx eax, al
jmp short loc_163A
loc_166E:
call ___stack_chk_fail
|
_BOOL8 func0(long long a1)
{
__int16 v1; // cx
int v2; // esi
unsigned long long v3; // rbx
int v4; // ebp
long long v5; // rax
char nptr[2]; // [rsp+8h] [rbp-30h] BYREF
char v8; // [rsp+Ah] [rbp-2Eh]
char v9[2]; // [rsp+Ch] [rbp-2Ch] BYREF
char v10; // [rsp+Eh] [rbp-2Ah]
char v11[4]; // [rsp+10h] [rbp-28h] BYREF
char v12; // [rsp+14h] [rbp-24h]
unsigned long long v13; // [rsp+18h] [rbp-20h]
v13 = __readfsqword(0x28u);
if ( strlen((const char *)a1) != 10 )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)a1 - 48) > 9u )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)(a1 + 1) - 48) > 9u )
return 0LL;
if ( *(_BYTE *)(a1 + 2) != 45 )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)(a1 + 3) - 48) > 9u )
return 0LL;
v1 = *(_WORD *)(a1 + 3);
if ( (unsigned __int8)(*(_BYTE *)(a1 + 4) - 48) > 9u )
return 0LL;
if ( *(_BYTE *)(a1 + 5) != 45 )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)(a1 + 6) - 48) > 9u )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)(a1 + 7) - 48) > 9u )
return 0LL;
if ( (unsigned __int8)(*(_BYTE *)(a1 + 8) - 48) > 9u )
return 0LL;
v2 = *(_DWORD *)(a1 + 6);
if ( (unsigned __int8)(*(_BYTE *)(a1 + 9) - 48) > 9u )
return 0LL;
*(_WORD *)nptr = *(_WORD *)a1;
*(_DWORD *)v11 = v2;
*(_WORD *)v9 = v1;
v8 = 0;
v10 = 0;
v12 = 0;
v3 = strtol(nptr, 0LL, 10);
v4 = strtol(v9, 0LL, 10);
strtol(v11, 0LL, 10);
if ( (unsigned int)(v3 - 1) > 0xB || (unsigned int)(v4 - 1) > 0x1E )
return 0LL;
if ( (unsigned int)v3 <= 0xB )
{
v5 = 2640LL;
if ( _bittest64(&v5, v3) )
return v4 != 31;
}
return v4 <= 29 || (_DWORD)v3 != 2;
}
|
func0:
ENDBR64
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x28
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
CALL 0x00101080
CMP RAX,0xa
JNZ 0x00101638
MOVZX EAX,byte ptr [RBX]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x1]
MOVZX EDX,word ptr [RBX]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
CMP byte ptr [RBX + 0x2],0x2d
JNZ 0x00101638
MOVZX EAX,byte ptr [RBX + 0x3]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x4]
MOVZX ECX,word ptr [RBX + 0x3]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
CMP byte ptr [RBX + 0x5],0x2d
JNZ 0x00101638
MOVZX EAX,byte ptr [RBX + 0x6]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x7]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x8]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOVZX EAX,byte ptr [RBX + 0x9]
MOV ESI,dword ptr [RBX + 0x6]
SUB EAX,0x30
CMP AL,0x9
JA 0x00101638
MOV word ptr [RSP + 0x8],DX
LEA RDI,[RSP + 0x8]
MOV EDX,0xa
MOV dword ptr [RSP + 0x10],ESI
XOR ESI,ESI
MOV word ptr [RSP + 0xc],CX
MOV byte ptr [RSP + 0xa],0x0
MOV byte ptr [RSP + 0xe],0x0
MOV byte ptr [RSP + 0x14],0x0
CALL 0x001010b0
LEA RDI,[RSP + 0xc]
MOV EDX,0xa
XOR ESI,ESI
MOV RBX,RAX
CALL 0x001010b0
LEA RDI,[RSP + 0x10]
MOV EDX,0xa
XOR ESI,ESI
MOV RBP,RAX
CALL 0x001010b0
LEA EAX,[RBX + -0x1]
CMP EAX,0xb
JA 0x00101638
LEA EAX,[RBP + -0x1]
CMP EAX,0x1e
JA 0x00101638
CMP EBX,0xb
JA 0x00101658
MOV EAX,0xa50
BT RAX,RBX
JNC 0x00101658
XOR EAX,EAX
CMP EBP,0x1f
SETNZ AL
JMP 0x0010163a
LAB_00101638:
XOR EAX,EAX
LAB_0010163a:
MOV RDX,qword ptr [RSP + 0x18]
SUB RDX,qword ptr FS:[0x28]
JNZ 0x0010166e
ADD RSP,0x28
POP RBX
POP RBP
RET
LAB_00101658:
CMP EBX,0x2
SETZ AL
CMP EBP,0x1d
SETG DL
AND EAX,EDX
XOR EAX,0x1
MOVZX EAX,AL
JMP 0x0010163a
LAB_0010166e:
CALL 0x00101090
|
bool func0(char *param_1)
{
uint uVar1;
int iVar2;
size_t sVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
bool bVar6;
int2 local_30;
int local_2e;
int2 local_2c;
int local_2a;
int4 local_28;
int local_24;
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen(param_1);
if (((((((sVar3 == 10) && ((byte)(*param_1 - 0x30U) < 10)) && ((byte)(param_1[1] - 0x30U) < 10))
&& ((param_1[2] == '-' && ((byte)(param_1[3] - 0x30U) < 10)))) &&
(((byte)(param_1[4] - 0x30U) < 10 &&
((param_1[5] == '-' && ((byte)(param_1[6] - 0x30U) < 10)))))) &&
((byte)(param_1[7] - 0x30U) < 10)) &&
(((byte)(param_1[8] - 0x30U) < 10 && ((byte)(param_1[9] - 0x30U) < 10)))) {
local_2e = 0;
local_2a = 0;
local_24 = 0;
local_30 = *(int2 *)param_1;
local_2c = *(int2 *)(param_1 + 3);
local_28 = *(int4 *)(param_1 + 6);
uVar4 = strtol((char *)&local_30,(char **)0x0,10);
lVar5 = strtol((char *)&local_2c,(char **)0x0,10);
strtol((char *)&local_28,(char **)0x0,10);
uVar1 = (uint)uVar4;
if ((uVar1 - 1 < 0xc) && (iVar2 = (int)lVar5, iVar2 - 1U < 0x1f)) {
if ((uVar1 < 0xc) && ((0xa50UL >> (uVar4 & 0x3f) & 1) != 0)) {
bVar6 = iVar2 != 0x1f;
}
else {
bVar6 = uVar1 != 2 || iVar2 < 0x1e;
}
goto LAB_0010163a;
}
}
bVar6 = false;
LAB_0010163a:
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return bVar6;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,156 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
|
char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (txt[i] == ' ' || txt[i] == ',' || txt[i] == '\0') {
if (j > 0) {
current[j] = '\0';
out[count] = strdup(current);
count++;
j = 0;
}
} else {
current[j++] = txt[i];
}
}
} else {
for (i = 0; i < len; ++i) {
if (islower(txt[i]) && ((txt[i] - 'a') % 2 == 1)) {
num++;
}
}
out = malloc(sizeof(char *));
out[0] = malloc(sizeof(char) * 12);
sprintf(out[0], "%d", num);
count = 1;
}
*returnSize = count;
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
for (int i = 0; i < size; i++) free(words[i]);
free(words);
}
int main() {
int size;
char *expected[3];
char **result;
result = func0("Hello world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("Hello,world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("abcdef", &size);
expected[0] = "3";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaabb", &size);
expected[0] = "2";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaaBb", &size);
expected[0] = "1";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("", &size);
expected[0] = "0";
assert(issame(expected, 1,result, size));
free_words(result, size);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,-0xa8(%rbp)
mov %rsi,-0xb0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x98(%rbp)
movl $0x0,-0x94(%rbp)
movl $0x0,-0x90(%rbp)
mov -0xa8(%rbp),%rax
mov %rax,%rdi
callq 10f0 <strlen@plt>
mov %eax,-0x8c(%rbp)
movq $0x0,-0x88(%rbp)
movq $0x0,-0x80(%rbp)
movq $0x0,-0x78(%rbp)
movq $0x0,-0x70(%rbp)
movq $0x0,-0x68(%rbp)
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq $0x0,-0x50(%rbp)
movq $0x0,-0x48(%rbp)
movq $0x0,-0x40(%rbp)
movq $0x0,-0x38(%rbp)
movq $0x0,-0x30(%rbp)
movq $0x0,-0x28(%rbp)
movl $0x0,-0x20(%rbp)
movb $0x0,-0x1c(%rbp)
mov -0xa8(%rbp),%rax
mov $0x20,%esi
mov %rax,%rdi
callq 1110 <strchr@plt>
test %rax,%rax
jne 1375 <func0+0x10c>
mov -0xa8(%rbp),%rax
mov $0x2c,%esi
mov %rax,%rdi
callq 1110 <strchr@plt>
test %rax,%rax
je 148d <func0+0x224>
mov -0x8c(%rbp),%eax
add $0x1,%eax
cltq
shl $0x3,%rax
mov %rax,%rdi
callq 1140 <malloc@plt>
mov %rax,-0x88(%rbp)
movl $0x0,-0x9c(%rbp)
jmpq 1476 <func0+0x20d>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x20,%al
je 13f0 <func0+0x187>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x2c,%al
je 13f0 <func0+0x187>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
test %al,%al
jne 1443 <func0+0x1da>
cmpl $0x0,-0x98(%rbp)
jle 146f <func0+0x206>
mov -0x98(%rbp),%eax
cltq
movb $0x0,-0x80(%rbp,%rax,1)
mov -0x90(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x88(%rbp),%rax
lea (%rdx,%rax,1),%rbx
lea -0x80(%rbp),%rax
mov %rax,%rdi
callq 1160 <strdup@plt>
mov %rax,(%rbx)
addl $0x1,-0x90(%rbp)
movl $0x0,-0x98(%rbp)
jmp 146f <func0+0x206>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
lea (%rdx,%rax,1),%rcx
mov -0x98(%rbp),%eax
lea 0x1(%rax),%edx
mov %edx,-0x98(%rbp)
movzbl (%rcx),%edx
cltq
mov %dl,-0x80(%rbp,%rax,1)
addl $0x1,-0x9c(%rbp)
mov -0x9c(%rbp),%eax
cmp -0x8c(%rbp),%eax
jle 13a2 <func0+0x139>
jmpq 1578 <func0+0x30f>
movl $0x0,-0x9c(%rbp)
jmp 1510 <func0+0x2a7>
callq 1170 <__ctype_b_loc@plt>
mov (%rax),%rax
mov -0x9c(%rbp),%edx
movslq %edx,%rcx
mov -0xa8(%rbp),%rdx
add %rcx,%rdx
movzbl (%rdx),%edx
movsbq %dl,%rdx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x200,%eax
test %eax,%eax
je 1509 <func0+0x2a0>
mov -0x9c(%rbp),%eax
movslq %eax,%rdx
mov -0xa8(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
movsbl %al,%eax
lea -0x61(%rax),%edx
mov %edx,%eax
sar $0x1f,%eax
shr $0x1f,%eax
add %eax,%edx
and $0x1,%edx
sub %eax,%edx
mov %edx,%eax
cmp $0x1,%eax
jne 1509 <func0+0x2a0>
addl $0x1,-0x94(%rbp)
addl $0x1,-0x9c(%rbp)
mov -0x9c(%rbp),%eax
cmp -0x8c(%rbp),%eax
jl 1499 <func0+0x230>
mov $0x8,%edi
callq 1140 <malloc@plt>
mov %rax,-0x88(%rbp)
mov $0xc,%edi
callq 1140 <malloc@plt>
mov %rax,%rdx
mov -0x88(%rbp),%rax
mov %rdx,(%rax)
mov -0x88(%rbp),%rax
mov (%rax),%rax
mov -0x94(%rbp),%edx
lea 0xaa7(%rip),%rsi
mov %rax,%rdi
mov $0x0,%eax
callq 1150 <sprintf@plt>
movl $0x1,-0x90(%rbp)
mov -0xb0(%rbp),%rax
mov -0x90(%rbp),%edx
mov %edx,(%rax)
mov -0x88(%rbp),%rax
mov -0x18(%rbp),%rbx
xor %fs:0x28,%rbx
je 15a2 <func0+0x339>
callq 1100 <__stack_chk_fail@plt>
add $0xa8,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0A8h
mov [rbp+s], rdi
mov [rbp+var_B0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov [rbp+var_98], 0
mov [rbp+var_94], 0
mov [rbp+var_90], 0
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
mov [rbp+var_8C], eax
mov [rbp+var_88], 0
mov qword ptr [rbp+var_80], 0
mov [rbp+var_78], 0
mov [rbp+var_70], 0
mov [rbp+var_68], 0
mov [rbp+var_60], 0
mov [rbp+var_58], 0
mov [rbp+var_50], 0
mov [rbp+var_48], 0
mov [rbp+var_40], 0
mov [rbp+var_38], 0
mov [rbp+var_30], 0
mov [rbp+var_28], 0
mov [rbp+var_28+5], 0
mov rax, [rbp+s]
mov esi, 20h ; ' '; c
mov rdi, rax; s
call _strchr
test rax, rax
jnz short loc_1372
mov rax, [rbp+s]
mov esi, 2Ch ; ','; c
mov rdi, rax; s
call _strchr
test rax, rax
jz loc_148A
loc_1372:
mov eax, [rbp+var_8C]
add eax, 1
cdqe
shl rax, 3
mov rdi, rax; size
call _malloc
mov [rbp+var_88], rax
mov [rbp+var_9C], 0
jmp loc_1473
loc_139F:
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 20h ; ' '
jz short loc_13ED
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 2Ch ; ','
jz short loc_13ED
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
test al, al
jnz short loc_1440
loc_13ED:
cmp [rbp+var_98], 0
jle short loc_146C
mov eax, [rbp+var_98]
cdqe
mov [rbp+rax+var_80], 0
mov eax, [rbp+var_90]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_88]
lea rbx, [rdx+rax]
lea rax, [rbp+var_80]
mov rdi, rax; s
call _strdup
mov [rbx], rax
add [rbp+var_90], 1
mov [rbp+var_98], 0
jmp short loc_146C
loc_1440:
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+s]
lea rcx, [rdx+rax]
mov eax, [rbp+var_98]
lea edx, [rax+1]
mov [rbp+var_98], edx
movzx edx, byte ptr [rcx]
cdqe
mov [rbp+rax+var_80], dl
loc_146C:
add [rbp+var_9C], 1
loc_1473:
mov eax, [rbp+var_9C]
cmp eax, [rbp+var_8C]
jle loc_139F
jmp loc_1578
loc_148A:
mov [rbp+var_9C], 0
jmp short loc_150D
loc_1496:
call ___ctype_b_loc
mov rax, [rax]
mov edx, [rbp+var_9C]
movsxd rcx, edx
mov rdx, [rbp+s]
add rdx, rcx
movzx edx, byte ptr [rdx]
movsx rdx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 200h
test eax, eax
jz short loc_1506
mov eax, [rbp+var_9C]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
movsx eax, al
lea edx, [rax-61h]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_1506
add [rbp+var_94], 1
loc_1506:
add [rbp+var_9C], 1
loc_150D:
mov eax, [rbp+var_9C]
cmp eax, [rbp+var_8C]
jl loc_1496
mov edi, 8; size
call _malloc
mov [rbp+var_88], rax
mov edi, 0Ch; size
call _malloc
mov rdx, rax
mov rax, [rbp+var_88]
mov [rax], rdx
mov rax, [rbp+var_88]
mov rax, [rax]
mov edx, [rbp+var_94]
lea rcx, format; "%d"
mov rsi, rcx; format
mov rdi, rax; s
mov eax, 0
call _sprintf
mov [rbp+var_90], 1
loc_1578:
mov rax, [rbp+var_B0]
mov edx, [rbp+var_90]
mov [rax], edx
mov rax, [rbp+var_88]
mov rdx, [rbp+var_18]
sub rdx, fs:28h
jz short loc_15A2
call ___stack_chk_fail
loc_15A2:
mov rbx, [rbp+var_8]
leave
retn
|
char ** func0(const char *a1, int *a2)
{
int v2; // eax
int i; // [rsp+14h] [rbp-9Ch]
int j; // [rsp+14h] [rbp-9Ch]
int v6; // [rsp+18h] [rbp-98h]
int v7; // [rsp+1Ch] [rbp-94h]
int v8; // [rsp+20h] [rbp-90h]
int v9; // [rsp+24h] [rbp-8Ch]
char **v10; // [rsp+28h] [rbp-88h]
char v11[8]; // [rsp+30h] [rbp-80h] BYREF
long long v12; // [rsp+38h] [rbp-78h]
long long v13; // [rsp+40h] [rbp-70h]
long long v14; // [rsp+48h] [rbp-68h]
long long v15; // [rsp+50h] [rbp-60h]
long long v16; // [rsp+58h] [rbp-58h]
long long v17; // [rsp+60h] [rbp-50h]
long long v18; // [rsp+68h] [rbp-48h]
long long v19; // [rsp+70h] [rbp-40h]
long long v20; // [rsp+78h] [rbp-38h]
long long v21; // [rsp+80h] [rbp-30h]
_QWORD v22[4]; // [rsp+88h] [rbp-28h]
v22[2] = __readfsqword(0x28u);
v6 = 0;
v7 = 0;
v8 = 0;
v9 = strlen(a1);
*(_QWORD *)v11 = 0LL;
v12 = 0LL;
v13 = 0LL;
v14 = 0LL;
v15 = 0LL;
v16 = 0LL;
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22[0] = 0LL;
*(_QWORD *)((char *)v22 + 5) = 0LL;
if ( strchr(a1, 32) || strchr(a1, 44) )
{
v10 = (char **)malloc(8LL * (v9 + 1));
for ( i = 0; i <= v9; ++i )
{
if ( a1[i] == 32 || a1[i] == 44 || !a1[i] )
{
if ( v6 > 0 )
{
v11[v6] = 0;
v10[v8++] = strdup(v11);
v6 = 0;
}
}
else
{
v2 = v6++;
v11[v2] = a1[i];
}
}
}
else
{
for ( j = 0; j < v9; ++j )
{
if ( ((*__ctype_b_loc())[a1[j]] & 0x200) != 0 && (a1[j] - 97) % 2 == 1 )
++v7;
}
v10 = (char **)malloc(8uLL);
*v10 = (char *)malloc(0xCuLL);
sprintf(*v10, "%d", v7);
v8 = 1;
}
*a2 = v8;
return v10;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RBP + -0xa8],RDI
MOV qword ptr [RBP + -0xb0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x98],0x0
MOV dword ptr [RBP + -0x94],0x0
MOV dword ptr [RBP + -0x90],0x0
MOV RAX,qword ptr [RBP + -0xa8]
MOV RDI,RAX
CALL 0x001010f0
MOV dword ptr [RBP + -0x8c],EAX
MOV qword ptr [RBP + -0x88],0x0
MOV qword ptr [RBP + -0x80],0x0
MOV qword ptr [RBP + -0x78],0x0
MOV qword ptr [RBP + -0x70],0x0
MOV qword ptr [RBP + -0x68],0x0
MOV qword ptr [RBP + -0x60],0x0
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV qword ptr [RBP + -0x40],0x0
MOV qword ptr [RBP + -0x38],0x0
MOV qword ptr [RBP + -0x30],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV qword ptr [RBP + -0x23],0x0
MOV RAX,qword ptr [RBP + -0xa8]
MOV ESI,0x20
MOV RDI,RAX
CALL 0x00101110
TEST RAX,RAX
JNZ 0x00101372
MOV RAX,qword ptr [RBP + -0xa8]
MOV ESI,0x2c
MOV RDI,RAX
CALL 0x00101110
TEST RAX,RAX
JZ 0x0010148a
LAB_00101372:
MOV EAX,dword ptr [RBP + -0x8c]
ADD EAX,0x1
CDQE
SHL RAX,0x3
MOV RDI,RAX
CALL 0x00101140
MOV qword ptr [RBP + -0x88],RAX
MOV dword ptr [RBP + -0x9c],0x0
JMP 0x00101473
LAB_0010139f:
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x20
JZ 0x001013ed
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x2c
JZ 0x001013ed
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
TEST AL,AL
JNZ 0x00101440
LAB_001013ed:
CMP dword ptr [RBP + -0x98],0x0
JLE 0x0010146c
MOV EAX,dword ptr [RBP + -0x98]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x80],0x0
MOV EAX,dword ptr [RBP + -0x90]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x88]
LEA RBX,[RDX + RAX*0x1]
LEA RAX,[RBP + -0x80]
MOV RDI,RAX
CALL 0x00101160
MOV qword ptr [RBX],RAX
ADD dword ptr [RBP + -0x90],0x1
MOV dword ptr [RBP + -0x98],0x0
JMP 0x0010146c
LAB_00101440:
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
LEA RCX,[RDX + RAX*0x1]
MOV EAX,dword ptr [RBP + -0x98]
LEA EDX,[RAX + 0x1]
MOV dword ptr [RBP + -0x98],EDX
MOVZX EDX,byte ptr [RCX]
CDQE
MOV byte ptr [RBP + RAX*0x1 + -0x80],DL
LAB_0010146c:
ADD dword ptr [RBP + -0x9c],0x1
LAB_00101473:
MOV EAX,dword ptr [RBP + -0x9c]
CMP EAX,dword ptr [RBP + -0x8c]
JLE 0x0010139f
JMP 0x00101578
LAB_0010148a:
MOV dword ptr [RBP + -0x9c],0x0
JMP 0x0010150d
LAB_00101496:
CALL 0x00101170
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x9c]
MOVSXD RCX,EDX
MOV RDX,qword ptr [RBP + -0xa8]
ADD RDX,RCX
MOVZX EDX,byte ptr [RDX]
MOVSX RDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x200
TEST EAX,EAX
JZ 0x00101506
MOV EAX,dword ptr [RBP + -0x9c]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOVSX EAX,AL
LEA EDX,[RAX + -0x61]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x00101506
ADD dword ptr [RBP + -0x94],0x1
LAB_00101506:
ADD dword ptr [RBP + -0x9c],0x1
LAB_0010150d:
MOV EAX,dword ptr [RBP + -0x9c]
CMP EAX,dword ptr [RBP + -0x8c]
JL 0x00101496
MOV EDI,0x8
CALL 0x00101140
MOV qword ptr [RBP + -0x88],RAX
MOV EDI,0xc
CALL 0x00101140
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RAX],RDX
MOV RAX,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x94]
LEA RCX,[0x102008]
MOV RSI,RCX
MOV RDI,RAX
MOV EAX,0x0
CALL 0x00101150
MOV dword ptr [RBP + -0x90],0x1
LAB_00101578:
MOV RAX,qword ptr [RBP + -0xb0]
MOV EDX,dword ptr [RBP + -0x90]
MOV dword ptr [RAX],EDX
MOV RAX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x18]
SUB RDX,qword ptr FS:[0x28]
JZ 0x001015a2
CALL 0x00101100
LAB_001015a2:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int8 * func0(char *param_1,int *param_2)
{
int iVar1;
size_t sVar2;
char *pcVar3;
ushort **ppuVar4;
void *pvVar5;
long in_FS_OFFSET;
int local_a4;
int local_a0;
uint local_9c;
int local_98;
int8 *local_90;
char local_88 [104];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local_a0 = 0;
local_9c = 0;
local_98 = 0;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
local_88[0] = '\0';
local_88[1] = '\0';
local_88[2] = '\0';
local_88[3] = '\0';
local_88[4] = '\0';
local_88[5] = '\0';
local_88[6] = '\0';
local_88[7] = '\0';
local_88[8] = '\0';
local_88[9] = '\0';
local_88[10] = '\0';
local_88[0xb] = '\0';
local_88[0xc] = '\0';
local_88[0xd] = '\0';
local_88[0xe] = '\0';
local_88[0xf] = '\0';
local_88[0x10] = '\0';
local_88[0x11] = '\0';
local_88[0x12] = '\0';
local_88[0x13] = '\0';
local_88[0x14] = '\0';
local_88[0x15] = '\0';
local_88[0x16] = '\0';
local_88[0x17] = '\0';
local_88[0x18] = '\0';
local_88[0x19] = '\0';
local_88[0x1a] = '\0';
local_88[0x1b] = '\0';
local_88[0x1c] = '\0';
local_88[0x1d] = '\0';
local_88[0x1e] = '\0';
local_88[0x1f] = '\0';
local_88[0x20] = '\0';
local_88[0x21] = '\0';
local_88[0x22] = '\0';
local_88[0x23] = '\0';
local_88[0x24] = '\0';
local_88[0x25] = '\0';
local_88[0x26] = '\0';
local_88[0x27] = '\0';
local_88[0x28] = '\0';
local_88[0x29] = '\0';
local_88[0x2a] = '\0';
local_88[0x2b] = '\0';
local_88[0x2c] = '\0';
local_88[0x2d] = '\0';
local_88[0x2e] = '\0';
local_88[0x2f] = '\0';
local_88[0x30] = '\0';
local_88[0x31] = '\0';
local_88[0x32] = '\0';
local_88[0x33] = '\0';
local_88[0x34] = '\0';
local_88[0x35] = '\0';
local_88[0x36] = '\0';
local_88[0x37] = '\0';
local_88[0x38] = '\0';
local_88[0x39] = '\0';
local_88[0x3a] = '\0';
local_88[0x3b] = '\0';
local_88[0x3c] = '\0';
local_88[0x3d] = '\0';
local_88[0x3e] = '\0';
local_88[0x3f] = '\0';
local_88[0x40] = '\0';
local_88[0x41] = '\0';
local_88[0x42] = '\0';
local_88[0x43] = '\0';
local_88[0x44] = '\0';
local_88[0x45] = '\0';
local_88[0x46] = '\0';
local_88[0x47] = '\0';
local_88[0x48] = '\0';
local_88[0x49] = '\0';
local_88[0x4a] = '\0';
local_88[0x4b] = '\0';
local_88[0x4c] = '\0';
local_88[0x4d] = '\0';
local_88[0x4e] = '\0';
local_88[0x4f] = '\0';
local_88[0x50] = '\0';
local_88[0x51] = '\0';
local_88[0x52] = '\0';
local_88[0x53] = '\0';
local_88[0x54] = '\0';
local_88[0x55] = '\0';
local_88[0x56] = '\0';
local_88[0x57] = '\0';
local_88[0x58] = '\0';
local_88[0x59] = '\0';
local_88[0x5a] = '\0';
local_88[0x5b] = '\0';
local_88[0x5c] = '\0';
local_88[0x5d] = '\0';
local_88[0x5e] = '\0';
local_88[0x5f] = '\0';
local_88[0x60] = '\0';
local_88[0x61] = '\0';
local_88[0x62] = '\0';
local_88[99] = '\0';
local_88[100] = '\0';
pcVar3 = strchr(param_1,0x20);
if ((pcVar3 == (char *)0x0) && (pcVar3 = strchr(param_1,0x2c), pcVar3 == (char *)0x0)) {
for (local_a4 = 0; local_a4 < iVar1; local_a4 = local_a4 + 1) {
ppuVar4 = __ctype_b_loc();
if ((((*ppuVar4)[param_1[local_a4]] & 0x200) != 0) && ((param_1[local_a4] + -0x61) % 2 == 1))
{
local_9c = local_9c + 1;
}
}
local_90 = (int8 *)malloc(8);
pvVar5 = malloc(0xc);
*local_90 = pvVar5;
sprintf((char *)*local_90,"%d",(ulong)local_9c);
local_98 = 1;
}
else {
local_90 = (int8 *)malloc((long)(iVar1 + 1) << 3);
for (local_a4 = 0; local_a4 <= iVar1; local_a4 = local_a4 + 1) {
if (((param_1[local_a4] == ' ') || (param_1[local_a4] == ',')) || (param_1[local_a4] == '\0'))
{
if (0 < local_a0) {
local_88[local_a0] = '\0';
pcVar3 = strdup(local_88);
local_90[local_98] = pcVar3;
local_98 = local_98 + 1;
local_a0 = 0;
}
}
else {
local_88[local_a0] = param_1[local_a4];
local_a0 = local_a0 + 1;
}
}
}
*param_2 = local_98;
if (local_20 == *(long *)(in_FS_OFFSET + 0x28)) {
return local_90;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,157 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
|
char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (txt[i] == ' ' || txt[i] == ',' || txt[i] == '\0') {
if (j > 0) {
current[j] = '\0';
out[count] = strdup(current);
count++;
j = 0;
}
} else {
current[j++] = txt[i];
}
}
} else {
for (i = 0; i < len; ++i) {
if (islower(txt[i]) && ((txt[i] - 'a') % 2 == 1)) {
num++;
}
}
out = malloc(sizeof(char *));
out[0] = malloc(sizeof(char) * 12);
sprintf(out[0], "%d", num);
count = 1;
}
*returnSize = count;
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
for (int i = 0; i < size; i++) free(words[i]);
free(words);
}
int main() {
int size;
char *expected[3];
char **result;
result = func0("Hello world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("Hello,world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("abcdef", &size);
expected[0] = "3";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaabb", &size);
expected[0] = "2";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaaBb", &size);
expected[0] = "1";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("", &size);
expected[0] = "0";
assert(issame(expected, 1,result, size));
free_words(result, size);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x78,%rsp
mov %rdi,%r12
mov %rsi,%r14
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
mov $0xffffffffffffffff,%rcx
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbp
movq $0x0,(%rsp)
movq $0x0,0x8(%rsp)
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
movq $0x0,0x28(%rsp)
movq $0x0,0x30(%rsp)
movq $0x0,0x38(%rsp)
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x0,0x50(%rsp)
movq $0x0,0x58(%rsp)
movl $0x0,0x60(%rsp)
movb $0x0,0x64(%rsp)
mov $0x20,%esi
mov %r12,%rdi
callq 10f0 <strchr@plt>
test %rax,%rax
je 133e <func0+0xf5>
lea 0x1(%rbp),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 1120 <malloc@plt>
mov %rax,%r13
test %ebp,%ebp
js 145e <func0+0x215>
mov %r12,%rbx
mov %ebp,%ebp
lea 0x1(%r12,%rbp,1),%r12
mov $0x0,%ebp
mov $0x0,%edx
mov %rsp,%r15
jmp 1388 <func0+0x13f>
mov $0x2c,%esi
mov %r12,%rdi
callq 10f0 <strchr@plt>
test %rax,%rax
jne 130b <func0+0xc2>
mov $0x0,%ebx
test %ebp,%ebp
jle 13f8 <func0+0x1af>
callq 1140 <__ctype_b_loc@plt>
mov (%rax),%rdi
mov %r12,%rdx
lea -0x1(%rbp),%eax
lea 0x1(%r12,%rax,1),%rsi
mov $0x0,%ebx
jmp 13cb <func0+0x182>
test %edx,%edx
jg 139e <func0+0x155>
add $0x1,%rbx
cmp %r12,%rbx
je 1439 <func0+0x1f0>
movzbl (%rbx),%eax
test $0xdf,%al
je 1377 <func0+0x12e>
cmp $0x2c,%al
je 1377 <func0+0x12e>
movslq %edx,%rcx
mov %al,(%rsp,%rcx,1)
lea 0x1(%rdx),%edx
jmp 137b <func0+0x132>
movslq %edx,%rdx
movb $0x0,(%rsp,%rdx,1)
mov %r15,%rdi
callq 1130 <strdup@plt>
mov %rax,%rdx
movslq %ebp,%rax
mov %rdx,0x0(%r13,%rax,8)
add $0x1,%ebp
mov $0x0,%edx
jmp 137b <func0+0x132>
add $0x1,%rdx
cmp %rsi,%rdx
je 13f8 <func0+0x1af>
movzbl (%rdx),%eax
movsbq %al,%rcx
testb $0x2,0x1(%rdi,%rcx,2)
je 13c2 <func0+0x179>
movsbl %al,%eax
sub $0x61,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
and $0x1,%eax
sub %ecx,%eax
cmp $0x1,%eax
sete %al
movzbl %al,%eax
add %eax,%ebx
jmp 13c2 <func0+0x179>
mov $0x8,%edi
callq 1120 <malloc@plt>
mov %rax,%r13
mov $0xc,%edi
callq 1120 <malloc@plt>
mov %rax,%rdi
mov %rax,0x0(%r13)
mov %ebx,%r8d
lea 0xbe4(%rip),%rcx
mov $0xc,%edx
mov $0x1,%esi
mov $0x0,%eax
callq 1150 <__sprintf_chk@plt>
mov $0x1,%ebp
mov %ebp,(%r14)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 1465 <func0+0x21c>
mov %r13,%rax
add $0x78,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov $0x0,%ebp
jmp 1439 <func0+0x1f0>
callq 10e0 <__stack_chk_fail@plt>
|
func0:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r12, rdi
mov r15, rsi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
call _strlen
mov rbp, rax
mov [rsp+0A8h+var_A8], 0
mov [rsp+0A8h+var_A0], 0
mov [rsp+0A8h+var_98], 0
mov [rsp+0A8h+var_90], 0
mov [rsp+0A8h+var_88], 0
mov [rsp+0A8h+var_80], 0
mov [rsp+0A8h+var_78], 0
mov [rsp+0A8h+var_70], 0
mov [rsp+0A8h+var_68], 0
mov [rsp+0A8h+var_60], 0
mov [rsp+0A8h+var_58], 0
mov [rsp+0A8h+var_50], 0
mov [rsp+0A8h+var_50+5], 0
mov esi, 20h ; ' '; c
mov rdi, r12; s
call _strchr
test rax, rax
jz short loc_135A
loc_131F:
lea edi, [rbp+1]
movsxd rdi, edi
shl rdi, 3; size
call _malloc
mov r14, rax
test ebp, ebp
js loc_147A
mov rbx, r12
mov ebp, ebp
lea rbp, [r12+rbp+1]
mov r12d, 0
mov edx, 0
mov r13, 100100000001h
jmp short loc_13A9
loc_135A:
mov esi, 2Ch ; ','; c
mov rdi, r12; s
call _strchr
test rax, rax
jnz short loc_131F
mov ebx, 0
test ebp, ebp
jle loc_1414
call ___ctype_b_loc
mov rdi, [rax]
mov rdx, r12
lea eax, [rbp-1]
lea rsi, [r12+rax+1]
mov ebx, 0
jmp short loc_13E7
loc_1393:
movsxd rcx, edx
mov byte ptr [rsp+rcx+0A8h+var_A8], al
lea edx, [rdx+1]
loc_139C:
add rbx, 1
cmp rbp, rbx
jz loc_1455
loc_13A9:
movzx eax, byte ptr [rbx]
cmp al, 2Ch ; ','
ja short loc_1393
bt r13, rax
jnb short loc_1393
test edx, edx
jle short loc_139C
movsxd rdx, edx
mov byte ptr [rsp+rdx+0A8h+var_A8], 0
mov rdi, rsp; s
call _strdup
mov rdx, rax
movsxd rax, r12d
mov [r14+rax*8], rdx
add r12d, 1
mov edx, 0
jmp short loc_139C
loc_13DE:
add rdx, 1
cmp rdx, rsi
jz short loc_1414
loc_13E7:
movzx eax, byte ptr [rdx]
movsx rcx, al
test byte ptr [rdi+rcx*2+1], 2
jz short loc_13DE
movsx eax, al
sub eax, 61h ; 'a'
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
and eax, 1
sub eax, ecx
cmp eax, 1
setz al
movzx eax, al
add ebx, eax
jmp short loc_13DE
loc_1414:
mov edi, 8; size
call _malloc
mov r14, rax
mov edi, 0Ch; size
call _malloc
mov rdi, rax
mov [r14], rax
mov r8d, ebx
lea rcx, unk_2004
mov edx, 0Ch
mov esi, 2
mov eax, 0
call ___sprintf_chk
mov r12d, 1
loc_1455:
mov [r15], r12d
mov rax, [rsp+0A8h+var_40]
sub rax, fs:28h
jnz short loc_1482
mov rax, r14
add rsp, 78h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_147A:
mov r12d, 0
jmp short loc_1455
loc_1482:
call ___stack_chk_fail
|
_QWORD * func0(char *s, int *a2)
{
int v3; // ebp
_QWORD *v4; // r14
char *v5; // rbx
char *v6; // rbp
int v7; // r12d
int v8; // edx
long long v9; // r13
unsigned int v10; // ebx
const unsigned __int16 *v11; // rdi
char *v12; // rdx
unsigned long long v13; // rax
void *v14; // rax
long long v15; // r9
long long v17; // [rsp+0h] [rbp-A8h] BYREF
long long v18; // [rsp+8h] [rbp-A0h]
long long v19; // [rsp+10h] [rbp-98h]
long long v20; // [rsp+18h] [rbp-90h]
long long v21; // [rsp+20h] [rbp-88h]
long long v22; // [rsp+28h] [rbp-80h]
long long v23; // [rsp+30h] [rbp-78h]
long long v24; // [rsp+38h] [rbp-70h]
long long v25; // [rsp+40h] [rbp-68h]
long long v26; // [rsp+48h] [rbp-60h]
long long v27; // [rsp+50h] [rbp-58h]
__int128 v28; // [rsp+58h] [rbp-50h]
unsigned long long v29; // [rsp+68h] [rbp-40h]
v29 = __readfsqword(0x28u);
v3 = strlen(s);
v17 = 0LL;
v18 = 0LL;
v19 = 0LL;
v20 = 0LL;
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
v26 = 0LL;
v27 = 0LL;
*(_QWORD *)&v28 = 0LL;
*(_QWORD *)((char *)&v28 + 5) = 0LL;
if ( strchr(s, 32) || strchr(s, 44) )
{
v4 = malloc(8LL * (v3 + 1));
if ( v3 < 0 )
{
v7 = 0;
}
else
{
v5 = s;
v6 = &s[v3 + 1];
v7 = 0;
v8 = 0;
v9 = 0x100100000001LL;
do
{
v13 = (unsigned __int8)*v5;
if ( (unsigned __int8)v13 <= 0x2Cu && _bittest64(&v9, v13) )
{
if ( v8 > 0 )
{
*((_BYTE *)&v17 + v8) = 0;
v4[v7++] = strdup((const char *)&v17);
v8 = 0;
}
}
else
{
*((_BYTE *)&v17 + v8++) = v13;
}
++v5;
}
while ( v6 != v5 );
}
}
else
{
v10 = 0;
if ( v3 > 0 )
{
v11 = *__ctype_b_loc();
v12 = s;
v10 = 0;
do
{
if ( (v11[*v12] & 0x200) != 0 )
v10 += (*v12 - 97) % 2 == 1;
++v12;
}
while ( v12 != &s[v3 - 1 + 1] );
}
v4 = malloc(8uLL);
v14 = malloc(0xCuLL);
*v4 = v14;
__sprintf_chk(
v14,
2LL,
12LL,
&unk_2004,
v10,
v15,
v17,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25,
v26,
v27,
v28,
*((_QWORD *)&v28 + 1),
v29);
v7 = 1;
}
*a2 = v7;
return v4;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R12,RDI
MOV R15,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x001010f0
MOV RBP,RAX
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x5d],0x0
MOV ESI,0x20
MOV RDI,R12
CALL 0x00101110
TEST RAX,RAX
JZ 0x0010135a
LAB_0010131f:
LEA EDI,[RBP + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x00101140
MOV R14,RAX
TEST EBP,EBP
JS 0x0010147a
MOV RBX,R12
MOV EBP,EBP
LEA RBP,[R12 + RBP*0x1 + 0x1]
MOV R12D,0x0
MOV EDX,0x0
MOV R13,0x100100000001
JMP 0x001013a9
LAB_0010135a:
MOV ESI,0x2c
MOV RDI,R12
CALL 0x00101110
TEST RAX,RAX
JNZ 0x0010131f
MOV EBX,0x0
TEST EBP,EBP
JLE 0x00101414
CALL 0x00101160
MOV RDI,qword ptr [RAX]
MOV RDX,R12
LEA EAX,[RBP + -0x1]
LEA RSI,[R12 + RAX*0x1 + 0x1]
MOV EBX,0x0
JMP 0x001013e7
LAB_00101393:
MOVSXD RCX,EDX
MOV byte ptr [RSP + RCX*0x1],AL
LEA EDX,[RDX + 0x1]
LAB_0010139c:
ADD RBX,0x1
CMP RBP,RBX
JZ 0x00101455
LAB_001013a9:
MOVZX EAX,byte ptr [RBX]
CMP AL,0x2c
JA 0x00101393
BT R13,RAX
JNC 0x00101393
TEST EDX,EDX
JLE 0x0010139c
MOVSXD RDX,EDX
MOV byte ptr [RSP + RDX*0x1],0x0
MOV RDI,RSP
CALL 0x00101150
MOV RDX,RAX
MOVSXD RAX,R12D
MOV qword ptr [R14 + RAX*0x8],RDX
ADD R12D,0x1
MOV EDX,0x0
JMP 0x0010139c
LAB_001013de:
ADD RDX,0x1
CMP RDX,RSI
JZ 0x00101414
LAB_001013e7:
MOVZX EAX,byte ptr [RDX]
MOVSX RCX,AL
TEST byte ptr [RDI + RCX*0x2 + 0x1],0x2
JZ 0x001013de
MOVSX EAX,AL
SUB EAX,0x61
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
AND EAX,0x1
SUB EAX,ECX
CMP EAX,0x1
SETZ AL
MOVZX EAX,AL
ADD EBX,EAX
JMP 0x001013de
LAB_00101414:
MOV EDI,0x8
CALL 0x00101140
MOV R14,RAX
MOV EDI,0xc
CALL 0x00101140
MOV RDI,RAX
MOV qword ptr [R14],RAX
MOV R8D,EBX
LEA RCX,[0x102004]
MOV EDX,0xc
MOV ESI,0x2
MOV EAX,0x0
CALL 0x00101170
MOV R12D,0x1
LAB_00101455:
MOV dword ptr [R15],R12D
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101482
MOV RAX,R14
ADD RSP,0x78
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_0010147a:
MOV R12D,0x0
JMP 0x00101455
LAB_00101482:
CALL 0x00101100
|
int8 * func0(byte *param_1,int *param_2)
{
byte *pbVar1;
byte bVar2;
size_t sVar3;
char *pcVar4;
int8 *puVar5;
ushort **ppuVar6;
void *pvVar7;
int iVar8;
int iVar9;
long in_FS_OFFSET;
byte local_a8 [104];
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen((char *)param_1);
local_a8[0] = 0;
local_a8[1] = 0;
local_a8[2] = 0;
local_a8[3] = 0;
local_a8[4] = 0;
local_a8[5] = 0;
local_a8[6] = 0;
local_a8[7] = 0;
local_a8[8] = 0;
local_a8[9] = 0;
local_a8[10] = 0;
local_a8[0xb] = 0;
local_a8[0xc] = 0;
local_a8[0xd] = 0;
local_a8[0xe] = 0;
local_a8[0xf] = 0;
local_a8[0x10] = 0;
local_a8[0x11] = 0;
local_a8[0x12] = 0;
local_a8[0x13] = 0;
local_a8[0x14] = 0;
local_a8[0x15] = 0;
local_a8[0x16] = 0;
local_a8[0x17] = 0;
local_a8[0x18] = 0;
local_a8[0x19] = 0;
local_a8[0x1a] = 0;
local_a8[0x1b] = 0;
local_a8[0x1c] = 0;
local_a8[0x1d] = 0;
local_a8[0x1e] = 0;
local_a8[0x1f] = 0;
local_a8[0x20] = 0;
local_a8[0x21] = 0;
local_a8[0x22] = 0;
local_a8[0x23] = 0;
local_a8[0x24] = 0;
local_a8[0x25] = 0;
local_a8[0x26] = 0;
local_a8[0x27] = 0;
local_a8[0x28] = 0;
local_a8[0x29] = 0;
local_a8[0x2a] = 0;
local_a8[0x2b] = 0;
local_a8[0x2c] = 0;
local_a8[0x2d] = 0;
local_a8[0x2e] = 0;
local_a8[0x2f] = 0;
local_a8[0x30] = 0;
local_a8[0x31] = 0;
local_a8[0x32] = 0;
local_a8[0x33] = 0;
local_a8[0x34] = 0;
local_a8[0x35] = 0;
local_a8[0x36] = 0;
local_a8[0x37] = 0;
local_a8[0x38] = 0;
local_a8[0x39] = 0;
local_a8[0x3a] = 0;
local_a8[0x3b] = 0;
local_a8[0x3c] = 0;
local_a8[0x3d] = 0;
local_a8[0x3e] = 0;
local_a8[0x3f] = 0;
local_a8[0x40] = 0;
local_a8[0x41] = 0;
local_a8[0x42] = 0;
local_a8[0x43] = 0;
local_a8[0x44] = 0;
local_a8[0x45] = 0;
local_a8[0x46] = 0;
local_a8[0x47] = 0;
local_a8[0x48] = 0;
local_a8[0x49] = 0;
local_a8[0x4a] = 0;
local_a8[0x4b] = 0;
local_a8[0x4c] = 0;
local_a8[0x4d] = 0;
local_a8[0x4e] = 0;
local_a8[0x4f] = 0;
local_a8[0x50] = 0;
local_a8[0x51] = 0;
local_a8[0x52] = 0;
local_a8[0x53] = 0;
local_a8[0x54] = 0;
local_a8[0x55] = 0;
local_a8[0x56] = 0;
local_a8[0x57] = 0;
local_a8[0x58] = 0;
local_a8[0x59] = 0;
local_a8[0x5a] = 0;
local_a8[0x5b] = 0;
local_a8[0x5c] = 0;
local_a8[0x5d] = 0;
local_a8[0x5e] = 0;
local_a8[0x5f] = 0;
local_a8[0x60] = 0;
local_a8[0x61] = 0;
local_a8[0x62] = 0;
local_a8[99] = 0;
local_a8[100] = 0;
pcVar4 = strchr((char *)param_1,0x20);
iVar9 = (int)sVar3;
if (pcVar4 == (char *)0x0) {
pcVar4 = strchr((char *)param_1,0x2c);
if (pcVar4 == (char *)0x0) {
iVar8 = 0;
if (0 < iVar9) {
ppuVar6 = __ctype_b_loc();
pbVar1 = param_1 + (ulong)(iVar9 - 1) + 1;
iVar8 = 0;
do {
if ((*(byte *)((long)*ppuVar6 + (long)(char)*param_1 * 2 + 1) & 2) != 0) {
iVar8 = iVar8 + (uint)(((char)*param_1 + -0x61) % 2 == 1);
}
param_1 = param_1 + 1;
} while (param_1 != pbVar1);
}
puVar5 = (int8 *)malloc(8);
pvVar7 = malloc(0xc);
*puVar5 = pvVar7;
__sprintf_chk(pvVar7,2,0xc,&DAT_00102004,iVar8);
iVar9 = 1;
goto LAB_00101455;
}
}
puVar5 = (int8 *)malloc((long)(iVar9 + 1) << 3);
if (iVar9 < 0) {
iVar9 = 0;
}
else {
pbVar1 = param_1 + (sVar3 & 0xffffffff) + 1;
iVar9 = 0;
iVar8 = 0;
do {
bVar2 = *param_1;
if ((bVar2 < 0x2d) && ((0x100100000001U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) {
if (0 < iVar8) {
local_a8[iVar8] = 0;
pcVar4 = strdup((char *)local_a8);
puVar5[iVar9] = pcVar4;
iVar9 = iVar9 + 1;
iVar8 = 0;
}
}
else {
local_a8[iVar8] = bVar2;
iVar8 = iVar8 + 1;
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
}
LAB_00101455:
*param_2 = iVar9;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,158 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
|
char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (txt[i] == ' ' || txt[i] == ',' || txt[i] == '\0') {
if (j > 0) {
current[j] = '\0';
out[count] = strdup(current);
count++;
j = 0;
}
} else {
current[j++] = txt[i];
}
}
} else {
for (i = 0; i < len; ++i) {
if (islower(txt[i]) && ((txt[i] - 'a') % 2 == 1)) {
num++;
}
}
out = malloc(sizeof(char *));
out[0] = malloc(sizeof(char) * 12);
sprintf(out[0], "%d", num);
count = 1;
}
*returnSize = count;
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
for (int i = 0; i < size; i++) free(words[i]);
free(words);
}
int main() {
int size;
char *expected[3];
char **result;
result = func0("Hello world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("Hello,world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("abcdef", &size);
expected[0] = "3";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaabb", &size);
expected[0] = "2";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaaBb", &size);
expected[0] = "1";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("", &size);
expected[0] = "0";
assert(issame(expected, 1,result, size));
free_words(result, size);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
pxor %xmm0,%xmm0
mov %rbx,%rdi
mov $0x20,%esi
movl $0x0,0x60(%rsp)
mov %rax,%r12
movb $0x0,0x64(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
callq 1110 <strchr@plt>
test %rax,%rax
je 16e8 <func0+0x128>
lea 0x1(%r12),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 1140 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
js 1798 <func0+0x1d8>
mov %r12d,%r12d
xor %edx,%edx
mov %rsp,%r15
lea 0x1(%rbx,%r12,1),%r13
xor %r12d,%r12d
jmp 1694 <func0+0xd4>
nopl 0x0(%rax,%rax,1)
test %edx,%edx
je 168b <func0+0xcb>
movslq %edx,%rdx
mov %r15,%rdi
movb $0x0,(%rsp,%rdx,1)
callq 1150 <strdup@plt>
xor %edx,%edx
mov %rax,%r8
movslq %r12d,%rax
add $0x1,%r12d
mov %r8,(%r14,%rax,8)
add $0x1,%rbx
cmp %rbx,%r13
je 16b8 <func0+0xf8>
movzbl (%rbx),%eax
test $0xdf,%al
je 1668 <func0+0xa8>
cmp $0x2c,%al
je 1668 <func0+0xa8>
movslq %edx,%rcx
add $0x1,%rbx
add $0x1,%edx
mov %al,(%rsp,%rcx,1)
cmp %rbx,%r13
jne 1694 <func0+0xd4>
nopl 0x0(%rax)
mov %r12d,0x0(%rbp)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 17a5 <func0+0x1e5>
add $0x78,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov $0x2c,%esi
mov %rbx,%rdi
callq 1110 <strchr@plt>
test %rax,%rax
jne 1634 <func0+0x74>
test %r12d,%r12d
jle 17a0 <func0+0x1e0>
callq 1160 <__ctype_b_loc@plt>
mov (%rax),%rsi
lea -0x1(%r12),%eax
xor %r12d,%r12d
lea 0x1(%rbx,%rax,1),%rcx
nopl 0x0(%rax)
movsbq (%rbx),%rdx
mov %rdx,%rax
testb $0x2,0x1(%rsi,%rdx,2)
je 1749 <func0+0x189>
sub $0x61,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
sete %al
movzbl %al,%eax
add %eax,%r12d
add $0x1,%rbx
cmp %rbx,%rcx
jne 1720 <func0+0x160>
mov $0x8,%edi
callq 1140 <malloc@plt>
mov $0xc,%edi
mov %rax,%r14
callq 1140 <malloc@plt>
mov %r12d,%r8d
mov $0xc,%edx
lea 0x88c(%rip),%rcx
mov %rax,(%r14)
mov %rax,%rdi
xor %eax,%eax
mov $0x1,%esi
mov $0x1,%r12d
callq 1170 <__sprintf_chk@plt>
jmpq 16b8 <func0+0xf8>
nopl (%rax)
xor %r12d,%r12d
jmpq 16b8 <func0+0xf8>
xor %r12d,%r12d
jmp 1752 <func0+0x192>
callq 1100 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
call _strlen
pxor xmm0, xmm0
mov esi, 20h ; ' '; c
mov rdi, rbx; s
movaps [rsp+0A8h+var_58], xmm0
mov r13, rax
mov qword ptr [rsp+0A8h+var_58+0Dh], 0
movaps [rsp+0A8h+var_A8], xmm0
movaps [rsp+0A8h+var_98], xmm0
movaps [rsp+0A8h+var_88], xmm0
movaps [rsp+0A8h+var_78], xmm0
movaps [rsp+0A8h+var_68], xmm0
call _strchr
test rax, rax
jz loc_16E0
loc_1630:
lea edi, [r13+1]
movsxd rdi, edi
shl rdi, 3; size
call _malloc
mov rbp, rax
test r13d, r13d
js loc_1790
mov r13d, r13d
xor r14d, r14d
xor edx, edx
mov r15, 100100000001h
lea r13, [rbx+r13+1]
jmp short loc_169B
loc_1668:
bt r15, rax
jnb short loc_16A2
test edx, edx
jle short loc_1692
movsxd rdx, edx
mov rdi, rsp; s
mov byte ptr [rsp+rdx+0A8h+var_A8], 0
call _strdup
mov rdx, rax
movsxd rax, r14d
add r14d, 1
mov [rbp+rax*8+0], rdx
xor edx, edx
loc_1692:
add rbx, 1
cmp r13, rbx
jz short loc_16B4
loc_169B:
movzx eax, byte ptr [rbx]
cmp al, 2Ch ; ','
jbe short loc_1668
loc_16A2:
movsxd rcx, edx
add rbx, 1
add edx, 1
mov byte ptr [rsp+rcx+0A8h+var_A8], al
cmp r13, rbx
jnz short loc_169B
loc_16B4:
mov [r12], r14d
mov rax, [rsp+0A8h+var_40]
sub rax, fs:28h
jnz loc_179D
add rsp, 78h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_16E0:
mov esi, 2Ch ; ','; c
mov rdi, rbx; s
call _strchr
test rax, rax
jnz loc_1630
test r13d, r13d
jle loc_1798
call ___ctype_b_loc
mov rsi, [rax]
lea eax, [r13-1]
xor r13d, r13d
lea rcx, [rbx+rax+1]
nop dword ptr [rax+rax+00h]
loc_1718:
movsx rdx, byte ptr [rbx]
mov rax, rdx
test byte ptr [rsi+rdx*2+1], 2
jz short loc_1741
sub eax, 61h ; 'a'
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
cmp eax, 1
setz al
movzx eax, al
add r13d, eax
loc_1741:
add rbx, 1
cmp rcx, rbx
jnz short loc_1718
loc_174A:
mov edi, 8; size
mov r14d, 1
call _malloc
mov edi, 0Ch; size
mov rbp, rax
call _malloc
mov r8d, r13d
mov edx, 0Ch
lea rcx, unk_2004
mov [rbp+0], rax
mov rdi, rax
mov esi, 2
xor eax, eax
call ___sprintf_chk
jmp loc_16B4
loc_1790:
xor r14d, r14d
jmp loc_16B4
loc_1798:
xor r13d, r13d
jmp short loc_174A
loc_179D:
call ___stack_chk_fail
|
_QWORD * func0(char *s, int *a2)
{
char *v3; // rbx
int v4; // r13d
_QWORD *v5; // rbp
int v6; // r14d
int v7; // edx
long long v8; // r15
char *v9; // r13
char *v10; // rdx
long long v11; // rax
unsigned long long v12; // rax
long long v13; // rcx
const unsigned __int16 *v15; // rsi
long long v16; // rax
unsigned int v17; // r13d
long long v18; // rdx
void *v19; // rax
long long v20; // r9
__int128 v21; // [rsp+0h] [rbp-A8h] BYREF
__int128 v22; // [rsp+10h] [rbp-98h]
__int128 v23; // [rsp+20h] [rbp-88h]
__int128 v24; // [rsp+30h] [rbp-78h]
__int128 v25; // [rsp+40h] [rbp-68h]
_QWORD v26[3]; // [rsp+50h] [rbp-58h] BYREF
unsigned long long v27; // [rsp+68h] [rbp-40h]
v3 = s;
v27 = __readfsqword(0x28u);
memset(v26, 0, 21);
v4 = strlen(s);
v21 = 0LL;
v22 = 0LL;
v23 = 0LL;
v24 = 0LL;
v25 = 0LL;
if ( strchr(s, 32) || strchr(s, 44) )
{
v5 = malloc(8LL * (v4 + 1));
if ( v4 < 0 )
{
v6 = 0;
}
else
{
v6 = 0;
v7 = 0;
v8 = 0x100100000001LL;
v9 = &s[v4 + 1];
do
{
while ( 1 )
{
v12 = (unsigned __int8)*v3;
if ( (unsigned __int8)v12 <= 0x2Cu )
{
if ( _bittest64(&v8, v12) )
break;
}
v13 = v7;
++v3;
++v7;
*((_BYTE *)&v21 + v13) = v12;
if ( v9 == v3 )
goto LABEL_10;
}
if ( v7 > 0 )
{
*((_BYTE *)&v21 + v7) = 0;
v10 = strdup((const char *)&v21);
v11 = v6++;
v5[v11] = v10;
v7 = 0;
}
++v3;
}
while ( v9 != v3 );
}
}
else
{
if ( v4 <= 0 )
{
v17 = 0;
}
else
{
v15 = *__ctype_b_loc();
v16 = (unsigned int)(v4 - 1);
v17 = 0;
do
{
v18 = *v3;
if ( (v15[v18] & 0x200) != 0 )
v17 += ((int)v18 - 97) % 2 == 1;
++v3;
}
while ( &s[v16 + 1] != v3 );
}
v6 = 1;
v5 = malloc(8uLL);
v19 = malloc(0xCuLL);
*v5 = v19;
__sprintf_chk(
v19,
2LL,
12LL,
&unk_2004,
v17,
v20,
v21,
*((_QWORD *)&v21 + 1),
v22,
*((_QWORD *)&v22 + 1),
v23,
*((_QWORD *)&v23 + 1),
v24,
*((_QWORD *)&v24 + 1),
v25,
*((_QWORD *)&v25 + 1),
v26[0],
v26[1],
v26[2],
v27);
}
LABEL_10:
*a2 = v6;
return v5;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
CALL 0x001010f0
PXOR XMM0,XMM0
MOV ESI,0x20
MOV RDI,RBX
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOV R13,RAX
MOV qword ptr [RSP + 0x5d],0x0
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CALL 0x00101110
TEST RAX,RAX
JZ 0x001016e0
LAB_00101630:
LEA EDI,[R13 + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x00101140
MOV RBP,RAX
TEST R13D,R13D
JS 0x00101790
MOV R13D,R13D
XOR R14D,R14D
XOR EDX,EDX
MOV R15,0x100100000001
LEA R13,[RBX + R13*0x1 + 0x1]
JMP 0x0010169b
LAB_00101668:
BT R15,RAX
JNC 0x001016a2
TEST EDX,EDX
JLE 0x00101692
MOVSXD RDX,EDX
MOV RDI,RSP
MOV byte ptr [RSP + RDX*0x1],0x0
CALL 0x00101150
MOV RDX,RAX
MOVSXD RAX,R14D
ADD R14D,0x1
MOV qword ptr [RBP + RAX*0x8],RDX
XOR EDX,EDX
LAB_00101692:
ADD RBX,0x1
CMP R13,RBX
JZ 0x001016b4
LAB_0010169b:
MOVZX EAX,byte ptr [RBX]
CMP AL,0x2c
JBE 0x00101668
LAB_001016a2:
MOVSXD RCX,EDX
ADD RBX,0x1
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1],AL
CMP R13,RBX
JNZ 0x0010169b
LAB_001016b4:
MOV dword ptr [R12],R14D
MOV RAX,qword ptr [RSP + 0x68]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x0010179d
ADD RSP,0x78
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_001016e0:
MOV ESI,0x2c
MOV RDI,RBX
CALL 0x00101110
TEST RAX,RAX
JNZ 0x00101630
TEST R13D,R13D
JLE 0x00101798
CALL 0x00101160
MOV RSI,qword ptr [RAX]
LEA EAX,[R13 + -0x1]
XOR R13D,R13D
LEA RCX,[RBX + RAX*0x1 + 0x1]
NOP dword ptr [RAX + RAX*0x1]
LAB_00101718:
MOVSX RDX,byte ptr [RBX]
MOV RAX,RDX
TEST byte ptr [RSI + RDX*0x2 + 0x1],0x2
JZ 0x00101741
SUB EAX,0x61
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
SETZ AL
MOVZX EAX,AL
ADD R13D,EAX
LAB_00101741:
ADD RBX,0x1
CMP RCX,RBX
JNZ 0x00101718
LAB_0010174a:
MOV EDI,0x8
MOV R14D,0x1
CALL 0x00101140
MOV EDI,0xc
MOV RBP,RAX
CALL 0x00101140
MOV R8D,R13D
MOV EDX,0xc
LEA RCX,[0x102004]
MOV qword ptr [RBP],RAX
MOV RDI,RAX
MOV ESI,0x2
XOR EAX,EAX
CALL 0x00101170
JMP 0x001016b4
LAB_00101790:
XOR R14D,R14D
JMP 0x001016b4
LAB_00101798:
XOR R13D,R13D
JMP 0x0010174a
LAB_0010179d:
CALL 0x00101100
|
int8 * func0(byte *param_1,int *param_2)
{
byte *pbVar1;
byte bVar2;
size_t sVar3;
char *pcVar4;
int8 *puVar5;
ushort **ppuVar6;
void *pvVar7;
long lVar8;
int iVar9;
int iVar10;
long in_FS_OFFSET;
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [13];
int3 uStack_4b;
int5 uStack_48;
long local_40;
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar3 = strlen((char *)param_1);
local_58 = SUB1613((int [16])0x0,0);
uStack_4b = 0;
uStack_48 = 0;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
pcVar4 = strchr((char *)param_1,0x20);
iVar10 = (int)sVar3;
if (pcVar4 == (char *)0x0) {
pcVar4 = strchr((char *)param_1,0x2c);
if (pcVar4 == (char *)0x0) {
if (iVar10 < 1) {
iVar9 = 0;
}
else {
ppuVar6 = __ctype_b_loc();
iVar9 = 0;
pbVar1 = param_1 + (ulong)(iVar10 - 1) + 1;
do {
if ((*(byte *)((long)*ppuVar6 + (long)(char)*param_1 * 2 + 1) & 2) != 0) {
iVar9 = iVar9 + (uint)(((char)*param_1 + -0x61) % 2 == 1);
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
}
iVar10 = 1;
puVar5 = (int8 *)malloc(8);
pvVar7 = malloc(0xc);
*puVar5 = pvVar7;
__sprintf_chk(pvVar7,2,0xc,&DAT_00102004,iVar9);
goto LAB_001016b4;
}
}
puVar5 = (int8 *)malloc((long)(iVar10 + 1) << 3);
if (iVar10 < 0) {
iVar10 = 0;
}
else {
iVar10 = 0;
iVar9 = 0;
pbVar1 = param_1 + (sVar3 & 0xffffffff) + 1;
do {
while( true ) {
bVar2 = *param_1;
if ((bVar2 < 0x2d) && ((0x100100000001U >> ((ulong)bVar2 & 0x3f) & 1) != 0)) break;
lVar8 = (long)iVar9;
param_1 = param_1 + 1;
iVar9 = iVar9 + 1;
local_a8[lVar8] = bVar2;
if (pbVar1 == param_1) goto LAB_001016b4;
}
if (0 < iVar9) {
local_a8[iVar9] = 0;
pcVar4 = strdup(local_a8);
lVar8 = (long)iVar10;
iVar10 = iVar10 + 1;
puVar5[lVar8] = pcVar4;
iVar9 = 0;
}
param_1 = param_1 + 1;
} while (pbVar1 != param_1);
}
LAB_001016b4:
*param_2 = iVar10;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,159 |
func0
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
|
char **func0(const char *txt, int *returnSize) {
int i, j = 0, num = 0, count = 0;
int len = strlen(txt);
char **out = NULL;
char current[101] = {0};
if (strchr(txt, ' ') || strchr(txt, ',')) {
out = malloc(sizeof(char *) * (len + 1));
for (i = 0; i <= len; ++i) {
if (txt[i] == ' ' || txt[i] == ',' || txt[i] == '\0') {
if (j > 0) {
current[j] = '\0';
out[count] = strdup(current);
count++;
j = 0;
}
} else {
current[j++] = txt[i];
}
}
} else {
for (i = 0; i < len; ++i) {
if (islower(txt[i]) && ((txt[i] - 'a') % 2 == 1)) {
num++;
}
}
out = malloc(sizeof(char *));
out[0] = malloc(sizeof(char) * 12);
sprintf(out[0], "%d", num);
count = 1;
}
*returnSize = count;
return out;
}
|
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
int issame(char **a, int aSize, char **b, int bSize) {
if (aSize != bSize) return 0;
for (int i = 0; i < aSize; i++) {
if (strcmp(a[i], b[i]) != 0) return 0;
}
return 1;
}
void free_words(char **words, int size) {
for (int i = 0; i < size; i++) free(words[i]);
free(words);
}
int main() {
int size;
char *expected[3];
char **result;
result = func0("Hello world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("Hello,world!", &size);
expected[0] = "Hello";
expected[1] = "world!";
assert(issame(expected, 2,result, size));
free_words(result, size);
result = func0("abcdef", &size);
expected[0] = "3";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaabb", &size);
expected[0] = "2";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("aaaBb", &size);
expected[0] = "1";
assert(issame(expected, 1,result, size));
free_words(result, size);
result = func0("", &size);
expected[0] = "0";
assert(issame(expected, 1,result, size));
free_words(result, size);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rsi,%rbp
push %rbx
mov %rdi,%rbx
sub $0x78,%rsp
mov %fs:0x28,%rax
mov %rax,0x68(%rsp)
xor %eax,%eax
callq 10f0 <strlen@plt>
pxor %xmm0,%xmm0
mov %rbx,%rdi
mov $0x20,%esi
movl $0x0,0x60(%rsp)
mov %rax,%r12
movb $0x0,0x64(%rsp)
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
callq 1110 <strchr@plt>
test %rax,%rax
je 16f8 <func0+0x128>
lea 0x1(%r12),%edi
movslq %edi,%rdi
shl $0x3,%rdi
callq 1140 <malloc@plt>
mov %rax,%r14
test %r12d,%r12d
js 17a8 <func0+0x1d8>
mov %r12d,%r12d
xor %edx,%edx
mov %rsp,%r15
lea 0x1(%rbx,%r12,1),%r13
xor %r12d,%r12d
jmp 16a4 <func0+0xd4>
nopl 0x0(%rax,%rax,1)
test %edx,%edx
je 169b <func0+0xcb>
movslq %edx,%rdx
mov %r15,%rdi
movb $0x0,(%rsp,%rdx,1)
callq 1150 <strdup@plt>
xor %edx,%edx
mov %rax,%r8
movslq %r12d,%rax
add $0x1,%r12d
mov %r8,(%r14,%rax,8)
add $0x1,%rbx
cmp %rbx,%r13
je 16c8 <func0+0xf8>
movzbl (%rbx),%eax
test $0xdf,%al
je 1678 <func0+0xa8>
cmp $0x2c,%al
je 1678 <func0+0xa8>
movslq %edx,%rcx
add $0x1,%rbx
add $0x1,%edx
mov %al,(%rsp,%rcx,1)
cmp %rbx,%r13
jne 16a4 <func0+0xd4>
nopl 0x0(%rax)
mov %r12d,0x0(%rbp)
mov 0x68(%rsp),%rax
xor %fs:0x28,%rax
jne 17b5 <func0+0x1e5>
add $0x78,%rsp
mov %r14,%rax
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
nopw 0x0(%rax,%rax,1)
mov $0x2c,%esi
mov %rbx,%rdi
callq 1110 <strchr@plt>
test %rax,%rax
jne 1644 <func0+0x74>
test %r12d,%r12d
jle 17b0 <func0+0x1e0>
callq 1160 <__ctype_b_loc@plt>
mov (%rax),%rsi
lea -0x1(%r12),%eax
xor %r12d,%r12d
lea 0x1(%rbx,%rax,1),%rcx
nopl 0x0(%rax)
movsbq (%rbx),%rdx
mov %rdx,%rax
testb $0x2,0x1(%rsi,%rdx,2)
je 1759 <func0+0x189>
sub $0x61,%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
sete %al
movzbl %al,%eax
add %eax,%r12d
add $0x1,%rbx
cmp %rbx,%rcx
jne 1730 <func0+0x160>
mov $0x8,%edi
callq 1140 <malloc@plt>
mov $0xc,%edi
mov %rax,%r14
callq 1140 <malloc@plt>
mov %r12d,%r8d
mov $0xc,%edx
lea 0x87c(%rip),%rcx
mov %rax,(%r14)
mov %rax,%rdi
xor %eax,%eax
mov $0x1,%esi
mov $0x1,%r12d
callq 1170 <__sprintf_chk@plt>
jmpq 16c8 <func0+0xf8>
nopl (%rax)
xor %r12d,%r12d
jmpq 16c8 <func0+0xf8>
xor %r12d,%r12d
jmp 1762 <func0+0x192>
callq 1100 <__stack_chk_fail@plt>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
push r14
push r13
push r12
mov r12, rsi
push rbp
push rbx
mov rbx, rdi
sub rsp, 168h
mov rax, fs:28h
mov [rsp+198h+var_40], rax
xor eax, eax
call _strlen
pxor xmm0, xmm0
mov esi, 20h ; ' '; c
mov rdi, rbx; s
movaps [rsp+198h+var_58], xmm0
mov r13, rax
mov qword ptr [rsp+198h+var_58+0Dh], 0
movaps xmmword ptr [rsp+198h+s], xmm0
movaps [rsp+198h+var_98], xmm0
movaps [rsp+198h+var_88], xmm0
movaps [rsp+198h+var_78], xmm0
movaps [rsp+198h+var_68], xmm0
call _strchr
test rax, rax
jz loc_1718
loc_164C:
lea edi, [r13+1]
movsxd rdi, edi
shl rdi, 3; size
call _malloc
mov rbp, rax
test r13d, r13d
js loc_1E98
mov r13d, r13d
xor r14d, r14d
xor edx, edx
mov r15, 100100000001h
lea r13, [rbx+r13+1]
jmp short loc_16C4
loc_1688:
bt r15, rax
jnb short loc_16CB
test edx, edx
jle short loc_16BB
movsxd rdx, edx
lea rdi, [rsp+198h+s]; s
mov [rsp+rdx+198h+s], 0
call _strdup
mov rdx, rax
movsxd rax, r14d
add r14d, 1
mov [rbp+rax*8+0], rdx
xor edx, edx
loc_16BB:
add rbx, 1
cmp r13, rbx
jz short loc_16E1
loc_16C4:
movzx eax, byte ptr [rbx]
cmp al, 2Ch ; ','
jbe short loc_1688
loc_16CB:
movsxd rcx, edx
add rbx, 1
add edx, 1
mov [rsp+rcx+198h+s], al
cmp r13, rbx
jnz short loc_16C4
loc_16E1:
mov [r12], r14d
mov rax, [rsp+198h+var_40]
sub rax, fs:28h
jnz loc_1F50
add rsp, 168h
mov rax, rbp
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1718:
mov esi, 2Ch ; ','; c
mov rdi, rbx; s
call _strchr
test rax, rax
jnz loc_164C
xor r14d, r14d
test r13d, r13d
jle loc_1E50
call ___ctype_b_loc
lea edx, [r13-1]
mov rax, [rax]
cmp edx, 0Eh
jbe loc_1F40
mov esi, r13d
mov rcx, rbx
pxor xmm3, xmm3
movdqa xmm7, cs:xmmword_30C0
shr esi, 4
pxor xmm8, xmm8
pxor xmm4, xmm4
movdqa xmm6, cs:xmmword_30D0
shl rsi, 4
movdqa xmm5, cs:xmmword_30E0
add rsi, rbx
nop dword ptr [rax+00h]
loc_1788:
movdqu xmm0, xmmword ptr [rcx]
add rcx, 10h
movd edx, xmm0
movaps [rsp+198h+var_B8], xmm0
movsx r14, byte ptr [rsp+198h+var_B8+1]
movdqa xmm13, xmm0
movsx rdx, dl
movaps [rsp+198h+var_C8], xmm0
movsx rbp, byte ptr [rsp+198h+var_C8+2]
movaps [rsp+198h+var_D8], xmm0
movsx r11, byte ptr [rsp+198h+var_D8+3]
movaps [rsp+198h+var_E8], xmm0
movsx r10, byte ptr [rsp+198h+var_E8+4]
movaps [rsp+198h+var_F8], xmm0
movsx r9, byte ptr [rsp+198h+var_F8+5]
movaps [rsp+198h+var_108], xmm0
movsx r8, byte ptr [rsp+198h+var_108+6]
movaps [rsp+198h+var_118], xmm0
movzx edx, word ptr [rax+rdx*2]
movsx rdi, byte ptr [rsp+198h+var_118+7]
movd xmm14, edx
movzx edx, word ptr [rax+rbp*2]
pinsrw xmm14, word ptr [rax+r14*2], 1
movd xmm9, edx
movzx edx, word ptr [rax+r10*2]
pinsrw xmm9, word ptr [rax+r11*2], 1
movd xmm1, edx
movzx edx, word ptr [rax+r8*2]
pinsrw xmm1, word ptr [rax+r9*2], 1
punpckldq xmm14, xmm9
movd xmm2, edx
pinsrw xmm2, word ptr [rax+rdi*2], 1
movaps [rsp+198h+var_128], xmm0
movsx r14, byte ptr [rsp+198h+var_128+8]
movaps [rsp+198h+var_138], xmm0
movsx rbp, byte ptr [rsp+198h+var_138+9]
movaps [rsp+198h+var_148], xmm0
movsx r11, byte ptr [rsp+198h+var_148+0Ah]
punpckldq xmm1, xmm2
movaps [rsp+198h+var_158], xmm0
movsx r10, byte ptr [rsp+198h+var_158+0Bh]
punpcklqdq xmm14, xmm1
movaps [rsp+198h+var_168], xmm0
movsx r9, byte ptr [rsp+198h+var_168+0Ch]
pand xmm14, xmm7
movaps [rsp+198h+var_188], xmm0
movsx rdi, byte ptr [rsp+198h+var_188+0Eh]
pcmpeqw xmm14, xmm4
movaps [rsp+198h+var_178], xmm0
movsx r8, byte ptr [rsp+198h+var_178+0Dh]
movaps [rsp+198h+var_198], xmm0
movsx rdx, byte ptr [rsp+198h+var_198+0Fh]
movzx r14d, word ptr [rax+r14*2]
movzx r11d, word ptr [rax+r11*2]
movzx r9d, word ptr [rax+r9*2]
pcmpeqw xmm14, xmm4
movzx edi, word ptr [rax+rdi*2]
movd xmm9, r14d
pinsrw xmm9, word ptr [rax+rbp*2], 1
movd xmm10, r11d
movd xmm1, r9d
pinsrw xmm10, word ptr [rax+r10*2], 1
pinsrw xmm1, word ptr [rax+r8*2], 1
movd xmm2, edi
pinsrw xmm2, word ptr [rax+rdx*2], 1
punpckldq xmm9, xmm10
movdqa xmm10, xmm4
punpckldq xmm1, xmm2
punpcklqdq xmm9, xmm1
movdqa xmm1, xmm8
pcmpgtb xmm1, xmm0
pand xmm9, xmm7
pcmpeqw xmm9, xmm4
punpcklbw xmm13, xmm1
punpckhbw xmm0, xmm1
movdqa xmm1, xmm4
pcmpgtw xmm1, xmm13
pcmpgtw xmm10, xmm0
movdqa xmm2, xmm13
pcmpeqw xmm9, xmm4
punpcklwd xmm2, xmm1
punpckhwd xmm13, xmm1
movdqa xmm1, xmm0
paddd xmm2, xmm6
punpckhwd xmm0, xmm10
punpcklwd xmm1, xmm10
movdqa xmm10, xmm0
movdqa xmm0, xmm2
paddd xmm13, xmm6
psrld xmm0, 1Fh
movdqa xmm15, xmm13
paddd xmm1, xmm6
paddd xmm2, xmm0
psrld xmm15, 1Fh
movdqa xmm12, xmm1
pand xmm2, xmm5
psrld xmm12, 1Fh
paddd xmm10, xmm6
psubd xmm2, xmm0
movdqa xmm0, xmm13
movdqa xmm11, xmm10
paddd xmm0, xmm15
pcmpeqd xmm2, xmm5
paddd xmm1, xmm12
pand xmm0, xmm5
psrld xmm11, 1Fh
psubd xmm0, xmm15
pcmpeqd xmm0, xmm5
movdqa xmm13, xmm2
punpcklwd xmm2, xmm0
punpckhwd xmm13, xmm0
movdqa xmm0, xmm2
punpcklwd xmm2, xmm13
punpckhwd xmm0, xmm13
punpcklwd xmm2, xmm0
movdqa xmm0, xmm1
movdqa xmm1, xmm10
paddd xmm1, xmm11
pand xmm0, xmm5
pand xmm2, xmm14
pand xmm1, xmm5
psubd xmm0, xmm12
psubd xmm1, xmm11
pcmpeqd xmm0, xmm5
pcmpeqd xmm1, xmm5
movdqa xmm10, xmm0
punpcklwd xmm0, xmm1
punpckhwd xmm10, xmm1
movdqa xmm1, xmm0
punpcklwd xmm0, xmm10
punpckhwd xmm1, xmm10
punpcklwd xmm0, xmm1
movdqa xmm1, xmm4
pcmpgtw xmm1, xmm2
pand xmm0, xmm9
movdqa xmm9, xmm2
punpcklwd xmm9, xmm1
punpckhwd xmm2, xmm1
movdqa xmm1, xmm4
pcmpgtw xmm1, xmm0
psubd xmm3, xmm9
psubd xmm3, xmm2
movdqa xmm2, xmm0
punpcklwd xmm2, xmm1
punpckhwd xmm0, xmm1
psubd xmm3, xmm2
psubd xmm3, xmm0
cmp rsi, rcx
jnz loc_1788
movdqa xmm0, xmm3
mov esi, r13d
psrldq xmm0, 8
and esi, 0FFFFFFF0h
paddd xmm0, xmm3
mov edx, esi
movdqa xmm1, xmm0
psrldq xmm1, 4
paddd xmm0, xmm1
movdqa xmm1, xmm3
psrldq xmm3, 8
paddd xmm3, xmm1
movd r14d, xmm0
test r13b, 0Fh
jz loc_1E50
loc_1AC7:
mov ecx, r13d
sub ecx, esi
lea edi, [rcx-1]
cmp edi, 6
jbe loc_1D47
mov rsi, [rbx+rsi]
pxor xmm0, xmm0
pxor xmm5, xmm5
movq xmm7, qword ptr cs:xmmword_30C0
movq xmm8, qword ptr cs:xmmword_30D0
movdqa xmm9, xmm5
mov rdi, rsi
mov r10d, esi
mov r9d, esi
movsx r8, sil
shl r10d, 8
sar edi, 18h
movzx r8d, word ptr [rax+r8*2]
movq xmm2, rsi
sar r10d, 18h
movsx rdi, dil
sar r9w, 8
movzx edi, word ptr [rax+rdi*2]
movsx r10, r10b
movsx r9, r9b
movzx r10d, word ptr [rax+r10*2]
movzx r9d, word ptr [rax+r9*2]
shl rdi, 10h
or rdi, r10
mov r10, rsi
shl rdi, 10h
shl r10, 8
or rdi, r9
sar r10, 38h
mov r9, rsi
shl rdi, 10h
shl r9, 10h
movzx r10d, word ptr [rax+r10*2]
or rdi, r8
sar r9, 38h
mov r8, rsi
movq xmm4, rdi
mov rdi, rsi
shl r8, 18h
movzx r9d, word ptr [rax+r9*2]
sar rdi, 38h
sar r8, 38h
pand xmm4, xmm7
movzx edi, word ptr [rax+rdi*2]
movzx r8d, word ptr [rax+r8*2]
pcmpeqw xmm4, xmm5
shl rdi, 10h
or rdi, r10
pcmpeqw xmm4, xmm5
shl rdi, 10h
or rdi, r9
shl rdi, 10h
or rdi, r8
movq xmm6, rdi
pand xmm7, xmm6
movq xmm6, rsi
pcmpgtb xmm0, xmm6
pcmpeqw xmm7, xmm5
punpcklbw xmm6, xmm0
pcmpeqw xmm7, xmm5
punpcklbw xmm2, xmm0
movdqa xmm0, xmm5
pshufd xmm2, xmm2, 4Eh ; 'N'
movdqa xmm1, xmm6
pcmpgtw xmm0, xmm6
pcmpgtw xmm9, xmm2
punpcklwd xmm1, xmm0
punpcklwd xmm6, xmm0
movdqa xmm0, xmm2
paddd xmm1, xmm8
pshufd xmm6, xmm6, 4Eh ; 'N'
punpcklwd xmm0, xmm9
paddd xmm6, xmm8
punpcklwd xmm2, xmm9
pxor xmm9, xmm9
movdqa xmm12, xmm9
movdqa xmm11, xmm9
pshufd xmm2, xmm2, 4Eh ; 'N'
pcmpgtd xmm12, xmm1
paddd xmm0, xmm8
paddd xmm2, xmm8
movq xmm8, qword ptr cs:xmmword_30E0
pcmpgtd xmm11, xmm6
movdqa xmm10, xmm9
pcmpgtd xmm10, xmm0
pcmpgtd xmm9, xmm2
pand xmm12, xmm8
pand xmm11, xmm8
paddd xmm1, xmm12
paddd xmm6, xmm11
pand xmm10, xmm8
pand xmm9, xmm8
pand xmm1, xmm8
paddd xmm0, xmm10
paddd xmm2, xmm9
psubd xmm1, xmm12
pand xmm6, xmm8
psubd xmm6, xmm11
pand xmm0, xmm8
pand xmm2, xmm8
pcmpeqd xmm1, xmm8
psubd xmm0, xmm10
psubd xmm2, xmm9
pcmpeqd xmm6, xmm8
pcmpeqd xmm0, xmm8
pcmpeqd xmm2, xmm8
movdqa xmm11, xmm1
punpcklwd xmm11, xmm6
punpcklwd xmm1, xmm6
pshufd xmm11, xmm11, 4Eh ; 'N'
punpcklwd xmm1, xmm11
pand xmm1, xmm4
movdqa xmm4, xmm0
punpcklwd xmm0, xmm2
punpcklwd xmm4, xmm2
movdqa xmm2, xmm5
pcmpgtw xmm2, xmm1
pshufd xmm4, xmm4, 4Eh ; 'N'
punpcklwd xmm0, xmm4
movdqa xmm4, xmm1
pand xmm0, xmm7
punpcklwd xmm4, xmm2
pcmpgtw xmm5, xmm0
punpcklwd xmm1, xmm2
psubd xmm3, xmm4
pshufd xmm1, xmm1, 4Eh ; 'N'
movdqa xmm2, xmm0
punpcklwd xmm2, xmm5
punpcklwd xmm0, xmm5
psubd xmm3, xmm1
pshufd xmm0, xmm0, 4Eh ; 'N'
psubd xmm3, xmm2
psubd xmm3, xmm0
movd r14d, xmm3
pshufd xmm7, xmm3, 0E5h
movd esi, xmm7
add r14d, esi
mov esi, ecx
and esi, 0FFFFFFF8h
add edx, esi
and ecx, 7
jz loc_1E50
loc_1D47:
movsxd rcx, edx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jz short loc_1D74
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
loc_1D74:
lea ecx, [rdx+1]
cmp ecx, r13d
jge loc_1E50
movsxd rcx, ecx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jnz loc_1EA0
loc_1D96:
lea ecx, [rdx+2]
cmp r13d, ecx
jle loc_1E50
movsxd rcx, ecx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jnz loc_1EC0
loc_1DB8:
lea ecx, [rdx+3]
cmp r13d, ecx
jle loc_1E50
movsxd rcx, ecx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jnz loc_1EE0
loc_1DDA:
lea ecx, [rdx+4]
cmp r13d, ecx
jle short loc_1E50
movsxd rcx, ecx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jnz loc_1F00
loc_1DF8:
lea ecx, [rdx+5]
cmp r13d, ecx
jle short loc_1E50
movsxd rcx, ecx
movsx rsi, byte ptr [rbx+rcx]
mov rcx, rsi
test byte ptr [rax+rsi*2+1], 2
jnz loc_1F20
loc_1E16:
add edx, 6
cmp r13d, edx
jle short loc_1E50
movsxd rdx, edx
movsx rcx, byte ptr [rbx+rdx]
test byte ptr [rax+rcx*2+1], 2
jz short loc_1E50
movsx eax, cl
sub eax, 61h ; 'a'
mov edx, eax
shr edx, 1Fh
add eax, edx
and eax, 1
sub eax, edx
cmp eax, 1
setz al
movzx eax, al
add r14d, eax
nop dword ptr [rax+rax+00h]
loc_1E50:
mov edi, 8; size
call _malloc
mov edi, 0Ch; size
mov rbp, rax
call _malloc
mov r8d, r14d
mov edx, 0Ch
lea rcx, unk_3004
mov [rbp+0], rax
mov rdi, rax
xor eax, eax
mov esi, 2
mov r14d, 1
call ___sprintf_chk
jmp loc_16E1
loc_1E98:
xor r14d, r14d
jmp loc_16E1
loc_1EA0:
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
jmp loc_1D96
loc_1EC0:
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
jmp loc_1DB8
loc_1EE0:
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
jmp loc_1DDA
loc_1F00:
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
jmp loc_1DF8
loc_1F20:
sub ecx, 61h ; 'a'
mov esi, ecx
shr esi, 1Fh
add ecx, esi
and ecx, 1
sub ecx, esi
cmp ecx, 1
setz cl
movzx ecx, cl
add r14d, ecx
jmp loc_1E16
loc_1F40:
pxor xmm3, xmm3
xor esi, esi
xor r14d, r14d
xor edx, edx
jmp loc_1AC7
loc_1F50:
call ___stack_chk_fail
|
_QWORD * func0(__m128i *s, int *a2)
{
char *v3; // rbx
int v4; // r13d
_QWORD *v5; // rbp
int v6; // r14d
int v7; // edx
long long v8; // r15
char *v9; // r13
char *v10; // rdx
long long v11; // rax
unsigned long long v12; // rax
long long v13; // rcx
unsigned int v15; // r14d
const unsigned __int16 *v16; // rax
const __m128i *v17; // rcx
__m128i v18; // xmm3
__m128i si128; // xmm7
__m128i v20; // xmm6
__m128i v21; // xmm5
__m128i v22; // xmm0
__m128i v23; // xmm14
__m128i v24; // xmm1
__m128i v25; // xmm9
__m128i v26; // xmm13
__m128i v27; // xmm0
__m128i v28; // xmm1
__m128i v29; // xmm10
__m128i v30; // xmm2
__m128i v31; // xmm13
__m128i v32; // xmm2
__m128i v33; // xmm1
__m128i v34; // xmm10
__m128i v35; // xmm13
__m128i v36; // xmm0
__m128i v37; // xmm1
__m128i v38; // xmm15
__m128i v39; // xmm12
__m128i v40; // xmm10
__m128i v41; // xmm2
__m128i v42; // xmm11
__m128i v43; // xmm0
__m128i v44; // xmm13
__m128i v45; // xmm2
__m128i v46; // xmm13
__m128i v47; // xmm0
__m128i v48; // xmm2
__m128i v49; // xmm1
__m128i v50; // xmm10
__m128i v51; // xmm0
__m128i v52; // xmm10
__m128i v53; // xmm1
__m128i v54; // xmm0
__m128i v55; // xmm9
__m128i v56; // xmm2
__m128i v57; // xmm1
long long v58; // rsi
__m128i v59; // xmm0
unsigned int v60; // edx
__m128i v61; // xmm3
int v62; // ecx
long long v63; // rsi
__m128i v64; // xmm7
__m128i v65; // xmm8
__m128i v66; // xmm6
__m128i v67; // xmm2
__m128i v68; // xmm6
__m128i v69; // xmm1
__m128i v70; // xmm0
__m128i v71; // xmm6
__m128i v72; // xmm2
__m128i v73; // xmm0
__m128i v74; // xmm2
__m128i v75; // xmm8
__m128i v76; // xmm12
__m128i v77; // xmm11
__m128i v78; // xmm10
__m128i v79; // xmm9
__m128i v80; // xmm1
__m128i v81; // xmm1
__m128i v82; // xmm0
__m128i v83; // xmm0
__m128i v84; // xmm1
__m128i v85; // xmm2
__m128i v86; // xmm3
long long v87; // rsi
long long v88; // rsi
long long v89; // rsi
long long v90; // rsi
long long v91; // rsi
long long v92; // rsi
int v93; // edx
long long v94; // rcx
void *v95; // rax
long long v96; // r8
long long v97; // r9
__m128i v98; // [rsp+0h] [rbp-198h]
__m128i v99; // [rsp+10h] [rbp-188h]
__m128i v100; // [rsp+20h] [rbp-178h]
__m128i v101; // [rsp+30h] [rbp-168h]
__m128i v102; // [rsp+40h] [rbp-158h]
__m128i v103; // [rsp+50h] [rbp-148h]
__m128i v104; // [rsp+60h] [rbp-138h]
__m128i v105; // [rsp+70h] [rbp-128h]
__m128i v106; // [rsp+80h] [rbp-118h]
__m128i v107; // [rsp+90h] [rbp-108h]
__m128i v108; // [rsp+A0h] [rbp-F8h]
__m128i v109; // [rsp+B0h] [rbp-E8h]
__m128i v110; // [rsp+C0h] [rbp-D8h]
__m128i v111; // [rsp+D0h] [rbp-C8h]
__m128i v112; // [rsp+E0h] [rbp-B8h]
char sa[16]; // [rsp+F0h] [rbp-A8h] BYREF
__int128 v114; // [rsp+100h] [rbp-98h]
__int128 v115; // [rsp+110h] [rbp-88h]
__int128 v116; // [rsp+120h] [rbp-78h]
__int128 v117; // [rsp+130h] [rbp-68h]
_QWORD v118[3]; // [rsp+140h] [rbp-58h] BYREF
unsigned long long v119; // [rsp+158h] [rbp-40h]
v3 = (char *)s;
v119 = __readfsqword(0x28u);
memset(v118, 0, 21);
v4 = strlen(s->m128i_i8);
*(_OWORD *)sa = 0LL;
v114 = 0LL;
v115 = 0LL;
v116 = 0LL;
v117 = 0LL;
if ( !strchr(s->m128i_i8, 32) && !strchr(s->m128i_i8, 44) )
{
v15 = 0;
if ( v4 > 0 )
{
v16 = *__ctype_b_loc();
if ( (unsigned int)(v4 - 1) <= 0xE )
{
v61 = 0LL;
v58 = 0LL;
v15 = 0;
v60 = 0;
goto LABEL_17;
}
v17 = s;
v18 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_30C0);
v20 = _mm_load_si128((const __m128i *)&xmmword_30D0);
v21 = _mm_load_si128((const __m128i *)&xmmword_30E0);
do
{
v22 = _mm_loadu_si128(v17++);
v112 = v22;
v111 = v22;
v110 = v22;
v109 = v22;
v108 = v22;
v107 = v22;
v106 = v22;
v105 = v22;
v104 = v22;
v103 = v22;
v102 = v22;
v101 = v22;
v99 = v22;
v100 = v22;
v98 = v22;
v23 = _mm_cmpeq_epi16(
_mm_cmpeq_epi16(
_mm_and_si128(
_mm_unpacklo_epi64(
_mm_unpacklo_epi32(
_mm_insert_epi16(_mm_cvtsi32_si128(v16[(char)_mm_cvtsi128_si32(v22)]), v16[v22.m128i_i8[1]], 1),
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[2]]), v16[v22.m128i_i8[3]], 1)),
_mm_unpacklo_epi32(
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[4]]), v16[v22.m128i_i8[5]], 1),
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[6]]), v16[v22.m128i_i8[7]], 1))),
si128),
(__m128i)0LL),
(__m128i)0LL);
v24 = _mm_cmpgt_epi8((__m128i)0LL, v22);
v25 = _mm_cmpeq_epi16(
_mm_and_si128(
_mm_unpacklo_epi64(
_mm_unpacklo_epi32(
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[8]]), v16[v22.m128i_i8[9]], 1),
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[10]]), v16[v22.m128i_i8[11]], 1)),
_mm_unpacklo_epi32(
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[12]]), v16[v22.m128i_i8[13]], 1),
_mm_insert_epi16(_mm_cvtsi32_si128(v16[v22.m128i_i8[14]]), v16[v22.m128i_i8[15]], 1))),
si128),
(__m128i)0LL);
v26 = _mm_unpacklo_epi8(v22, v24);
v27 = _mm_unpackhi_epi8(v22, v24);
v28 = _mm_cmpgt_epi16((__m128i)0LL, v26);
v29 = _mm_cmpgt_epi16((__m128i)0LL, v27);
v30 = _mm_unpacklo_epi16(v26, v28);
v31 = _mm_unpackhi_epi16(v26, v28);
v32 = _mm_add_epi32(v30, v20);
v33 = _mm_unpacklo_epi16(v27, v29);
v34 = _mm_unpackhi_epi16(v27, v29);
v35 = _mm_add_epi32(v31, v20);
v36 = _mm_srli_epi32(v32, 0x1Fu);
v37 = _mm_add_epi32(v33, v20);
v38 = _mm_srli_epi32(v35, 0x1Fu);
v39 = _mm_srli_epi32(v37, 0x1Fu);
v40 = _mm_add_epi32(v34, v20);
v41 = _mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v32, v36), v21), v36);
v42 = _mm_srli_epi32(v40, 0x1Fu);
v43 = _mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v35, v38), v21), v38), v21);
v44 = _mm_cmpeq_epi32(v41, v21);
v45 = _mm_unpacklo_epi16(v44, v43);
v46 = _mm_unpackhi_epi16(v44, v43);
v47 = _mm_add_epi32(v37, v39);
v48 = _mm_and_si128(_mm_unpacklo_epi16(_mm_unpacklo_epi16(v45, v46), _mm_unpackhi_epi16(v45, v46)), v23);
v49 = _mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v40, v42), v21), v42), v21);
v50 = _mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(v47, v21), v39), v21);
v51 = _mm_unpacklo_epi16(v50, v49);
v52 = _mm_unpackhi_epi16(v50, v49);
v53 = _mm_cmpgt_epi16((__m128i)0LL, v48);
v54 = _mm_and_si128(
_mm_unpacklo_epi16(_mm_unpacklo_epi16(v51, v52), _mm_unpackhi_epi16(v51, v52)),
_mm_cmpeq_epi16(v25, (__m128i)0LL));
v55 = _mm_unpacklo_epi16(v48, v53);
v56 = _mm_unpackhi_epi16(v48, v53);
v57 = _mm_cmpgt_epi16((__m128i)0LL, v54);
v18 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v18, v55), v56), _mm_unpacklo_epi16(v54, v57)),
_mm_unpackhi_epi16(v54, v57));
}
while ( &s[(unsigned int)v4 >> 4] != v17 );
v58 = v4 & 0xFFFFFFF0;
v59 = _mm_add_epi32(_mm_srli_si128(v18, 8), v18);
v60 = v4 & 0xFFFFFFF0;
v61 = v59;
v15 = _mm_cvtsi128_si32(_mm_add_epi32(v59, _mm_srli_si128(v59, 4)));
if ( (v4 & 0xF) != 0 )
{
LABEL_17:
v62 = v4 - v58;
if ( (unsigned int)(v4 - v58 - 1) <= 6 )
goto LABEL_19;
v63 = *(long long *)((char *)s->m128i_i64 + v58);
v64 = _mm_loadl_epi64((const __m128i *)&xmmword_30C0);
v65 = _mm_loadl_epi64((const __m128i *)&xmmword_30D0);
v66 = _mm_unpacklo_epi8(
(__m128i)(unsigned long long)v63,
_mm_cmpgt_epi8((__m128i)0LL, (__m128i)(unsigned long long)v63));
v67 = _mm_shuffle_epi32(v66, 78);
v68 = _mm_unpacklo_epi16(v66, _mm_cmpgt_epi16((__m128i)0LL, v66));
v69 = _mm_add_epi32(v68, v65);
v70 = _mm_unpacklo_epi16(v67, _mm_cmpgt_epi16((__m128i)0LL, v67));
v71 = _mm_add_epi32(_mm_shuffle_epi32(v68, 78), v65);
v72 = _mm_shuffle_epi32(v70, 78);
v73 = _mm_add_epi32(v70, v65);
v74 = _mm_add_epi32(v72, v65);
v75 = _mm_loadl_epi64((const __m128i *)&xmmword_30E0);
v76 = _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v69), v75);
v77 = _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v71), v75);
v78 = _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v73), v75);
v79 = _mm_and_si128(_mm_cmpgt_epi32((__m128i)0LL, v74), v75);
v80 = _mm_unpacklo_epi16(
_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v69, v76), v75), v76), v75),
_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v71, v77), v75), v77), v75));
v81 = _mm_and_si128(
_mm_unpacklo_epi16(v80, _mm_shuffle_epi32(v80, 78)),
_mm_cmpeq_epi16(
_mm_cmpeq_epi16(
_mm_and_si128(
(__m128i)(v16[(char)v63] | ((v16[SBYTE1(v63)] | ((v16[(char)((_DWORD)v63 << 8 >> 24)] | ((unsigned long long)v16[SBYTE3(v63)] << 16)) << 16)) << 16)),
v64),
(__m128i)0LL),
(__m128i)0LL));
v82 = _mm_unpacklo_epi16(
_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v73, v78), v75), v78), v75),
_mm_cmpeq_epi32(_mm_sub_epi32(_mm_and_si128(_mm_add_epi32(v74, v79), v75), v79), v75));
v83 = _mm_and_si128(
_mm_unpacklo_epi16(v82, _mm_shuffle_epi32(v82, 78)),
_mm_cmpeq_epi16(
_mm_cmpeq_epi16(
_mm_and_si128(
v64,
(__m128i)(v16[v63 << 24 >> 56] | ((v16[v63 << 16 >> 56] | ((v16[v63 << 8 >> 56] | ((unsigned long long)v16[v63 >> 56] << 16)) << 16)) << 16))),
(__m128i)0LL),
(__m128i)0LL));
v84 = _mm_unpacklo_epi16(v81, _mm_cmpgt_epi16((__m128i)0LL, v81));
v85 = _mm_unpacklo_epi16(v83, _mm_cmpgt_epi16((__m128i)0LL, v83));
v86 = _mm_sub_epi32(
_mm_sub_epi32(_mm_sub_epi32(_mm_sub_epi32(v61, v84), _mm_shuffle_epi32(v84, 78)), v85),
_mm_shuffle_epi32(v85, 78));
v15 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v86, 229)) + _mm_cvtsi128_si32(v86);
v60 += v62 & 0xFFFFFFF8;
if ( (v62 & 7) != 0 )
{
LABEL_19:
v87 = s->m128i_i8[v60];
if ( (v16[v87] & 0x200) != 0 )
v15 += ((int)v87 - 97) % 2 == 1;
if ( (int)(v60 + 1) < v4 )
{
v88 = s->m128i_i8[v60 + 1];
if ( (v16[v88] & 0x200) != 0 )
v15 += ((int)v88 - 97) % 2 == 1;
if ( v4 > (int)(v60 + 2) )
{
v89 = s->m128i_i8[v60 + 2];
if ( (v16[v89] & 0x200) != 0 )
v15 += ((int)v89 - 97) % 2 == 1;
if ( v4 > (int)(v60 + 3) )
{
v90 = s->m128i_i8[v60 + 3];
if ( (v16[v90] & 0x200) != 0 )
v15 += ((int)v90 - 97) % 2 == 1;
if ( v4 > (int)(v60 + 4) )
{
v91 = s->m128i_i8[v60 + 4];
if ( (v16[v91] & 0x200) != 0 )
v15 += ((int)v91 - 97) % 2 == 1;
if ( v4 > (int)(v60 + 5) )
{
v92 = s->m128i_i8[v60 + 5];
if ( (v16[v92] & 0x200) != 0 )
v15 += ((int)v92 - 97) % 2 == 1;
v93 = v60 + 6;
if ( v4 > v93 )
{
v94 = s->m128i_i8[v93];
if ( (v16[v94] & 0x200) != 0 )
v15 += ((char)v94 - 97) % 2 == 1;
}
}
}
}
}
}
}
}
}
v5 = malloc(8uLL);
v95 = malloc(0xCuLL);
v96 = v15;
*v5 = v95;
v6 = 1;
__sprintf_chk(
v95,
2LL,
12LL,
&unk_3004,
v96,
v97,
v98.m128i_i64[0],
v98.m128i_i64[1],
v99.m128i_i64[0],
v99.m128i_i64[1],
v100.m128i_i64[0],
v100.m128i_i64[1],
v101.m128i_i64[0],
v101.m128i_i64[1],
v102.m128i_i64[0],
v102.m128i_i64[1],
v103.m128i_i64[0],
v103.m128i_i64[1],
v104.m128i_i64[0],
v104.m128i_i64[1],
v105.m128i_i64[0],
v105.m128i_i64[1],
v106.m128i_i64[0],
v106.m128i_i64[1],
v107.m128i_i64[0],
v107.m128i_i64[1],
v108.m128i_i64[0],
v108.m128i_i64[1],
v109.m128i_i64[0],
v109.m128i_i64[1],
v110.m128i_i64[0],
v110.m128i_i64[1],
v111.m128i_i64[0],
v111.m128i_i64[1],
v112.m128i_i64[0],
v112.m128i_i64[1],
*(_QWORD *)sa,
*(_QWORD *)&sa[8],
v114,
*((_QWORD *)&v114 + 1),
v115,
*((_QWORD *)&v115 + 1),
v116,
*((_QWORD *)&v116 + 1),
v117,
*((_QWORD *)&v117 + 1),
v118[0],
v118[1],
v118[2],
v119);
goto LABEL_10;
}
v5 = malloc(8LL * (v4 + 1));
if ( v4 < 0 )
{
v6 = 0;
}
else
{
v6 = 0;
v7 = 0;
v8 = 0x100100000001LL;
v9 = &s->m128i_i8[v4 + 1];
do
{
while ( 1 )
{
v12 = (unsigned __int8)*v3;
if ( (unsigned __int8)v12 <= 0x2Cu )
{
if ( _bittest64(&v8, v12) )
break;
}
v13 = v7;
++v3;
++v7;
sa[v13] = v12;
if ( v9 == v3 )
goto LABEL_10;
}
if ( v7 > 0 )
{
sa[v7] = 0;
v10 = strdup(sa);
v11 = v6++;
v5[v11] = v10;
v7 = 0;
}
++v3;
}
while ( v9 != v3 );
}
LABEL_10:
*a2 = v6;
return v5;
}
|
func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RSI
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x168
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x158],RAX
XOR EAX,EAX
CALL 0x001010f0
PXOR XMM0,XMM0
MOV ESI,0x20
MOV RDI,RBX
MOVAPS xmmword ptr [RSP + 0x140],XMM0
MOV R13,RAX
MOV qword ptr [RSP + 0x14d],0x0
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOVAPS xmmword ptr [RSP + 0x100],XMM0
MOVAPS xmmword ptr [RSP + 0x110],XMM0
MOVAPS xmmword ptr [RSP + 0x120],XMM0
MOVAPS xmmword ptr [RSP + 0x130],XMM0
CALL 0x00101110
TEST RAX,RAX
JZ 0x00101718
LAB_0010164c:
LEA EDI,[R13 + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x3
CALL 0x00101140
MOV RBP,RAX
TEST R13D,R13D
JS 0x00101e98
MOV R13D,R13D
XOR R14D,R14D
XOR EDX,EDX
MOV R15,0x100100000001
LEA R13,[RBX + R13*0x1 + 0x1]
JMP 0x001016c4
LAB_00101688:
BT R15,RAX
JNC 0x001016cb
TEST EDX,EDX
JLE 0x001016bb
MOVSXD RDX,EDX
LEA RDI,[RSP + 0xf0]
MOV byte ptr [RSP + RDX*0x1 + 0xf0],0x0
CALL 0x00101150
MOV RDX,RAX
MOVSXD RAX,R14D
ADD R14D,0x1
MOV qword ptr [RBP + RAX*0x8],RDX
XOR EDX,EDX
LAB_001016bb:
ADD RBX,0x1
CMP R13,RBX
JZ 0x001016e1
LAB_001016c4:
MOVZX EAX,byte ptr [RBX]
CMP AL,0x2c
JBE 0x00101688
LAB_001016cb:
MOVSXD RCX,EDX
ADD RBX,0x1
ADD EDX,0x1
MOV byte ptr [RSP + RCX*0x1 + 0xf0],AL
CMP R13,RBX
JNZ 0x001016c4
LAB_001016e1:
MOV dword ptr [R12],R14D
MOV RAX,qword ptr [RSP + 0x158]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101f50
ADD RSP,0x168
MOV RAX,RBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101718:
MOV ESI,0x2c
MOV RDI,RBX
CALL 0x00101110
TEST RAX,RAX
JNZ 0x0010164c
XOR R14D,R14D
TEST R13D,R13D
JLE 0x00101e50
CALL 0x00101160
LEA EDX,[R13 + -0x1]
MOV RAX,qword ptr [RAX]
CMP EDX,0xe
JBE 0x00101f40
MOV ESI,R13D
MOV RCX,RBX
PXOR XMM3,XMM3
MOVDQA XMM7,xmmword ptr [0x001030c0]
SHR ESI,0x4
PXOR XMM8,XMM8
PXOR XMM4,XMM4
MOVDQA XMM6,xmmword ptr [0x001030d0]
SHL RSI,0x4
MOVDQA XMM5,xmmword ptr [0x001030e0]
ADD RSI,RBX
NOP dword ptr [RAX]
LAB_00101788:
MOVDQU XMM0,xmmword ptr [RCX]
ADD RCX,0x10
MOVD EDX,XMM0
MOVAPS xmmword ptr [RSP + 0xe0],XMM0
MOVSX R14,byte ptr [RSP + 0xe1]
MOVDQA XMM13,XMM0
MOVSX RDX,DL
MOVAPS xmmword ptr [RSP + 0xd0],XMM0
MOVSX RBP,byte ptr [RSP + 0xd2]
MOVAPS xmmword ptr [RSP + 0xc0],XMM0
MOVSX R11,byte ptr [RSP + 0xc3]
MOVAPS xmmword ptr [RSP + 0xb0],XMM0
MOVSX R10,byte ptr [RSP + 0xb4]
MOVAPS xmmword ptr [RSP + 0xa0],XMM0
MOVSX R9,byte ptr [RSP + 0xa5]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVSX R8,byte ptr [RSP + 0x96]
MOVAPS xmmword ptr [RSP + 0x80],XMM0
MOVZX EDX,word ptr [RAX + RDX*0x2]
MOVSX RDI,byte ptr [RSP + 0x87]
MOVD XMM14,EDX
MOVZX EDX,word ptr [RAX + RBP*0x2]
PINSRW XMM14,word ptr [RAX + R14*0x2],0x1
MOVD XMM9,EDX
MOVZX EDX,word ptr [RAX + R10*0x2]
PINSRW XMM9,word ptr [RAX + R11*0x2],0x1
MOVD XMM1,EDX
MOVZX EDX,word ptr [RAX + R8*0x2]
PINSRW XMM1,word ptr [RAX + R9*0x2],0x1
PUNPCKLDQ XMM14,XMM9
MOVD XMM2,EDX
PINSRW XMM2,word ptr [RAX + RDI*0x2],0x1
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVSX R14,byte ptr [RSP + 0x78]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVSX RBP,byte ptr [RSP + 0x69]
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVSX R11,byte ptr [RSP + 0x5a]
PUNPCKLDQ XMM1,XMM2
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVSX R10,byte ptr [RSP + 0x4b]
PUNPCKLQDQ XMM14,XMM1
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVSX R9,byte ptr [RSP + 0x3c]
PAND XMM14,XMM7
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOVSX RDI,byte ptr [RSP + 0x1e]
PCMPEQW XMM14,XMM4
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVSX R8,byte ptr [RSP + 0x2d]
MOVAPS xmmword ptr [RSP],XMM0
MOVSX RDX,byte ptr [RSP + 0xf]
MOVZX R14D,word ptr [RAX + R14*0x2]
MOVZX R11D,word ptr [RAX + R11*0x2]
MOVZX R9D,word ptr [RAX + R9*0x2]
PCMPEQW XMM14,XMM4
MOVZX EDI,word ptr [RAX + RDI*0x2]
MOVD XMM9,R14D
PINSRW XMM9,word ptr [RAX + RBP*0x2],0x1
MOVD XMM10,R11D
MOVD XMM1,R9D
PINSRW XMM10,word ptr [RAX + R10*0x2],0x1
PINSRW XMM1,word ptr [RAX + R8*0x2],0x1
MOVD XMM2,EDI
PINSRW XMM2,word ptr [RAX + RDX*0x2],0x1
PUNPCKLDQ XMM9,XMM10
MOVDQA XMM10,XMM4
PUNPCKLDQ XMM1,XMM2
PUNPCKLQDQ XMM9,XMM1
MOVDQA XMM1,XMM8
PCMPGTB XMM1,XMM0
PAND XMM9,XMM7
PCMPEQW XMM9,XMM4
PUNPCKLBW XMM13,XMM1
PUNPCKHBW XMM0,XMM1
MOVDQA XMM1,XMM4
PCMPGTW XMM1,XMM13
PCMPGTW XMM10,XMM0
MOVDQA XMM2,XMM13
PCMPEQW XMM9,XMM4
PUNPCKLWD XMM2,XMM1
PUNPCKHWD XMM13,XMM1
MOVDQA XMM1,XMM0
PADDD XMM2,XMM6
PUNPCKHWD XMM0,XMM10
PUNPCKLWD XMM1,XMM10
MOVDQA XMM10,XMM0
MOVDQA XMM0,XMM2
PADDD XMM13,XMM6
PSRLD XMM0,0x1f
MOVDQA XMM15,XMM13
PADDD XMM1,XMM6
PADDD XMM2,XMM0
PSRLD XMM15,0x1f
MOVDQA XMM12,XMM1
PAND XMM2,XMM5
PSRLD XMM12,0x1f
PADDD XMM10,XMM6
PSUBD XMM2,XMM0
MOVDQA XMM0,XMM13
MOVDQA XMM11,XMM10
PADDD XMM0,XMM15
PCMPEQD XMM2,XMM5
PADDD XMM1,XMM12
PAND XMM0,XMM5
PSRLD XMM11,0x1f
PSUBD XMM0,XMM15
PCMPEQD XMM0,XMM5
MOVDQA XMM13,XMM2
PUNPCKLWD XMM2,XMM0
PUNPCKHWD XMM13,XMM0
MOVDQA XMM0,XMM2
PUNPCKLWD XMM2,XMM13
PUNPCKHWD XMM0,XMM13
PUNPCKLWD XMM2,XMM0
MOVDQA XMM0,XMM1
MOVDQA XMM1,XMM10
PADDD XMM1,XMM11
PAND XMM0,XMM5
PAND XMM2,XMM14
PAND XMM1,XMM5
PSUBD XMM0,XMM12
PSUBD XMM1,XMM11
PCMPEQD XMM0,XMM5
PCMPEQD XMM1,XMM5
MOVDQA XMM10,XMM0
PUNPCKLWD XMM0,XMM1
PUNPCKHWD XMM10,XMM1
MOVDQA XMM1,XMM0
PUNPCKLWD XMM0,XMM10
PUNPCKHWD XMM1,XMM10
PUNPCKLWD XMM0,XMM1
MOVDQA XMM1,XMM4
PCMPGTW XMM1,XMM2
PAND XMM0,XMM9
MOVDQA XMM9,XMM2
PUNPCKLWD XMM9,XMM1
PUNPCKHWD XMM2,XMM1
MOVDQA XMM1,XMM4
PCMPGTW XMM1,XMM0
PSUBD XMM3,XMM9
PSUBD XMM3,XMM2
MOVDQA XMM2,XMM0
PUNPCKLWD XMM2,XMM1
PUNPCKHWD XMM0,XMM1
PSUBD XMM3,XMM2
PSUBD XMM3,XMM0
CMP RSI,RCX
JNZ 0x00101788
MOVDQA XMM0,XMM3
MOV ESI,R13D
PSRLDQ XMM0,0x8
AND ESI,0xfffffff0
PADDD XMM0,XMM3
MOV EDX,ESI
MOVDQA XMM1,XMM0
PSRLDQ XMM1,0x4
PADDD XMM0,XMM1
MOVDQA XMM1,XMM3
PSRLDQ XMM3,0x8
PADDD XMM3,XMM1
MOVD R14D,XMM0
TEST R13B,0xf
JZ 0x00101e50
LAB_00101ac7:
MOV ECX,R13D
SUB ECX,ESI
LEA EDI,[RCX + -0x1]
CMP EDI,0x6
JBE 0x00101d47
MOV RSI,qword ptr [RBX + RSI*0x1]
PXOR XMM0,XMM0
PXOR XMM5,XMM5
MOVQ XMM7,qword ptr [0x001030c0]
MOVQ XMM8,qword ptr [0x001030d0]
MOVDQA XMM9,XMM5
MOV RDI,RSI
MOV R10D,ESI
MOV R9D,ESI
MOVSX R8,SIL
SHL R10D,0x8
SAR EDI,0x18
MOVZX R8D,word ptr [RAX + R8*0x2]
MOVQ XMM2,RSI
SAR R10D,0x18
MOVSX RDI,DIL
SAR R9W,0x8
MOVZX EDI,word ptr [RAX + RDI*0x2]
MOVSX R10,R10B
MOVSX R9,R9B
MOVZX R10D,word ptr [RAX + R10*0x2]
MOVZX R9D,word ptr [RAX + R9*0x2]
SHL RDI,0x10
OR RDI,R10
MOV R10,RSI
SHL RDI,0x10
SHL R10,0x8
OR RDI,R9
SAR R10,0x38
MOV R9,RSI
SHL RDI,0x10
SHL R9,0x10
MOVZX R10D,word ptr [RAX + R10*0x2]
OR RDI,R8
SAR R9,0x38
MOV R8,RSI
MOVQ XMM4,RDI
MOV RDI,RSI
SHL R8,0x18
MOVZX R9D,word ptr [RAX + R9*0x2]
SAR RDI,0x38
SAR R8,0x38
PAND XMM4,XMM7
MOVZX EDI,word ptr [RAX + RDI*0x2]
MOVZX R8D,word ptr [RAX + R8*0x2]
PCMPEQW XMM4,XMM5
SHL RDI,0x10
OR RDI,R10
PCMPEQW XMM4,XMM5
SHL RDI,0x10
OR RDI,R9
SHL RDI,0x10
OR RDI,R8
MOVQ XMM6,RDI
PAND XMM7,XMM6
MOVQ XMM6,RSI
PCMPGTB XMM0,XMM6
PCMPEQW XMM7,XMM5
PUNPCKLBW XMM6,XMM0
PCMPEQW XMM7,XMM5
PUNPCKLBW XMM2,XMM0
MOVDQA XMM0,XMM5
PSHUFD XMM2,XMM2,0x4e
MOVDQA XMM1,XMM6
PCMPGTW XMM0,XMM6
PCMPGTW XMM9,XMM2
PUNPCKLWD XMM1,XMM0
PUNPCKLWD XMM6,XMM0
MOVDQA XMM0,XMM2
PADDD XMM1,XMM8
PSHUFD XMM6,XMM6,0x4e
PUNPCKLWD XMM0,XMM9
PADDD XMM6,XMM8
PUNPCKLWD XMM2,XMM9
PXOR XMM9,XMM9
MOVDQA XMM12,XMM9
MOVDQA XMM11,XMM9
PSHUFD XMM2,XMM2,0x4e
PCMPGTD XMM12,XMM1
PADDD XMM0,XMM8
PADDD XMM2,XMM8
MOVQ XMM8,qword ptr [0x001030e0]
PCMPGTD XMM11,XMM6
MOVDQA XMM10,XMM9
PCMPGTD XMM10,XMM0
PCMPGTD XMM9,XMM2
PAND XMM12,XMM8
PAND XMM11,XMM8
PADDD XMM1,XMM12
PADDD XMM6,XMM11
PAND XMM10,XMM8
PAND XMM9,XMM8
PAND XMM1,XMM8
PADDD XMM0,XMM10
PADDD XMM2,XMM9
PSUBD XMM1,XMM12
PAND XMM6,XMM8
PSUBD XMM6,XMM11
PAND XMM0,XMM8
PAND XMM2,XMM8
PCMPEQD XMM1,XMM8
PSUBD XMM0,XMM10
PSUBD XMM2,XMM9
PCMPEQD XMM6,XMM8
PCMPEQD XMM0,XMM8
PCMPEQD XMM2,XMM8
MOVDQA XMM11,XMM1
PUNPCKLWD XMM11,XMM6
PUNPCKLWD XMM1,XMM6
PSHUFD XMM11,XMM11,0x4e
PUNPCKLWD XMM1,XMM11
PAND XMM1,XMM4
MOVDQA XMM4,XMM0
PUNPCKLWD XMM0,XMM2
PUNPCKLWD XMM4,XMM2
MOVDQA XMM2,XMM5
PCMPGTW XMM2,XMM1
PSHUFD XMM4,XMM4,0x4e
PUNPCKLWD XMM0,XMM4
MOVDQA XMM4,XMM1
PAND XMM0,XMM7
PUNPCKLWD XMM4,XMM2
PCMPGTW XMM5,XMM0
PUNPCKLWD XMM1,XMM2
PSUBD XMM3,XMM4
PSHUFD XMM1,XMM1,0x4e
MOVDQA XMM2,XMM0
PUNPCKLWD XMM2,XMM5
PUNPCKLWD XMM0,XMM5
PSUBD XMM3,XMM1
PSHUFD XMM0,XMM0,0x4e
PSUBD XMM3,XMM2
PSUBD XMM3,XMM0
MOVD R14D,XMM3
PSHUFD XMM7,XMM3,0xe5
MOVD ESI,XMM7
ADD R14D,ESI
MOV ESI,ECX
AND ESI,0xfffffff8
ADD EDX,ESI
AND ECX,0x7
JZ 0x00101e50
LAB_00101d47:
MOVSXD RCX,EDX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JZ 0x00101d74
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
LAB_00101d74:
LEA ECX,[RDX + 0x1]
CMP ECX,R13D
JGE 0x00101e50
MOVSXD RCX,ECX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JNZ 0x00101ea0
LAB_00101d96:
LEA ECX,[RDX + 0x2]
CMP R13D,ECX
JLE 0x00101e50
MOVSXD RCX,ECX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JNZ 0x00101ec0
LAB_00101db8:
LEA ECX,[RDX + 0x3]
CMP R13D,ECX
JLE 0x00101e50
MOVSXD RCX,ECX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JNZ 0x00101ee0
LAB_00101dda:
LEA ECX,[RDX + 0x4]
CMP R13D,ECX
JLE 0x00101e50
MOVSXD RCX,ECX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JNZ 0x00101f00
LAB_00101df8:
LEA ECX,[RDX + 0x5]
CMP R13D,ECX
JLE 0x00101e50
MOVSXD RCX,ECX
MOVSX RSI,byte ptr [RBX + RCX*0x1]
MOV RCX,RSI
TEST byte ptr [RAX + RSI*0x2 + 0x1],0x2
JNZ 0x00101f20
LAB_00101e16:
ADD EDX,0x6
CMP R13D,EDX
JLE 0x00101e50
MOVSXD RDX,EDX
MOVSX RCX,byte ptr [RBX + RDX*0x1]
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x2
JZ 0x00101e50
MOVSX EAX,CL
SUB EAX,0x61
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
AND EAX,0x1
SUB EAX,EDX
CMP EAX,0x1
SETZ AL
MOVZX EAX,AL
ADD R14D,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101e50:
MOV EDI,0x8
CALL 0x00101140
MOV EDI,0xc
MOV RBP,RAX
CALL 0x00101140
MOV R8D,R14D
MOV EDX,0xc
LEA RCX,[0x103004]
MOV qword ptr [RBP],RAX
MOV RDI,RAX
XOR EAX,EAX
MOV ESI,0x2
MOV R14D,0x1
CALL 0x00101170
JMP 0x001016e1
LAB_00101e98:
XOR R14D,R14D
JMP 0x001016e1
LAB_00101ea0:
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
JMP 0x00101d96
LAB_00101ec0:
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
JMP 0x00101db8
LAB_00101ee0:
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
JMP 0x00101dda
LAB_00101f00:
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
JMP 0x00101df8
LAB_00101f20:
SUB ECX,0x61
MOV ESI,ECX
SHR ESI,0x1f
ADD ECX,ESI
AND ECX,0x1
SUB ECX,ESI
CMP ECX,0x1
SETZ CL
MOVZX ECX,CL
ADD R14D,ECX
JMP 0x00101e16
LAB_00101f40:
PXOR XMM3,XMM3
XOR ESI,ESI
XOR R14D,R14D
XOR EDX,EDX
JMP 0x00101ac7
LAB_00101f50:
CALL 0x00101100
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int8 * func0(int (*param_1) [16],int *param_2)
{
byte bVar1;
ushort *puVar2;
int iVar3;
int iVar4;
int iVar5;
int auVar6 [14];
int auVar7 [12];
unkbyte10 Var8;
int auVar9 [12];
int auVar10 [16];
int auVar11 [16];
int auVar12 [16];
int auVar13 [16];
int auVar14 [12];
int auVar15 [12];
int auVar16 [14];
int auVar17 [12];
int auVar18 [16];
int auVar19 [16];
int auVar20 [16];
int auVar21 [12];
int auVar22 [16];
int auVar23 [16];
int auVar24 [12];
int auVar25 [12];
int *puVar26;
size_t sVar27;
char *pcVar28;
int8 *puVar29;
ushort **ppuVar30;
void *pvVar31;
uint uVar32;
long lVar33;
int (*pauVar34) [16];
char cVar35;
int iVar36;
char cVar37;
uint uVar38;
char cVar40;
char cVar41;
uint uVar42;
int iVar43;
long in_FS_OFFSET;
char cVar44;
int4 uVar45;
int iVar46;
int2 uVar86;
int iVar88;
int2 uVar91;
int auVar50 [12];
int2 uVar85;
int iVar92;
int auVar51 [12];
int auVar57 [16];
int auVar61 [16];
int auVar65 [16];
int auVar68 [16];
int auVar52 [12];
int auVar70 [16];
int auVar53 [12];
int auVar74 [16];
int auVar78 [16];
int auVar81 [16];
short sVar87;
short sVar90;
int auVar82 [16];
int iVar93;
int auVar94 [12];
short sVar114;
int iVar115;
int auVar95 [16];
int iVar116;
int iVar118;
int iVar119;
int auVar100 [16];
int auVar103 [16];
int auVar107 [16];
int auVar110 [16];
short sVar117;
int auVar111 [16];
int iVar120;
int iVar121;
int iVar122;
int auVar124 [12];
int auVar125 [12];
int iVar159;
int auVar126 [16];
int iVar161;
int auVar129 [16];
int auVar133 [16];
int auVar137 [16];
int auVar140 [16];
int auVar142 [16];
int auVar145 [16];
int auVar153 [16];
int2 uVar160;
int auVar156 [16];
int iVar162;
int iVar163;
int iVar164;
int auVar165 [16];
int auVar166 [16];
int iVar169;
char cVar181;
char cVar182;
char cVar183;
int uVar184;
int auVar170 [16];
int auVar178 [16];
int auVar185 [16];
uint uVar186;
uint uVar191;
int auVar187 [16];
int auVar188 [16];
int iVar192;
uint uVar193;
int iVar194;
uint uVar195;
int iVar196;
int iVar197;
uint uVar198;
uint uVar199;
uint uVar200;
uint uVar201;
int iVar202;
int auVar203 [12];
int iVar213;
int iVar214;
int auVar204 [16];
int iVar215;
int auVar216 [16];
char cStack_189;
char cStack_17a;
char cStack_16b;
char cStack_15c;
char cStack_14d;
char cStack_13e;
char cStack_12f;
char cStack_120;
char cStack_111;
char cStack_102;
char cStack_f3;
char cStack_e4;
char cStack_d5;
char cStack_c6;
char cStack_b7;
int local_a8 [16];
int local_98 [16];
int local_88 [16];
int local_78 [16];
int local_68 [16];
int local_58 [13];
int3 uStack_4b;
int5 uStack_48;
long local_40;
ulong uVar39;
int6 uVar47;
int8 uVar48;
int auVar58 [16];
int auVar62 [16];
int auVar71 [16];
int auVar75 [16];
int auVar49 [12];
int auVar59 [16];
int auVar63 [16];
int auVar66 [16];
int auVar72 [16];
int auVar76 [16];
int auVar79 [16];
int auVar83 [16];
int auVar54 [14];
int auVar56 [16];
int auVar60 [16];
int auVar64 [16];
int auVar67 [16];
int auVar69 [16];
int auVar73 [16];
int auVar77 [16];
int auVar80 [16];
int auVar84 [16];
int auVar55 [16];
int iVar89;
int auVar96 [16];
int auVar97 [16];
int auVar104 [16];
int auVar98 [16];
int auVar101 [16];
int auVar105 [16];
int auVar108 [16];
int auVar112 [16];
int auVar99 [16];
int auVar102 [16];
int auVar106 [16];
int auVar109 [16];
int auVar113 [16];
int auVar123 [12];
int auVar130 [16];
int auVar134 [16];
int auVar146 [16];
int auVar147 [16];
int auVar148 [16];
int auVar149 [16];
int auVar150 [16];
int auVar151 [16];
int auVar152 [16];
int auVar127 [16];
int auVar131 [16];
int auVar135 [16];
int auVar138 [16];
int auVar143 [16];
int auVar154 [16];
int auVar157 [16];
int auVar128 [16];
int auVar132 [16];
int auVar136 [16];
int auVar139 [16];
int auVar141 [16];
int auVar144 [16];
int auVar155 [16];
int auVar158 [16];
int auVar167 [16];
int auVar168 [16];
int auVar171 [16];
int auVar172 [16];
int auVar173 [16];
int auVar174 [16];
int auVar175 [16];
int auVar176 [16];
int auVar177 [16];
int auVar179 [16];
int auVar180 [16];
int auVar189 [16];
int auVar190 [16];
int auVar205 [16];
int auVar206 [16];
int auVar207 [16];
int auVar208 [16];
int auVar209 [16];
int auVar212 [16];
int auVar210 [16];
int auVar211 [16];
local_40 = *(long *)(in_FS_OFFSET + 0x28);
sVar27 = strlen((char *)param_1);
local_58 = SUB1613((int [16])0x0,0);
uStack_4b = 0;
uStack_48 = 0;
local_a8 = (int [16])0x0;
local_98 = (int [16])0x0;
local_88 = (int [16])0x0;
local_78 = (int [16])0x0;
local_68 = (int [16])0x0;
pcVar28 = strchr((char *)param_1,0x20);
uVar42 = (uint)sVar27;
if (pcVar28 == (char *)0x0) {
pcVar28 = strchr((char *)param_1,0x2c);
if (pcVar28 == (char *)0x0) {
iVar36 = 0;
if (0 < (int)uVar42) {
ppuVar30 = __ctype_b_loc();
puVar2 = *ppuVar30;
if (uVar42 - 1 < 0xf) {
iVar43 = 0;
iVar164 = 0;
uVar39 = 0;
iVar36 = 0;
uVar38 = 0;
}
else {
iVar162 = 0;
iVar163 = 0;
iVar43 = 0;
iVar164 = 0;
pauVar34 = param_1;
do {
auVar129 = *pauVar34;
pauVar34 = pauVar34 + 1;
cStack_b7 = auVar129[1];
cVar35 = auVar129[0];
cStack_c6 = auVar129[2];
cStack_d5 = auVar129[3];
cStack_e4 = auVar129[4];
cStack_f3 = auVar129[5];
cStack_102 = auVar129[6];
cStack_111 = auVar129[7];
cStack_120 = auVar129[8];
cStack_12f = auVar129[9];
cStack_13e = auVar129[10];
cStack_14d = auVar129[0xb];
cStack_15c = auVar129[0xc];
cStack_17a = auVar129[0xe];
cStack_16b = auVar129[0xd];
cStack_189 = auVar129[0xf];
auVar216._0_2_ = -(ushort)((puVar2[cVar35] & (ushort)DAT_001030c0) != 0);
auVar216._2_2_ = -(ushort)((puVar2[cStack_b7] & DAT_001030c0._2_2_) != 0);
auVar216._4_2_ = -(ushort)((puVar2[cStack_c6] & DAT_001030c0._4_2_) != 0);
auVar216._6_2_ = -(ushort)((puVar2[cStack_d5] & DAT_001030c0._6_2_) != 0);
auVar216._8_2_ = -(ushort)((puVar2[cStack_e4] & _UNK_001030c8) != 0);
auVar216._10_2_ = -(ushort)((puVar2[cStack_f3] & _UNK_001030ca) != 0);
auVar216._12_2_ = -(ushort)((puVar2[cStack_102] & _UNK_001030cc) != 0);
auVar216._14_2_ = -(ushort)((puVar2[cStack_111] & _UNK_001030ce) != 0);
auVar211._0_14_ = auVar129._0_14_;
auVar211[0xe] = cStack_111;
auVar211[0xf] = -(cStack_111 < '\0');
auVar210._14_2_ = auVar211._14_2_;
auVar210._0_13_ = auVar129._0_13_;
auVar210[0xd] = -(cStack_102 < '\0');
auVar209._13_3_ = auVar210._13_3_;
auVar209._0_12_ = auVar129._0_12_;
auVar209[0xc] = cStack_102;
auVar208._12_4_ = auVar209._12_4_;
auVar208._0_11_ = auVar129._0_11_;
auVar208[0xb] = -(cStack_f3 < '\0');
auVar207._11_5_ = auVar208._11_5_;
auVar207._0_10_ = auVar129._0_10_;
auVar207[10] = cStack_f3;
auVar206._10_6_ = auVar207._10_6_;
auVar206._0_9_ = auVar129._0_9_;
auVar206[9] = -(cStack_e4 < '\0');
auVar205._9_7_ = auVar206._9_7_;
auVar205._0_8_ = auVar129._0_8_;
auVar205[8] = cStack_e4;
Var8 = CONCAT91(CONCAT81(auVar205._8_8_,-(cStack_d5 < '\0')),cStack_d5);
auVar7._2_10_ = Var8;
auVar7[1] = -(cStack_c6 < '\0');
auVar7[0] = cStack_c6;
auVar6._2_12_ = auVar7;
auVar6[1] = -(cStack_b7 < '\0');
auVar6[0] = cStack_b7;
auVar204._0_2_ = CONCAT11(-(cVar35 < '\0'),cVar35);
auVar204._2_14_ = auVar6;
uVar85 = CONCAT11(-(cStack_120 < '\0'),cStack_120);
uVar45 = CONCAT13(-(cStack_12f < '\0'),CONCAT12(cStack_12f,uVar85));
uVar47 = CONCAT15(-(cStack_13e < '\0'),CONCAT14(cStack_13e,uVar45));
uVar48 = CONCAT17(-(cStack_14d < '\0'),CONCAT16(cStack_14d,uVar47));
auVar49._0_10_ = CONCAT19(-(cStack_15c < '\0'),CONCAT18(cStack_15c,uVar48));
auVar49[10] = cStack_16b;
auVar49[0xb] = -(cStack_16b < '\0');
auVar54[0xc] = cStack_17a;
auVar54._0_12_ = auVar49;
auVar54[0xd] = -(cStack_17a < '\0');
auVar55[0xe] = cStack_189;
auVar55._0_14_ = auVar54;
auVar55[0xf] = -(cStack_189 < '\0');
sVar90 = (short)Var8;
sVar87 = (short)((unkuint10)auVar49._0_10_ >> 0x40);
auVar187._0_2_ = -(ushort)((puVar2[cStack_120] & (ushort)DAT_001030c0) != 0);
auVar187._2_2_ = -(ushort)((puVar2[cStack_12f] & DAT_001030c0._2_2_) != 0);
auVar187._4_2_ = -(ushort)((puVar2[cStack_13e] & DAT_001030c0._4_2_) != 0);
auVar187._6_2_ = -(ushort)((puVar2[cStack_14d] & DAT_001030c0._6_2_) != 0);
auVar187._8_2_ = -(ushort)((puVar2[cStack_15c] & _UNK_001030c8) != 0);
auVar187._10_2_ = -(ushort)((puVar2[cStack_16b] & _UNK_001030ca) != 0);
auVar187._12_2_ = -(ushort)((puVar2[cStack_17a] & _UNK_001030cc) != 0);
auVar187._14_2_ = -(ushort)((puVar2[cStack_189] & _UNK_001030ce) != 0);
auVar128._0_12_ = auVar204._0_12_;
auVar128._12_2_ = sVar90;
auVar128._14_2_ = -(ushort)(sVar90 < 0);
auVar127._12_4_ = auVar128._12_4_;
auVar127._0_10_ = auVar204._0_10_;
auVar127._10_2_ = -(ushort)(auVar7._0_2_ < 0);
auVar126._10_6_ = auVar127._10_6_;
auVar126._0_8_ = auVar204._0_8_;
auVar126._8_2_ = auVar7._0_2_;
auVar9._4_8_ = auVar126._8_8_;
auVar9._2_2_ = -(ushort)(auVar6._0_2_ < 0);
auVar9._0_2_ = auVar6._0_2_;
iVar202 = CONCAT22(-(ushort)(auVar205._8_2_ < 0),auVar205._8_2_);
auVar203._0_8_ =
CONCAT26(-(ushort)(auVar207._10_2_ < 0),CONCAT24(auVar207._10_2_,iVar202));
auVar203._8_2_ = auVar209._12_2_;
auVar203._10_2_ = -(ushort)(auVar209._12_2_ < 0);
auVar212._12_2_ = auVar210._14_2_;
auVar212._0_12_ = auVar203;
auVar212._14_2_ = -(ushort)(auVar205._8_8_ < 0);
iVar120 = CONCAT22(-(ushort)(cVar35 < '\0'),auVar204._0_2_) + (int)DAT_001030d0;
iVar159 = auVar9._0_4_ + DAT_001030d0._4_4_;
iVar161 = auVar126._8_4_ + _UNK_001030d8;
iVar192 = CONCAT22(-(ushort)(sVar87 < 0),sVar87);
auVar50._0_8_ = CONCAT26(-(ushort)(auVar49._10_2_ < 0),CONCAT24(auVar49._10_2_,iVar192))
;
auVar50._8_2_ = auVar54._12_2_;
auVar50._10_2_ = -(ushort)(auVar54._12_2_ < 0);
auVar56._12_2_ = auVar55._14_2_;
auVar56._0_12_ = auVar50;
auVar56._14_2_ = -(ushort)(auVar55._14_2_ < 0);
auVar99._12_2_ = (short)((ulong)uVar48 >> 0x30);
auVar99._0_12_ = auVar49;
auVar99._14_2_ = -(ushort)(cStack_14d < '\0');
auVar98._12_4_ = auVar99._12_4_;
auVar98._10_2_ = -(ushort)(cStack_13e < '\0');
auVar98._0_10_ = auVar49._0_10_;
auVar97._10_6_ = auVar98._10_6_;
auVar97._8_2_ = (short)((uint6)uVar47 >> 0x20);
auVar97._0_8_ = uVar48;
auVar96._8_8_ = auVar97._8_8_;
auVar96._6_2_ = -(ushort)(cStack_12f < '\0');
auVar96._0_6_ = uVar47;
auVar95._6_10_ = auVar96._6_10_;
auVar95._4_2_ = (short)((uint)uVar45 >> 0x10);
auVar95._0_4_ = uVar45;
iVar202 = iVar202 + (int)DAT_001030d0;
iVar213 = (int)((ulong)auVar203._0_8_ >> 0x20) + DAT_001030d0._4_4_;
iVar214 = auVar203._8_4_ + _UNK_001030d8;
iVar215 = auVar212._12_4_ + _UNK_001030dc;
iVar119 = iVar120 >> 0x1f;
iVar3 = iVar159 >> 0x1f;
iVar169 = iVar161 >> 0x1f;
iVar36 = auVar127._12_4_ + _UNK_001030dc >> 0x1f;
iVar93 = CONCAT22(-(ushort)(cStack_120 < '\0'),uVar85) + (int)DAT_001030d0;
iVar115 = auVar95._4_4_ + DAT_001030d0._4_4_;
iVar118 = auVar97._8_4_ + _UNK_001030d8;
iVar46 = iVar202 >> 0x1f;
iVar88 = iVar213 >> 0x1f;
iVar92 = iVar214 >> 0x1f;
iVar89 = iVar215 >> 0x1f;
iVar4 = iVar93 >> 0x1f;
iVar5 = iVar115 >> 0x1f;
iVar116 = iVar118 >> 0x1f;
iVar122 = auVar98._12_4_ + _UNK_001030dc >> 0x1f;
iVar192 = iVar192 + (int)DAT_001030d0;
iVar194 = (int)((ulong)auVar50._0_8_ >> 0x20) + DAT_001030d0._4_4_;
iVar196 = auVar50._8_4_ + _UNK_001030d8;
iVar197 = auVar56._12_4_ + _UNK_001030dc;
iVar121 = -(uint)((iVar120 - iVar119 & (uint)DAT_001030e0) + iVar119 ==
(uint)DAT_001030e0);
iVar159 = -(uint)((iVar159 - iVar3 & DAT_001030e0._4_4_) + iVar3 == DAT_001030e0._4_4_);
auVar123._0_8_ = CONCAT44(iVar159,iVar121);
auVar123._8_4_ = -(uint)((iVar161 - iVar169 & _UNK_001030e8) + iVar169 == _UNK_001030e8)
;
iVar3 = iVar192 >> 0x1f;
iVar120 = iVar194 >> 0x1f;
iVar119 = iVar196 >> 0x1f;
iVar169 = iVar197 >> 0x1f;
iVar46 = -(uint)((iVar202 - iVar46 & (uint)DAT_001030e0) + iVar46 == (uint)DAT_001030e0)
;
iVar88 = -(uint)((iVar213 - iVar88 & DAT_001030e0._4_4_) + iVar88 == DAT_001030e0._4_4_)
;
iVar92 = -(uint)((iVar214 - iVar92 & _UNK_001030e8) + iVar92 == _UNK_001030e8);
auVar132._12_2_ = (short)((uint)iVar159 >> 0x10);
auVar132._0_12_ = auVar123;
auVar132._14_2_ = (short)((uint)iVar88 >> 0x10);
uVar86 = (int2)iVar88;
auVar131._12_4_ = auVar132._12_4_;
auVar131._0_10_ = auVar123._0_10_;
auVar131._10_2_ = uVar86;
auVar130._10_6_ = auVar131._10_6_;
auVar130._8_2_ = (short)iVar159;
auVar130._0_8_ = auVar123._0_8_;
uVar85 = (int2)((uint)iVar46 >> 0x10);
auVar10._2_8_ = auVar130._8_8_;
auVar10._0_2_ = uVar85;
auVar10._10_6_ = 0;
auVar140._0_2_ = (int2)iVar121;
auVar129._12_4_ = 0;
auVar129._0_12_ = SUB1612(auVar10 << 0x30,4);
auVar129 = auVar129 << 0x20;
uVar91 = (int2)iVar92;
auVar136._0_12_ = auVar129._0_12_;
auVar136._12_2_ = uVar85;
auVar136._14_2_ = (short)((uint)iVar92 >> 0x10);
auVar135._12_4_ = auVar136._12_4_;
auVar135._0_10_ = auVar129._0_10_;
auVar135._10_2_ = (short)((uint)auVar123._8_4_ >> 0x10);
auVar134._10_6_ = auVar135._10_6_;
auVar134._0_8_ = auVar129._0_8_;
auVar134._8_2_ = (short)((uint)iVar121 >> 0x10);
auVar11._2_8_ = auVar134._8_8_;
auVar11._0_2_ = uVar91;
auVar11._10_6_ = 0;
auVar133._12_4_ = 0;
auVar133._0_12_ = SUB1612(auVar11 << 0x30,4);
auVar133 = auVar133 << 0x20;
auVar139._0_12_ = auVar133._0_12_;
auVar139._12_2_ = uVar91;
auVar139._14_2_ =
-(ushort)((iVar215 - iVar89 & _UNK_001030ec) + iVar89 == _UNK_001030ec);
auVar138._12_4_ = auVar139._12_4_;
auVar138._0_10_ = auVar133._0_10_;
auVar138._10_2_ = uVar86;
auVar137._10_6_ = auVar138._10_6_;
auVar137._0_8_ = auVar133._0_8_;
auVar137._8_2_ = (short)iVar46;
auVar140._8_8_ = auVar137._8_8_;
auVar140._6_2_ =
-(ushort)(((auVar127._12_4_ + _UNK_001030dc) - iVar36 & _UNK_001030ec) + iVar36 ==
_UNK_001030ec);
auVar140._4_2_ = (short)auVar123._8_4_;
auVar140._2_2_ = (short)iVar159;
auVar140 = auVar140 & auVar216;
iVar36 = -(uint)((iVar93 - iVar4 & (uint)DAT_001030e0) + iVar4 == (uint)DAT_001030e0);
iVar89 = -(uint)((iVar115 - iVar5 & DAT_001030e0._4_4_) + iVar5 == DAT_001030e0._4_4_);
auVar51._0_8_ = CONCAT44(iVar89,iVar36);
auVar51._8_4_ = -(uint)((iVar118 - iVar116 & _UNK_001030e8) + iVar116 == _UNK_001030e8);
iVar92 = -(uint)((iVar192 - iVar3 & (uint)DAT_001030e0) + iVar3 == (uint)DAT_001030e0);
iVar116 = -(uint)((iVar194 - iVar120 & DAT_001030e0._4_4_) + iVar120 ==
DAT_001030e0._4_4_);
iVar119 = -(uint)((iVar196 - iVar119 & _UNK_001030e8) + iVar119 == _UNK_001030e8);
auVar60._12_2_ = (short)((uint)iVar89 >> 0x10);
auVar60._0_12_ = auVar51;
auVar60._14_2_ = (short)((uint)iVar116 >> 0x10);
auVar59._12_4_ = auVar60._12_4_;
auVar59._0_10_ = auVar51._0_10_;
uVar86 = (int2)iVar116;
auVar59._10_2_ = uVar86;
auVar58._10_6_ = auVar59._10_6_;
auVar58._8_2_ = (short)iVar89;
auVar58._0_8_ = auVar51._0_8_;
uVar85 = (int2)((uint)iVar92 >> 0x10);
auVar12._2_8_ = auVar58._8_8_;
auVar12._0_2_ = uVar85;
auVar12._10_6_ = 0;
auVar68._0_2_ = (int2)iVar36;
auVar57._12_4_ = 0;
auVar57._0_12_ = SUB1612(auVar12 << 0x30,4);
auVar57 = auVar57 << 0x20;
uVar91 = (int2)iVar119;
auVar64._0_12_ = auVar57._0_12_;
auVar64._12_2_ = uVar85;
auVar64._14_2_ = (short)((uint)iVar119 >> 0x10);
auVar63._12_4_ = auVar64._12_4_;
auVar63._0_10_ = auVar57._0_10_;
auVar63._10_2_ = (short)((uint)auVar51._8_4_ >> 0x10);
auVar62._10_6_ = auVar63._10_6_;
auVar62._0_8_ = auVar57._0_8_;
auVar62._8_2_ = (short)((uint)iVar36 >> 0x10);
auVar13._2_8_ = auVar62._8_8_;
auVar13._0_2_ = uVar91;
auVar13._10_6_ = 0;
auVar61._12_4_ = 0;
auVar61._0_12_ = SUB1612(auVar13 << 0x30,4);
auVar61 = auVar61 << 0x20;
auVar67._0_12_ = auVar61._0_12_;
auVar67._12_2_ = uVar91;
auVar67._14_2_ =
-(ushort)((iVar197 - iVar169 & _UNK_001030ec) + iVar169 == _UNK_001030ec);
auVar66._12_4_ = auVar67._12_4_;
auVar66._0_10_ = auVar61._0_10_;
auVar66._10_2_ = uVar86;
auVar65._10_6_ = auVar66._10_6_;
auVar65._0_8_ = auVar61._0_8_;
auVar65._8_2_ = (short)iVar92;
auVar68._8_8_ = auVar65._8_8_;
auVar68._6_2_ =
-(ushort)(((auVar98._12_4_ + _UNK_001030dc) - iVar122 & _UNK_001030ec) + iVar122 ==
_UNK_001030ec);
auVar68._4_2_ = (short)auVar51._8_4_;
auVar68._2_2_ = (short)iVar89;
auVar68 = auVar68 & auVar187;
auVar190._0_12_ = auVar140._0_12_;
auVar190._12_2_ = auVar140._6_2_;
auVar190._14_2_ = -(ushort)(auVar140._6_2_ < 0);
auVar189._12_4_ = auVar190._12_4_;
auVar189._0_10_ = auVar140._0_10_;
auVar189._10_2_ = -(ushort)(auVar140._4_2_ < 0);
auVar188._10_6_ = auVar189._10_6_;
auVar188._0_8_ = auVar140._0_8_;
auVar188._8_2_ = auVar140._4_2_;
auVar14._4_8_ = auVar188._8_8_;
auVar14._2_2_ = -(ushort)(auVar140._2_2_ < 0);
auVar14._0_2_ = auVar140._2_2_;
iVar89 = CONCAT22(-(ushort)(auVar140._8_2_ < 0),auVar140._8_2_);
auVar124._0_8_ =
CONCAT26(-(ushort)(auVar140._10_2_ < 0),CONCAT24(auVar140._10_2_,iVar89));
auVar124._8_2_ = auVar140._12_2_;
auVar124._10_2_ = -(ushort)(auVar140._12_2_ < 0);
auVar141._12_2_ = auVar140._14_2_;
auVar141._0_12_ = auVar124;
auVar141._14_2_ = -(ushort)(auVar140._14_2_ < 0);
auVar144._0_12_ = auVar68._0_12_;
auVar144._12_2_ = auVar68._6_2_;
auVar144._14_2_ = -(ushort)(auVar68._6_2_ < 0);
auVar143._12_4_ = auVar144._12_4_;
auVar143._0_10_ = auVar68._0_10_;
auVar143._10_2_ = -(ushort)(auVar68._4_2_ < 0);
auVar142._10_6_ = auVar143._10_6_;
auVar142._0_8_ = auVar68._0_8_;
auVar142._8_2_ = auVar68._4_2_;
auVar15._4_8_ = auVar142._8_8_;
auVar15._2_2_ = -(ushort)(auVar68._2_2_ < 0);
auVar15._0_2_ = auVar68._2_2_;
iVar36 = CONCAT22(-(ushort)(auVar68._8_2_ < 0),auVar68._8_2_);
auVar52._0_8_ = CONCAT26(-(ushort)(auVar68._10_2_ < 0),CONCAT24(auVar68._10_2_,iVar36));
auVar52._8_2_ = auVar68._12_2_;
auVar52._10_2_ = -(ushort)(auVar68._12_2_ < 0);
auVar69._12_2_ = auVar68._14_2_;
auVar69._0_12_ = auVar52;
auVar69._14_2_ = -(ushort)(auVar68._14_2_ < 0);
iVar162 = (((iVar162 - CONCAT22(-(ushort)(auVar140._0_2_ < 0),auVar140._0_2_)) - iVar89)
- CONCAT22(-(ushort)(auVar68._0_2_ < 0),auVar68._0_2_)) - iVar36;
iVar163 = (((iVar163 - auVar14._0_4_) - (int)((ulong)auVar124._0_8_ >> 0x20)) -
auVar15._0_4_) - (int)((ulong)auVar52._0_8_ >> 0x20);
iVar43 = (((iVar43 - auVar188._8_4_) - auVar124._8_4_) - auVar142._8_4_) - auVar52._8_4_
;
iVar164 = (((iVar164 - auVar189._12_4_) - auVar141._12_4_) - auVar143._12_4_) -
auVar69._12_4_;
} while (param_1 + (sVar27 >> 4 & 0xfffffff) != pauVar34);
uVar38 = uVar42 & 0xfffffff0;
uVar39 = (ulong)uVar38;
iVar36 = iVar43 + iVar162 + iVar164 + iVar163;
iVar43 = iVar43 + iVar162;
iVar164 = iVar164 + iVar163;
if ((sVar27 & 0xf) == 0) goto LAB_00101e50;
}
uVar32 = uVar42 - (int)uVar39;
if (6 < uVar32 - 1) {
uVar39 = *(ulong *)(*param_1 + uVar39);
cVar35 = (char)(uVar39 >> 8);
cVar37 = (char)uVar39;
cVar40 = (char)(uVar39 >> 0x18);
cVar41 = (char)(uVar39 >> 0x10);
auVar165._0_2_ = -(ushort)((puVar2[cVar37] & (ushort)DAT_001030c0) != 0);
auVar165._2_2_ = -(ushort)((puVar2[cVar35] & DAT_001030c0._2_2_) != 0);
auVar165._4_2_ = -(ushort)((puVar2[cVar41] & DAT_001030c0._4_2_) != 0);
auVar165._6_2_ = -(ushort)((puVar2[cVar40] & DAT_001030c0._6_2_) != 0);
auVar165._8_8_ = 0;
cVar44 = -(cVar37 < '\0');
cVar181 = (char)(uVar39 >> 0x20);
cVar182 = (char)(uVar39 >> 0x28);
cVar183 = (char)(uVar39 >> 0x30);
uVar184 = (int)(uVar39 >> 0x38);
auVar177._8_6_ = 0;
auVar177._0_8_ = uVar39;
auVar177[0xe] = uVar184;
auVar177[0xf] = -((long)uVar39 < 0);
auVar176._14_2_ = auVar177._14_2_;
auVar176._8_5_ = 0;
auVar176._0_8_ = uVar39;
auVar176[0xd] = -(cVar183 < '\0');
auVar175._13_3_ = auVar176._13_3_;
auVar175._8_4_ = 0;
auVar175._0_8_ = uVar39;
auVar175[0xc] = cVar183;
auVar174._12_4_ = auVar175._12_4_;
auVar174._8_3_ = 0;
auVar174._0_8_ = uVar39;
auVar174[0xb] = -(cVar182 < '\0');
auVar173._11_5_ = auVar174._11_5_;
auVar173._8_2_ = 0;
auVar173._0_8_ = uVar39;
auVar173[10] = cVar182;
auVar172._10_6_ = auVar173._10_6_;
auVar172[8] = 0;
auVar172._0_8_ = uVar39;
auVar172[9] = -(cVar181 < '\0');
auVar171._9_7_ = auVar172._9_7_;
auVar171[8] = cVar181;
auVar171._0_8_ = uVar39;
Var8 = CONCAT91(CONCAT81(auVar171._8_8_,-(cVar40 < '\0')),cVar40);
auVar17._2_10_ = Var8;
auVar17[1] = -(cVar41 < '\0');
auVar17[0] = cVar41;
auVar16._2_12_ = auVar17;
auVar16[1] = -(cVar35 < '\0');
auVar16[0] = cVar35;
auVar170._0_2_ = CONCAT11(cVar44,cVar37);
auVar170._2_14_ = auVar16;
auVar185._0_2_ =
-(ushort)(((ushort)DAT_001030c0 & puVar2[(long)(uVar39 << 0x18) >> 0x38]) != 0);
auVar185._2_2_ =
-(ushort)((DAT_001030c0._2_2_ & puVar2[(long)(uVar39 << 0x10) >> 0x38]) != 0);
auVar185._4_2_ =
-(ushort)((DAT_001030c0._4_2_ & puVar2[(long)(uVar39 << 8) >> 0x38]) != 0);
auVar185._6_2_ = -(ushort)((DAT_001030c0._6_2_ & puVar2[(long)uVar39 >> 0x38]) != 0);
auVar185._8_8_ = 0;
auVar152._8_6_ = 0;
auVar152._0_8_ = uVar39;
auVar152[0xe] = uVar184;
auVar152[0xf] = -((long)uVar39 < 0);
auVar151._14_2_ = auVar152._14_2_;
auVar151._8_5_ = 0;
auVar151._0_8_ = uVar39;
auVar151[0xd] = -(cVar183 < '\0');
auVar150._13_3_ = auVar151._13_3_;
auVar150._8_4_ = 0;
auVar150._0_8_ = uVar39;
auVar150[0xc] = cVar183;
auVar149._12_4_ = auVar150._12_4_;
auVar149._8_3_ = 0;
auVar149._0_8_ = uVar39;
auVar149[0xb] = -(cVar182 < '\0');
auVar148._11_5_ = auVar149._11_5_;
auVar148._8_2_ = 0;
auVar148._0_8_ = uVar39;
auVar148[10] = cVar182;
auVar147._10_6_ = auVar148._10_6_;
auVar147[8] = 0;
auVar147._0_8_ = uVar39;
auVar147[9] = -(cVar181 < '\0');
auVar146._9_7_ = auVar147._9_7_;
auVar146[8] = cVar181;
auVar146._0_8_ = uVar39;
lVar33 = auVar146._8_8_;
auVar20._1_8_ = lVar33;
auVar20[0] = -(cVar40 < '\0');
auVar20._9_7_ = 0;
auVar19._10_6_ = 0;
auVar19._0_10_ = SUB1610(auVar20 << 0x38,6);
auVar18._11_5_ = 0;
auVar18._0_11_ = SUB1611(auVar19 << 0x30,5);
auVar145._4_12_ = SUB1612(auVar18 << 0x28,4);
auVar145[3] = -(cVar35 < '\0');
auVar145[2] = cVar35;
auVar145[1] = cVar44;
auVar145[0] = cVar37;
auVar125._8_4_ = auVar145._0_4_;
auVar125._0_8_ = lVar33;
sVar90 = auVar17._0_2_;
sVar114 = (short)Var8;
sVar87 = auVar150._12_2_;
auVar102._0_12_ = auVar170._0_12_;
auVar102._12_2_ = sVar114;
auVar102._14_2_ = -(ushort)(sVar114 < 0);
auVar101._12_4_ = auVar102._12_4_;
auVar101._0_10_ = auVar170._0_10_;
auVar101._10_2_ = -(ushort)(sVar90 < 0);
auVar100._10_6_ = auVar101._10_6_;
auVar100._0_8_ = auVar170._0_8_;
auVar100._8_2_ = sVar90;
auVar21._4_8_ = auVar100._8_8_;
auVar21._2_2_ = -(ushort)(auVar16._0_2_ < 0);
auVar21._0_2_ = auVar16._0_2_;
auVar180._12_2_ = sVar114;
auVar180._0_12_ = auVar102._0_12_;
auVar180._14_2_ = -(ushort)(sVar114 < 0);
auVar179._12_4_ = auVar180._12_4_;
auVar179._10_2_ = -(ushort)(sVar90 < 0);
auVar179._0_10_ = auVar101._0_10_;
auVar178._10_6_ = auVar179._10_6_;
auVar178._8_2_ = sVar90;
auVar178._0_8_ = auVar100._0_8_;
iVar163 = CONCAT22(-(ushort)(cVar37 < '\0'),auVar170._0_2_) + (int)DAT_001030d0;
iVar89 = auVar21._0_4_ + DAT_001030d0._4_4_;
auVar73._12_2_ = auVar151._14_2_;
auVar73._0_12_ = auVar125;
auVar73._14_2_ = -(ushort)(lVar33 < 0);
auVar72._12_4_ = auVar73._12_4_;
auVar72._0_10_ = auVar125._0_10_;
auVar72._10_2_ = -(ushort)(sVar87 < 0);
auVar71._10_6_ = auVar72._10_6_;
auVar71._8_2_ = sVar87;
auVar71._0_8_ = lVar33;
auVar70._8_8_ = auVar71._8_8_;
auVar70._6_2_ = -(ushort)(auVar146._8_4_ < 0);
auVar70._4_2_ = auVar148._10_2_;
auVar70._0_4_ = auVar146._8_4_;
iVar169 = auVar178._8_4_ + (int)DAT_001030d0;
auVar155._12_2_ = auVar151._14_2_;
auVar155._0_12_ = auVar125;
auVar155._14_2_ = -(ushort)(lVar33 < 0);
auVar154._12_4_ = auVar155._12_4_;
auVar154._10_2_ = -(ushort)(sVar87 < 0);
auVar154._0_10_ = auVar72._0_10_;
auVar153._10_6_ = auVar154._10_6_;
auVar153._8_2_ = sVar87;
auVar153._0_8_ = lVar33;
iVar36 = CONCAT22(-(ushort)(auVar146._8_2_ < 0),auVar146._8_2_) + (int)DAT_001030d0;
iVar162 = auVar70._4_4_ + DAT_001030d0._4_4_;
iVar122 = auVar153._8_4_ + (int)DAT_001030d0;
uVar200 = -(uint)(iVar163 < 0) & (uint)DAT_001030e0;
uVar201 = -(uint)(iVar89 < 0) & DAT_001030e0._4_4_;
uVar198 = -(uint)(iVar169 < 0) & (uint)DAT_001030e0;
uVar199 = -(uint)(auVar179._12_4_ + DAT_001030d0._4_4_ < 0) & DAT_001030e0._4_4_;
uVar193 = -(uint)(iVar36 < 0) & (uint)DAT_001030e0;
uVar195 = -(uint)(iVar162 < 0) & DAT_001030e0._4_4_;
uVar186 = -(uint)(iVar122 < 0) & (uint)DAT_001030e0;
uVar191 = -(uint)(auVar154._12_4_ + DAT_001030d0._4_4_ < 0) & DAT_001030e0._4_4_;
iVar163 = -(uint)((iVar163 + uVar200 & (uint)DAT_001030e0) - uVar200 == (uint)DAT_001030e0
);
iVar89 = -(uint)((iVar89 + uVar201 & DAT_001030e0._4_4_) - uVar201 == DAT_001030e0._4_4_);
auVar94._0_8_ = CONCAT44(iVar89,iVar163);
auVar94._8_4_ = 0xffffffff;
iVar92 = -(uint)((iVar169 + uVar198 & (uint)DAT_001030e0) - uVar198 == (uint)DAT_001030e0)
;
iVar116 = -(uint)((auVar179._12_4_ + DAT_001030d0._4_4_ + uVar199 & DAT_001030e0._4_4_) -
uVar199 == DAT_001030e0._4_4_);
iVar36 = -(uint)((iVar36 + uVar193 & (uint)DAT_001030e0) - uVar193 == (uint)DAT_001030e0);
iVar162 = -(uint)((iVar162 + uVar195 & DAT_001030e0._4_4_) - uVar195 == DAT_001030e0._4_4_
);
auVar53._0_8_ = CONCAT44(iVar162,iVar36);
auVar53._8_4_ = 0xffffffff;
iVar122 = -(uint)((iVar122 + uVar186 & (uint)DAT_001030e0) - uVar186 == (uint)DAT_001030e0
);
iVar169 = -(uint)((auVar154._12_4_ + DAT_001030d0._4_4_ + uVar191 & DAT_001030e0._4_4_) -
uVar191 == DAT_001030e0._4_4_);
uVar91 = (int2)((uint)iVar116 >> 0x10);
uVar160 = (int2)((uint)iVar89 >> 0x10);
uVar86 = (int2)iVar116;
uVar85 = (int2)((uint)iVar92 >> 0x10);
auVar106._12_2_ = uVar160;
auVar106._0_12_ = auVar94;
auVar106._14_2_ = uVar91;
auVar105._12_4_ = auVar106._12_4_;
auVar105._10_2_ = uVar86;
auVar105._0_10_ = auVar94._0_10_;
auVar104._10_6_ = auVar105._10_6_;
auVar104._8_2_ = (short)iVar89;
auVar104._0_8_ = auVar94._0_8_;
auVar22._2_8_ = auVar104._8_8_;
auVar22._0_2_ = uVar85;
auVar22._10_6_ = 0;
auVar103._12_4_ = 0;
auVar103._0_12_ = SUB1612(auVar22 << 0x30,4);
auVar103 = auVar103 << 0x20;
auVar109._0_12_ = auVar103._0_12_;
auVar109._12_2_ = uVar85;
auVar109._14_2_ = uVar91;
auVar108._12_4_ = auVar109._12_4_;
auVar108._0_10_ = auVar103._0_10_;
auVar108._10_2_ = uVar160;
auVar107._10_6_ = auVar108._10_6_;
auVar107._0_8_ = auVar103._0_8_;
auVar107._8_2_ = (short)((uint)iVar163 >> 0x10);
auVar110._8_8_ = auVar107._8_8_;
auVar110._6_2_ = uVar86;
auVar110._4_2_ = (short)iVar92;
auVar110._2_2_ = (short)iVar89;
auVar110._0_2_ = (short)iVar163;
auVar110 = auVar110 & auVar165;
uVar160 = (int2)((uint)iVar169 >> 0x10);
uVar85 = (int2)((uint)iVar162 >> 0x10);
auVar77._12_2_ = uVar85;
auVar77._0_12_ = auVar53;
auVar77._14_2_ = uVar160;
auVar76._12_4_ = auVar77._12_4_;
auVar76._0_10_ = auVar53._0_10_;
uVar91 = (int2)iVar169;
auVar76._10_2_ = uVar91;
auVar75._10_6_ = auVar76._10_6_;
auVar75._8_2_ = (short)iVar162;
auVar75._0_8_ = auVar53._0_8_;
uVar86 = (int2)((uint)iVar122 >> 0x10);
auVar23._2_8_ = auVar75._8_8_;
auVar23._0_2_ = uVar86;
auVar23._10_6_ = 0;
auVar81._0_2_ = (int2)iVar36;
auVar74._12_4_ = 0;
auVar74._0_12_ = SUB1612(auVar23 << 0x30,4);
auVar74 = auVar74 << 0x20;
sVar114 = auVar110._4_2_;
sVar117 = auVar110._6_2_;
auVar80._0_12_ = auVar74._0_12_;
auVar80._12_2_ = uVar86;
auVar80._14_2_ = uVar160;
auVar79._12_4_ = auVar80._12_4_;
auVar79._0_10_ = auVar74._0_10_;
auVar79._10_2_ = uVar85;
auVar78._10_6_ = auVar79._10_6_;
auVar78._0_8_ = auVar74._0_8_;
auVar78._8_2_ = (short)((uint)iVar36 >> 0x10);
auVar81._8_8_ = auVar78._8_8_;
auVar81._6_2_ = uVar91;
auVar81._4_2_ = (short)iVar122;
auVar81._2_2_ = (short)iVar162;
auVar81 = auVar81 & auVar185;
auVar168._0_12_ = auVar110._0_12_;
auVar168._12_2_ = sVar117;
auVar168._14_2_ = -(ushort)(sVar117 < 0);
auVar167._12_4_ = auVar168._12_4_;
auVar167._0_10_ = auVar110._0_10_;
auVar167._10_2_ = -(ushort)(sVar114 < 0);
auVar166._10_6_ = auVar167._10_6_;
auVar166._0_8_ = auVar110._0_8_;
auVar166._8_2_ = sVar114;
auVar24._4_8_ = auVar166._8_8_;
auVar24._2_2_ = -(ushort)(auVar110._2_2_ < 0);
auVar24._0_2_ = auVar110._2_2_;
sVar87 = auVar81._4_2_;
sVar90 = auVar81._6_2_;
auVar113._12_2_ = sVar117;
auVar113._0_12_ = auVar168._0_12_;
auVar113._14_2_ = -(ushort)(sVar117 < 0);
auVar112._12_4_ = auVar113._12_4_;
auVar112._10_2_ = -(ushort)(sVar114 < 0);
auVar112._0_10_ = auVar167._0_10_;
auVar111._10_6_ = auVar112._10_6_;
auVar111._8_2_ = sVar114;
auVar111._0_8_ = auVar166._0_8_;
auVar158._0_12_ = auVar81._0_12_;
auVar158._12_2_ = sVar90;
auVar158._14_2_ = -(ushort)(sVar90 < 0);
auVar157._12_4_ = auVar158._12_4_;
auVar157._0_10_ = auVar81._0_10_;
auVar157._10_2_ = -(ushort)(sVar87 < 0);
auVar156._10_6_ = auVar157._10_6_;
auVar156._0_8_ = auVar81._0_8_;
auVar156._8_2_ = sVar87;
auVar25._4_8_ = auVar156._8_8_;
auVar25._2_2_ = -(ushort)(auVar81._2_2_ < 0);
auVar25._0_2_ = auVar81._2_2_;
auVar84._12_2_ = sVar90;
auVar84._0_12_ = auVar158._0_12_;
auVar84._14_2_ = -(ushort)(sVar90 < 0);
auVar83._12_4_ = auVar84._12_4_;
auVar83._10_2_ = -(ushort)(sVar87 < 0);
auVar83._0_10_ = auVar157._0_10_;
auVar82._10_6_ = auVar83._10_6_;
auVar82._8_2_ = sVar87;
auVar82._0_8_ = auVar156._0_8_;
iVar36 = ((((iVar43 - CONCAT22(-(ushort)(auVar110._0_2_ < 0),auVar110._0_2_)) -
auVar111._8_4_) - CONCAT22(-(ushort)(auVar81._0_2_ < 0),auVar81._0_2_)) -
auVar82._8_4_) +
((((iVar164 - auVar24._0_4_) - auVar112._12_4_) - auVar25._0_4_) - auVar83._12_4_
);
uVar38 = uVar38 + (uVar32 & 0xfffffff8);
if ((uVar32 & 7) == 0) goto LAB_00101e50;
}
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)uVar38] * 2 + 1) & 2) != 0) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)uVar38] + -0x61) % 2 == 1);
}
if ((int)(uVar38 + 1) < (int)uVar42) {
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 1)] * 2 + 1) & 2) != 0
) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 1)] + -0x61) % 2 == 1);
}
if ((int)(uVar38 + 2) < (int)uVar42) {
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 2)] * 2 + 1) & 2) !=
0) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 2)] + -0x61) % 2 == 1);
}
if ((int)(uVar38 + 3) < (int)uVar42) {
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 3)] * 2 + 1) & 2)
!= 0) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 3)] + -0x61) % 2 == 1);
}
if ((int)(uVar38 + 4) < (int)uVar42) {
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 4)] * 2 + 1) & 2
) != 0) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 4)] + -0x61) % 2 == 1);
}
if ((int)(uVar38 + 5) < (int)uVar42) {
if ((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 5)] * 2 + 1) &
2) != 0) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 5)] + -0x61) % 2 == 1)
;
}
if (((int)(uVar38 + 6) < (int)uVar42) &&
((*(byte *)((long)puVar2 + (long)(char)(*param_1)[(int)(uVar38 + 6)] * 2 + 1) &
2) != 0)) {
iVar36 = iVar36 + (uint)(((char)(*param_1)[(int)(uVar38 + 6)] + -0x61) % 2 == 1)
;
}
}
}
}
}
}
}
LAB_00101e50:
puVar29 = (int8 *)malloc(8);
pvVar31 = malloc(0xc);
*puVar29 = pvVar31;
iVar43 = 1;
__sprintf_chk(pvVar31,2,0xc,&DAT_00103004,iVar36);
goto LAB_001016e1;
}
}
puVar29 = (int8 *)malloc((long)(int)(uVar42 + 1) << 3);
if ((int)uVar42 < 0) {
iVar43 = 0;
}
else {
iVar43 = 0;
iVar36 = 0;
puVar26 = *param_1;
do {
while( true ) {
bVar1 = (*param_1)[0];
if ((bVar1 < 0x2d) && ((0x100100000001U >> ((ulong)bVar1 & 0x3f) & 1) != 0)) break;
lVar33 = (long)iVar36;
param_1 = (int (*) [16])(*param_1 + 1);
iVar36 = iVar36 + 1;
local_a8[lVar33] = bVar1;
if ((int (*) [16])(puVar26 + (sVar27 & 0xffffffff) + 1) == param_1) goto LAB_001016e1;
}
if (0 < iVar36) {
local_a8[iVar36] = 0;
pcVar28 = strdup(local_a8);
lVar33 = (long)iVar43;
iVar43 = iVar43 + 1;
puVar29[lVar33] = pcVar28;
iVar36 = 0;
}
param_1 = (int (*) [16])(*param_1 + 1);
} while ((int (*) [16])(puVar26 + (sVar27 & 0xffffffff) + 1) != param_1);
}
LAB_001016e1:
*param_2 = iVar43;
if (local_40 == *(long *)(in_FS_OFFSET + 0x28)) {
return puVar29;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
1,160 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
assert(func0(list4, 6) == true);
int list5[] = {1, 2, 3, 4, 5, 6, 7};
assert(func0(list5, 7) == true);
int list6[] = {1, 3, 2, 4, 5, 6, 7};
assert(func0(list6, 7) == false);
assert(func0(NULL, 0) == true);
int list7[] = {1};
assert(func0(list7, 1) == true);
int list8[] = {3, 2, 1};
assert(func0(list8, 3) == false);
int list9[] = {1, 2, 2, 2, 3, 4};
assert(func0(list9, 6) == false);
int list10[] = {1, 2, 3, 3, 3, 4};
assert(func0(list10, 6) == false);
int list11[] = {1, 2, 2, 3, 3, 4};
assert(func0(list11, 6) == true);
int list12[] = {1, 2, 3, 4};
assert(func0(list12, 4) == true);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 1188 <func0+0x1f>
mov $0x1,%eax
jmpq 1250 <func0+0xe7>
movl $0x1,-0x4(%rbp)
jmpq 123f <func0+0xd6>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jge 11ce <func0+0x65>
mov $0x0,%eax
jmpq 1250 <func0+0xe7>
cmpl $0x1,-0x4(%rbp)
jle 123b <func0+0xd2>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 123b <func0+0xd2>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0x4(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x8(%rax),%rcx
mov -0x18(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
cmp %eax,%edx
jne 123b <func0+0xd2>
mov $0x0,%eax
jmp 1250 <func0+0xe7>
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 1194 <func0+0x2b>
mov $0x1,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jnz short loc_1188
mov eax, 1
jmp loc_1250
loc_1188:
mov [rbp+var_4], 1
jmp loc_123F
loc_1194:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jge short loc_11CE
mov eax, 0
jmp loc_1250
loc_11CE:
cmp [rbp+var_4], 1
jle short loc_123B
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rcx, [rax-4]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_123B
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_4]
cdqe
shl rax, 2
lea rcx, [rax-8]
mov rax, [rbp+var_18]
add rax, rcx
mov eax, [rax]
cmp edx, eax
jnz short loc_123B
mov eax, 0
jmp short loc_1250
loc_123B:
add [rbp+var_4], 1
loc_123F:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl loc_1194
mov eax, 1
loc_1250:
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int i; // [rsp+18h] [rbp-4h]
if ( !a2 )
return 1LL;
for ( i = 1; i < a2; ++i )
{
if ( *(_DWORD *)(4LL * i + a1) < *(_DWORD *)(4LL * i - 4 + a1) )
return 0LL;
if ( i > 1
&& *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * i - 4 + a1)
&& *(_DWORD *)(4LL * i + a1) == *(_DWORD *)(4LL * i - 8 + a1) )
{
return 0LL;
}
}
return 1LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101188
MOV EAX,0x1
JMP 0x00101250
LAB_00101188:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0010123f
LAB_00101194:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JGE 0x001011ce
MOV EAX,0x0
JMP 0x00101250
LAB_001011ce:
CMP dword ptr [RBP + -0x4],0x1
JLE 0x0010123b
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x0010123b
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x4]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EDX,EAX
JNZ 0x0010123b
MOV EAX,0x0
JMP 0x00101250
LAB_0010123b:
ADD dword ptr [RBP + -0x4],0x1
LAB_0010123f:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x00101194
MOV EAX,0x1
LAB_00101250:
POP RBP
RET
|
int8 func0(long param_1,int param_2)
{
int local_c;
if (param_2 != 0) {
for (local_c = 1; local_c < param_2; local_c = local_c + 1) {
if (*(int *)(param_1 + (long)local_c * 4) < *(int *)(param_1 + (long)local_c * 4 + -4)) {
return 0;
}
if (((1 < local_c) &&
(*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_1 + (long)local_c * 4 + -4))) &&
(*(int *)(param_1 + (long)local_c * 4) == *(int *)(param_1 + (long)local_c * 4 + -8))) {
return 0;
}
}
}
return 1;
}
|
1,161 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
assert(func0(list4, 6) == true);
int list5[] = {1, 2, 3, 4, 5, 6, 7};
assert(func0(list5, 7) == true);
int list6[] = {1, 3, 2, 4, 5, 6, 7};
assert(func0(list6, 7) == false);
assert(func0(NULL, 0) == true);
int list7[] = {1};
assert(func0(list7, 1) == true);
int list8[] = {3, 2, 1};
assert(func0(list8, 3) == false);
int list9[] = {1, 2, 2, 2, 3, 4};
assert(func0(list9, 6) == false);
int list10[] = {1, 2, 3, 3, 3, 4};
assert(func0(list10, 6) == false);
int list11[] = {1, 2, 2, 3, 3, 4};
assert(func0(list11, 6) == true);
int list12[] = {1, 2, 3, 4};
assert(func0(list12, 4) == true);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 11ad <func0+0x44>
lea -0x2(%rsi),%esi
add $0x2,%rsi
mov $0x1,%eax
jmp 1189 <func0+0x20>
add $0x1,%rax
cmp %rsi,%rax
je 11a7 <func0+0x3e>
mov (%rdi,%rax,4),%edx
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,%edx
jl 11b3 <func0+0x4a>
jne 1180 <func0+0x17>
cmp $0x1,%eax
jle 1180 <func0+0x17>
cmp -0x8(%rdi,%rax,4),%edx
jne 1180 <func0+0x17>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
mov $0x1,%eax
retq
mov $0x0,%eax
retq
|
func0:
endbr64
mov eax, 1
cmp esi, 1
jle short locret_11A6
mov esi, esi
mov eax, 1
jmp short loc_1189
loc_1180:
add rax, 1
cmp rax, rsi
jz short loc_11A7
loc_1189:
mov edx, [rdi+rax*4]
mov ecx, [rdi+rax*4-4]
cmp edx, ecx
jl short loc_11AD
jnz short loc_1180
cmp eax, 1
jle short loc_1180
cmp edx, [rdi+rax*4-8]
jnz short loc_1180
mov eax, 0
locret_11A6:
retn
loc_11A7:
mov eax, 1
retn
loc_11AD:
mov eax, 0
retn
|
long long func0(long long a1, int a2)
{
long long result; // rax
long long v3; // rax
int v4; // edx
int v5; // ecx
result = 1LL;
if ( a2 > 1 )
{
v3 = 1LL;
while ( 1 )
{
v4 = *(_DWORD *)(a1 + 4 * v3);
v5 = *(_DWORD *)(a1 + 4 * v3 - 4);
if ( v4 < v5 )
break;
if ( v4 == v5 && (int)v3 > 1 && v4 == *(_DWORD *)(a1 + 4 * v3 - 8) )
return 0LL;
if ( ++v3 == a2 )
return 1LL;
}
return 0LL;
}
return result;
}
|
func0:
ENDBR64
MOV EAX,0x1
CMP ESI,0x1
JLE 0x001011a6
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101189
LAB_00101180:
ADD RAX,0x1
CMP RAX,RSI
JZ 0x001011a7
LAB_00101189:
MOV EDX,dword ptr [RDI + RAX*0x4]
MOV ECX,dword ptr [RDI + RAX*0x4 + -0x4]
CMP EDX,ECX
JL 0x001011ad
JNZ 0x00101180
CMP EAX,0x1
JLE 0x00101180
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x8]
JNZ 0x00101180
MOV EAX,0x0
LAB_001011a6:
RET
LAB_001011a7:
MOV EAX,0x1
RET
LAB_001011ad:
MOV EAX,0x0
RET
|
int8 func0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
int8 uVar3;
ulong uVar4;
uVar3 = 1;
if (1 < (int)param_2) {
uVar4 = 1;
while( true ) {
iVar1 = *(int *)(param_1 + uVar4 * 4);
iVar2 = *(int *)(param_1 + -4 + uVar4 * 4);
if (iVar1 < iVar2) {
return 0;
}
if (((iVar1 == iVar2) && (1 < (int)uVar4)) && (iVar1 == *(int *)(param_1 + -8 + uVar4 * 4)))
break;
uVar4 = uVar4 + 1;
if (uVar4 == param_2) {
return 1;
}
}
uVar3 = 0;
}
return uVar3;
}
|
1,162 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
assert(func0(list4, 6) == true);
int list5[] = {1, 2, 3, 4, 5, 6, 7};
assert(func0(list5, 7) == true);
int list6[] = {1, 3, 2, 4, 5, 6, 7};
assert(func0(list6, 7) == false);
assert(func0(NULL, 0) == true);
int list7[] = {1};
assert(func0(list7, 1) == true);
int list8[] = {3, 2, 1};
assert(func0(list8, 3) == false);
int list9[] = {1, 2, 2, 2, 3, 4};
assert(func0(list9, 6) == false);
int list10[] = {1, 2, 3, 3, 3, 4};
assert(func0(list10, 6) == false);
int list11[] = {1, 2, 2, 3, 3, 4};
assert(func0(list11, 6) == true);
int list12[] = {1, 2, 3, 4};
assert(func0(list12, 4) == true);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
je 1600 <func0+0x10>
jmp 15a0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0_part_0:
cmp esi, 1
jle short loc_1568
mov esi, esi
mov eax, 1
jmp short loc_1549
loc_1540:
add rax, 1
cmp rsi, rax
jz short loc_1568
loc_1549:
mov edx, [rdi+rax*4]
cmp edx, [rdi+rax*4-4]
jl short loc_155F
jnz short loc_1540
cmp eax, 1
jz short loc_1540
cmp edx, [rdi+rax*4-8]
jnz short loc_1540
loc_155F:
xor eax, eax
retn
loc_1568:
mov eax, 1
retn
|
long long func0_part_0(long long a1, int a2)
{
long long v2; // rax
int v3; // edx
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 < *(_DWORD *)(a1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(a1 + 4 * v2 - 4) && (_DWORD)v2 != 1 && v3 == *(_DWORD *)(a1 + 4 * v2 - 8) )
{
break;
}
if ( a2 == ++v2 )
return 1LL;
}
return 0LL;
}
|
func0.part.0:
CMP ESI,0x1
JLE 0x00101568
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101549
LAB_00101540:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101568
LAB_00101549:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x4]
JL 0x0010155f
JNZ 0x00101540
CMP EAX,0x1
JZ 0x00101540
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x8]
JNZ 0x00101540
LAB_0010155f:
XOR EAX,EAX
RET
LAB_00101568:
MOV EAX,0x1
RET
|
int8 func0_part_0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (1 < (int)param_2) {
uVar3 = 1;
do {
iVar2 = *(int *)(param_1 + uVar3 * 4);
iVar1 = *(int *)(param_1 + -4 + uVar3 * 4);
if ((iVar2 < iVar1) ||
(((iVar2 == iVar1 && ((int)uVar3 != 1)) && (iVar2 == *(int *)(param_1 + -8 + uVar3 * 4)))))
{
return 0;
}
uVar3 = uVar3 + 1;
} while (param_2 != uVar3);
}
return 1;
}
|
1,163 |
func0
|
#include <stdio.h>
#include <stdbool.h>
|
bool func0(const int *lst, int lst_size) {
if (lst_size == 0) return true;
for (int i = 1; i < lst_size; i++) {
if (lst[i] < lst[i - 1]) return false;
if (i >= 2 && lst[i] == lst[i - 1] && lst[i] == lst[i - 2]) return false;
}
return true;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
int main() {
int list1[] = {5};
assert(func0(list1, 1) == true);
int list2[] = {1, 2, 3, 4, 5};
assert(func0(list2, 5) == true);
int list3[] = {1, 3, 2, 4, 5};
assert(func0(list3, 5) == false);
int list4[] = {1, 2, 3, 4, 5, 6};
assert(func0(list4, 6) == true);
int list5[] = {1, 2, 3, 4, 5, 6, 7};
assert(func0(list5, 7) == true);
int list6[] = {1, 3, 2, 4, 5, 6, 7};
assert(func0(list6, 7) == false);
assert(func0(NULL, 0) == true);
int list7[] = {1};
assert(func0(list7, 1) == true);
int list8[] = {3, 2, 1};
assert(func0(list8, 3) == false);
int list9[] = {1, 2, 2, 2, 3, 4};
assert(func0(list9, 6) == false);
int list10[] = {1, 2, 3, 3, 3, 4};
assert(func0(list10, 6) == false);
int list11[] = {1, 2, 2, 3, 3, 4};
assert(func0(list11, 6) == true);
int list12[] = {1, 2, 3, 4};
assert(func0(list12, 4) == true);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp $0x1,%esi
jle 15e0 <func0+0x50>
sub $0x2,%esi
mov $0x1,%eax
add $0x2,%rsi
jmp 15b9 <func0+0x29>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rax,%rsi
je 15e0 <func0+0x50>
mov (%rdi,%rax,4),%edx
mov -0x4(%rdi,%rax,4),%ecx
cmp %ecx,%edx
jl 15d3 <func0+0x43>
cmp $0x1,%eax
je 15b0 <func0+0x20>
cmp %ecx,%edx
jne 15b0 <func0+0x20>
cmp -0x8(%rdi,%rax,4),%edx
jne 15b0 <func0+0x20>
xor %eax,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
mov $0x1,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0_part_0:
cmp esi, 1
jle short loc_1568
mov esi, esi
mov eax, 1
jmp short loc_1549
loc_1540:
add rax, 1
cmp rsi, rax
jz short loc_1568
loc_1549:
mov edx, [rdi+rax*4]
cmp edx, [rdi+rax*4-4]
jl short loc_155F
jnz short loc_1540
cmp eax, 1
jz short loc_1540
cmp edx, [rdi+rax*4-8]
jnz short loc_1540
loc_155F:
xor eax, eax
retn
loc_1568:
mov eax, 1
retn
|
long long func0_part_0(long long a1, int a2)
{
long long v2; // rax
int v3; // edx
if ( a2 <= 1 )
return 1LL;
v2 = 1LL;
while ( 1 )
{
v3 = *(_DWORD *)(a1 + 4 * v2);
if ( v3 < *(_DWORD *)(a1 + 4 * v2 - 4)
|| v3 == *(_DWORD *)(a1 + 4 * v2 - 4) && (_DWORD)v2 != 1 && v3 == *(_DWORD *)(a1 + 4 * v2 - 8) )
{
break;
}
if ( a2 == ++v2 )
return 1LL;
}
return 0LL;
}
|
func0.part.0:
CMP ESI,0x1
JLE 0x00101568
MOV ESI,ESI
MOV EAX,0x1
JMP 0x00101549
LAB_00101540:
ADD RAX,0x1
CMP RSI,RAX
JZ 0x00101568
LAB_00101549:
MOV EDX,dword ptr [RDI + RAX*0x4]
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x4]
JL 0x0010155f
JNZ 0x00101540
CMP EAX,0x1
JZ 0x00101540
CMP EDX,dword ptr [RDI + RAX*0x4 + -0x8]
JNZ 0x00101540
LAB_0010155f:
XOR EAX,EAX
RET
LAB_00101568:
MOV EAX,0x1
RET
|
int8 func0_part_0(long param_1,uint param_2)
{
int iVar1;
int iVar2;
ulong uVar3;
if (1 < (int)param_2) {
uVar3 = 1;
do {
iVar2 = *(int *)(param_1 + uVar3 * 4);
iVar1 = *(int *)(param_1 + -4 + uVar3 * 4);
if ((iVar2 < iVar1) ||
(((iVar2 == iVar1 && ((int)uVar3 != 1)) && (iVar2 == *(int *)(param_1 + -8 + uVar3 * 4)))))
{
return 0;
}
uVar3 = uVar3 + 1;
} while (param_2 != uVar3);
}
return 1;
}
|
1,164 |
func0
|
#include <stdio.h>
|
const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
if (l < 2) return "NO";
for (i = 2; i * i <= l; i++)
if (l % i == 0) return "NO";
return "YES";
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1), "NO") == 0);
assert(strcmp(func0(1, 2, 3, 5), "NO") == 0);
assert(strcmp(func0(1, 2, 1, 2), "NO") == 0);
assert(strcmp(func0(-2, -2, -3, -2), "NO") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %ecx,-0x20(%rbp)
mov -0x14(%rbp),%eax
cmp %eax,-0x1c(%rbp)
cmovge -0x1c(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x18(%rbp),%eax
cmp %eax,-0x20(%rbp)
cmovle -0x20(%rbp),%eax
mov %eax,-0x8(%rbp)
mov -0x8(%rbp),%eax
sub -0xc(%rbp),%eax
mov %eax,-0x4(%rbp)
cmpl $0x1,-0x4(%rbp)
jg 11af <func0+0x46>
lea 0xe5b(%rip),%rax
jmp 11e4 <func0+0x7b>
movl $0x2,-0x10(%rbp)
jmp 11d2 <func0+0x69>
mov -0x4(%rbp),%eax
cltd
idivl -0x10(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11ce <func0+0x65>
lea 0xe3c(%rip),%rax
jmp 11e4 <func0+0x7b>
addl $0x1,-0x10(%rbp)
mov -0x10(%rbp),%eax
imul %eax,%eax
cmp %eax,-0x4(%rbp)
jge 11b8 <func0+0x4f>
lea 0xe27(%rip),%rax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov edx, [rbp+var_1C]
mov eax, [rbp+var_14]
cmp edx, eax
cmovge eax, edx
mov [rbp+var_C], eax
mov edx, [rbp+var_20]
mov eax, [rbp+var_18]
cmp edx, eax
cmovle eax, edx
mov [rbp+var_8], eax
mov eax, [rbp+var_8]
sub eax, [rbp+var_C]
mov [rbp+var_4], eax
cmp [rbp+var_4], 1
jg short loc_11B1
lea rax, s2; "NO"
jmp short loc_11E6
loc_11B1:
mov [rbp+var_10], 2
jmp short loc_11D4
loc_11BA:
mov eax, [rbp+var_4]
cdq
idiv [rbp+var_10]
mov eax, edx
test eax, eax
jnz short loc_11D0
lea rax, s2; "NO"
jmp short loc_11E6
loc_11D0:
add [rbp+var_10], 1
loc_11D4:
mov eax, [rbp+var_10]
imul eax, eax
cmp [rbp+var_4], eax
jge short loc_11BA
lea rax, aYes; "YES"
loc_11E6:
pop rbp
retn
|
const char * func0(int a1, int a2, int a3, int a4)
{
int v4; // eax
int v5; // eax
int i; // [rsp+10h] [rbp-10h]
int v8; // [rsp+14h] [rbp-Ch]
int v9; // [rsp+1Ch] [rbp-4h]
v4 = a1;
if ( a3 >= a1 )
v4 = a3;
v8 = v4;
v5 = a2;
if ( a4 <= a2 )
v5 = a4;
v9 = v5 - v8;
if ( v5 - v8 <= 1 )
return "NO";
for ( i = 2; v9 >= i * i; ++i )
{
if ( !(v9 % i) )
return "NO";
}
return "YES";
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV EDX,dword ptr [RBP + -0x1c]
MOV EAX,dword ptr [RBP + -0x14]
CMP EDX,EAX
CMOVGE EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
MOV EDX,dword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x18]
CMP EDX,EAX
CMOVLE EAX,EDX
MOV dword ptr [RBP + -0x8],EAX
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x1
JG 0x001011b1
LEA RAX,[0x102008]
JMP 0x001011e6
LAB_001011b1:
MOV dword ptr [RBP + -0x10],0x2
JMP 0x001011d4
LAB_001011ba:
MOV EAX,dword ptr [RBP + -0x4]
CDQ
IDIV dword ptr [RBP + -0x10]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x001011d0
LEA RAX,[0x102008]
JMP 0x001011e6
LAB_001011d0:
ADD dword ptr [RBP + -0x10],0x1
LAB_001011d4:
MOV EAX,dword ptr [RBP + -0x10]
IMUL EAX,EAX
CMP dword ptr [RBP + -0x4],EAX
JGE 0x001011ba
LEA RAX,[0x10200b]
LAB_001011e6:
POP RBP
RET
|
int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
int local_18;
if (param_1 <= param_3) {
param_1 = param_3;
}
if (param_4 <= param_2) {
param_2 = param_4;
}
param_2 = param_2 - param_1;
if (param_2 < 2) {
puVar1 = &DAT_00102008;
}
else {
for (local_18 = 2; local_18 * local_18 <= param_2; local_18 = local_18 + 1) {
if (param_2 % local_18 == 0) {
return &DAT_00102008;
}
}
puVar1 = &DAT_0010200b;
}
return puVar1;
}
|
1,165 |
func0
|
#include <stdio.h>
|
const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
if (l < 2) return "NO";
for (i = 2; i * i <= l; i++)
if (l % i == 0) return "NO";
return "YES";
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1), "NO") == 0);
assert(strcmp(func0(1, 2, 3, 5), "NO") == 0);
assert(strcmp(func0(1, 2, 1, 2), "NO") == 0);
assert(strcmp(func0(-2, -2, -3, -2), "NO") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
cmp %esi,%ecx
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
lea 0xea4(%rip),%rax
cmp $0x1,%ecx
jle 119e <func0+0x55>
lea 0xe9b(%rip),%rax
cmp $0x3,%ecx
jle 119e <func0+0x55>
lea 0xe8c(%rip),%rax
test $0x1,%cl
je 119e <func0+0x55>
mov $0x2,%edi
add $0x1,%edi
mov %edi,%eax
imul %edi,%eax
cmp %ecx,%eax
jg 119f <func0+0x56>
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
jne 1182 <func0+0x39>
lea 0xe66(%rip),%rax
retq
lea 0xe61(%rip),%rax
retq
|
func0:
endbr64
cmp ecx, esi
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
lea rax, s2; "NO"
cmp ecx, 1
jle short locret_11BE
lea rax, aYes; "YES"
cmp ecx, 3
jle short locret_11BE
lea rax, s2; "NO"
test cl, 1
jz short locret_11BE
mov esi, 2
loc_11A2:
add esi, 1
mov eax, esi
imul eax, esi
cmp eax, ecx
jg short loc_11BF
mov eax, ecx
cdq
idiv esi
test edx, edx
jnz short loc_11A2
lea rax, s2; "NO"
locret_11BE:
retn
loc_11BF:
lea rax, aYes; "YES"
retn
|
const char * func0(int a1, int a2, int a3, int a4)
{
int v4; // ecx
const char *result; // rax
int v6; // esi
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v4 = a4 - a3;
result = "NO";
if ( v4 > 1 )
{
result = "YES";
if ( v4 > 3 )
{
result = "NO";
if ( (v4 & 1) != 0 )
{
v6 = 2;
while ( 1 )
{
++v6;
if ( v6 * v6 > v4 )
break;
if ( !(v4 % v6) )
return "NO";
}
return "YES";
}
}
}
return result;
}
|
func0:
ENDBR64
CMP ECX,ESI
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
LEA RAX,[0x102004]
CMP ECX,0x1
JLE 0x001011be
LEA RAX,[0x102007]
CMP ECX,0x3
JLE 0x001011be
LEA RAX,[0x102004]
TEST CL,0x1
JZ 0x001011be
MOV ESI,0x2
LAB_001011a2:
ADD ESI,0x1
MOV EAX,ESI
IMUL EAX,ESI
CMP EAX,ECX
JG 0x001011bf
MOV EAX,ECX
CDQ
IDIV ESI
TEST EDX,EDX
JNZ 0x001011a2
LEA RAX,[0x102004]
LAB_001011be:
RET
LAB_001011bf:
LEA RAX,[0x102007]
RET
|
int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
puVar1 = &DAT_00102004;
if (((1 < (int)uVar2) && (puVar1 = &DAT_00102007, 3 < (int)uVar2)) &&
(puVar1 = &DAT_00102004, (uVar2 & 1) != 0)) {
iVar3 = 2;
do {
iVar3 = iVar3 + 1;
if ((int)uVar2 < iVar3 * iVar3) {
return &DAT_00102007;
}
} while ((int)uVar2 % iVar3 != 0);
puVar1 = &DAT_00102004;
}
return puVar1;
}
|
1,166 |
func0
|
#include <stdio.h>
|
const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
if (l < 2) return "NO";
for (i = 2; i * i <= l; i++)
if (l % i == 0) return "NO";
return "YES";
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1), "NO") == 0);
assert(strcmp(func0(1, 2, 3, 5), "NO") == 0);
assert(strcmp(func0(1, 2, 1, 2), "NO") == 0);
assert(strcmp(func0(-2, -2, -3, -2), "NO") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
cmp %esi,%ecx
lea 0xeb7(%rip),%rax
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
cmp $0x1,%ecx
jle 11a7 <func0+0x67>
lea 0xea4(%rip),%rax
cmp $0x3,%ecx
jle 11a7 <func0+0x67>
lea 0xe95(%rip),%rax
test $0x1,%cl
je 11a7 <func0+0x67>
mov $0x2,%edi
jmp 1189 <func0+0x49>
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 11a0 <func0+0x60>
add $0x1,%edi
mov %edi,%eax
imul %edi,%eax
cmp %ecx,%eax
jle 1180 <func0+0x40>
lea 0xe6b(%rip),%rax
retq
nopl (%rax)
lea 0xe5d(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
cmp ecx, esi
lea rax, unk_2008
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
cmp ecx, 1
jle short locret_11A7
lea rax, unk_2004
cmp ecx, 3
jle short locret_11A7
lea rax, unk_2008
test cl, 1
jz short locret_11A7
mov esi, 2
jmp short loc_1189
loc_1180:
mov eax, ecx
cdq
idiv esi
test edx, edx
jz short loc_11A0
loc_1189:
add esi, 1
mov eax, esi
imul eax, esi
cmp eax, ecx
jle short loc_1180
lea rax, unk_2004
retn
loc_11A0:
lea rax, unk_2008
locret_11A7:
retn
|
void * func0(int a1, int a2, int a3, int a4)
{
void *result; // rax
int v5; // ecx
int v6; // esi
result = &unk_2008;
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v5 = a4 - a3;
if ( v5 > 1 )
{
result = &unk_2004;
if ( v5 > 3 )
{
result = &unk_2008;
if ( (v5 & 1) != 0 )
{
v6 = 2;
do
{
++v6;
if ( v6 * v6 > v5 )
return &unk_2004;
}
while ( v5 % v6 );
return &unk_2008;
}
}
}
return result;
}
|
func0:
ENDBR64
CMP ECX,ESI
LEA RAX,[0x102008]
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
CMP ECX,0x1
JLE 0x001011a7
LEA RAX,[0x102004]
CMP ECX,0x3
JLE 0x001011a7
LEA RAX,[0x102008]
TEST CL,0x1
JZ 0x001011a7
MOV ESI,0x2
JMP 0x00101189
LAB_00101180:
MOV EAX,ECX
CDQ
IDIV ESI
TEST EDX,EDX
JZ 0x001011a0
LAB_00101189:
ADD ESI,0x1
MOV EAX,ESI
IMUL EAX,ESI
CMP EAX,ECX
JLE 0x00101180
LEA RAX,[0x102004]
RET
LAB_001011a0:
LEA RAX,[0x102008]
LAB_001011a7:
RET
|
int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
puVar1 = &DAT_00102008;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
if (((1 < (int)uVar2) && (puVar1 = &DAT_00102004, 3 < (int)uVar2)) &&
(puVar1 = &DAT_00102008, (uVar2 & 1) != 0)) {
iVar3 = 2;
do {
iVar3 = iVar3 + 1;
if ((int)uVar2 < iVar3 * iVar3) {
return &DAT_00102004;
}
} while ((int)uVar2 % iVar3 != 0);
puVar1 = &DAT_00102008;
}
return puVar1;
}
|
1,167 |
func0
|
#include <stdio.h>
|
const char* func0(int interval1_start, int interval1_end, int interval2_start, int interval2_end) {
int inter1, inter2, l, i;
inter1 = interval1_start > interval2_start ? interval1_start : interval2_start;
inter2 = interval1_end < interval2_end ? interval1_end : interval2_end;
l = inter2 - inter1;
if (l < 2) return "NO";
for (i = 2; i * i <= l; i++)
if (l % i == 0) return "NO";
return "YES";
}
|
#include <stdio.h>
#include <assert.h>
#include <string.h>
int main() {
assert(strcmp(func0(1, 2, 2, 3), "NO") == 0);
assert(strcmp(func0(-1, 1, 0, 4), "NO") == 0);
assert(strcmp(func0(-3, -1, -5, 5), "YES") == 0);
assert(strcmp(func0(-2, 2, -4, 0), "YES") == 0);
assert(strcmp(func0(-11, 2, -1, -1), "NO") == 0);
assert(strcmp(func0(1, 2, 3, 5), "NO") == 0);
assert(strcmp(func0(1, 2, 1, 2), "NO") == 0);
assert(strcmp(func0(-2, -2, -3, -2), "NO") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
cmp %esi,%ecx
lea 0xeb7(%rip),%rax
cmovg %esi,%ecx
cmp %edi,%edx
cmovl %edi,%edx
sub %edx,%ecx
cmp $0x1,%ecx
jle 11a7 <func0+0x67>
lea 0xea4(%rip),%rax
cmp $0x3,%ecx
jle 11a7 <func0+0x67>
lea 0xe95(%rip),%rax
test $0x1,%cl
je 11a7 <func0+0x67>
mov $0x2,%edi
jmp 1189 <func0+0x49>
nopl 0x0(%rax,%rax,1)
mov %ecx,%eax
cltd
idiv %edi
test %edx,%edx
je 11a0 <func0+0x60>
add $0x1,%edi
mov %edi,%eax
imul %edi,%eax
cmp %ecx,%eax
jle 1180 <func0+0x40>
lea 0xe6b(%rip),%rax
retq
nopl (%rax)
lea 0xe5d(%rip),%rax
retq
nopl 0x0(%rax,%rax,1)
|
func0:
endbr64
cmp ecx, esi
lea rax, unk_2008
cmovg ecx, esi
cmp edx, edi
cmovl edx, edi
sub ecx, edx
cmp ecx, 1
jle short locret_11A7
lea rax, unk_2004
cmp ecx, 3
jle short locret_11A7
lea rax, unk_2008
test cl, 1
jz short locret_11A7
mov esi, 2
jmp short loc_1189
loc_1180:
mov eax, ecx
cdq
idiv esi
test edx, edx
jz short loc_11A0
loc_1189:
add esi, 1
mov eax, esi
imul eax, esi
cmp eax, ecx
jle short loc_1180
lea rax, unk_2004
retn
loc_11A0:
lea rax, unk_2008
locret_11A7:
retn
|
void * func0(int a1, int a2, int a3, int a4)
{
void *result; // rax
int v5; // ecx
int v6; // esi
result = &unk_2008;
if ( a4 > a2 )
a4 = a2;
if ( a3 < a1 )
a3 = a1;
v5 = a4 - a3;
if ( v5 > 1 )
{
result = &unk_2004;
if ( v5 > 3 )
{
result = &unk_2008;
if ( (v5 & 1) != 0 )
{
v6 = 2;
do
{
++v6;
if ( v6 * v6 > v5 )
return &unk_2004;
}
while ( v5 % v6 );
return &unk_2008;
}
}
}
return result;
}
|
func0:
ENDBR64
CMP ECX,ESI
LEA RAX,[0x102008]
CMOVG ECX,ESI
CMP EDX,EDI
CMOVL EDX,EDI
SUB ECX,EDX
CMP ECX,0x1
JLE 0x001011a7
LEA RAX,[0x102004]
CMP ECX,0x3
JLE 0x001011a7
LEA RAX,[0x102008]
TEST CL,0x1
JZ 0x001011a7
MOV ESI,0x2
JMP 0x00101189
LAB_00101180:
MOV EAX,ECX
CDQ
IDIV ESI
TEST EDX,EDX
JZ 0x001011a0
LAB_00101189:
ADD ESI,0x1
MOV EAX,ESI
IMUL EAX,ESI
CMP EAX,ECX
JLE 0x00101180
LEA RAX,[0x102004]
RET
LAB_001011a0:
LEA RAX,[0x102008]
LAB_001011a7:
RET
|
int * func0(int param_1,int param_2,int param_3,int param_4)
{
int *puVar1;
uint uVar2;
int iVar3;
puVar1 = &DAT_00102008;
if (param_2 < param_4) {
param_4 = param_2;
}
if (param_3 < param_1) {
param_3 = param_1;
}
uVar2 = param_4 - param_3;
if (((1 < (int)uVar2) && (puVar1 = &DAT_00102004, 3 < (int)uVar2)) &&
(puVar1 = &DAT_00102008, (uVar2 & 1) != 0)) {
iVar3 = 2;
do {
iVar3 = iVar3 + 1;
if ((int)uVar2 < iVar3 * iVar3) {
return &DAT_00102004;
}
} while ((int)uVar2 % iVar3 != 0);
puVar1 = &DAT_00102008;
}
return puVar1;
}
|
1,168 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1, 2, -1, -1, 9};
assert(func0(arr5, 7) == 20);
int arr6[] = {-1, 1, -1, 1};
assert(func0(arr6, 4) == 4);
int arr7[] = {-1, 1, 1, 1};
assert(func0(arr7, 4) == -4);
int arr8[] = {-1, 1, 1, 0};
assert(func0(arr8, 4) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %rdi,-0x18(%rbp)
mov %esi,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jne 1188 <func0+0x1f>
mov $0xffff8000,%eax
jmpq 120e <func0+0xa5>
movl $0x0,-0xc(%rbp)
movl $0x1,-0x8(%rbp)
movl $0x0,-0x4(%rbp)
jmp 11ff <func0+0x96>
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
cltd
xor %edx,%eax
sub %edx,%eax
add %eax,-0xc(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jne 11de <func0+0x75>
movl $0x0,-0x8(%rbp)
mov -0x4(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
mov (%rax),%eax
test %eax,%eax
jns 11fb <func0+0x92>
negl -0x8(%rbp)
addl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x1c(%rbp),%eax
jl 119f <func0+0x36>
mov -0xc(%rbp),%eax
imul -0x8(%rbp),%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
cmp [rbp+var_1C], 0
jnz short loc_1188
mov eax, 0FFFF8000h
jmp loc_1210
loc_1188:
mov [rbp+var_C], 0
mov [rbp+var_8], 1
mov [rbp+var_4], 0
jmp short loc_1201
loc_119F:
mov eax, [rbp+var_4]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_18]
add rax, rdx
mov eax, [rax]
mov edx, eax
neg edx
cmovns eax, edx
add [rbp+var_C], eax
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
jnz short loc_11E0
mov [rbp+var_8], 0
loc_11E0:
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
jns short loc_11FD
neg [rbp+var_8]
loc_11FD:
add [rbp+var_4], 1
loc_1201:
mov eax, [rbp+var_4]
cmp eax, [rbp+var_1C]
jl short loc_119F
mov eax, [rbp+var_C]
imul eax, [rbp+var_8]
loc_1210:
pop rbp
retn
|
long long func0(long long a1, int a2)
{
int v3; // eax
int v4; // [rsp+10h] [rbp-Ch]
int v5; // [rsp+14h] [rbp-8h]
int i; // [rsp+18h] [rbp-4h]
if ( !a2 )
return 4294934528LL;
v4 = 0;
v5 = 1;
for ( i = 0; i < a2; ++i )
{
v3 = *(_DWORD *)(4LL * i + a1);
if ( v3 <= 0 )
v3 = -*(_DWORD *)(4LL * i + a1);
v4 += v3;
if ( !*(_DWORD *)(4LL * i + a1) )
v5 = 0;
if ( *(int *)(4LL * i + a1) < 0 )
v5 = -v5;
}
return (unsigned int)(v5 * v4);
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00101188
MOV EAX,0xffff8000
JMP 0x00101210
LAB_00101188:
MOV dword ptr [RBP + -0xc],0x0
MOV dword ptr [RBP + -0x8],0x1
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00101201
LAB_0010119f:
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]
MOV EDX,EAX
NEG EDX
CMOVNS EAX,EDX
ADD dword ptr [RBP + -0xc],EAX
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
JNZ 0x001011e0
MOV dword ptr [RBP + -0x8],0x0
LAB_001011e0:
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
JNS 0x001011fd
NEG dword ptr [RBP + -0x8]
LAB_001011fd:
ADD dword ptr [RBP + -0x4],0x1
LAB_00101201:
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x1c]
JL 0x0010119f
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,dword ptr [RBP + -0x8]
LAB_00101210:
POP RBP
RET
|
int func0(long param_1,int param_2)
{
int iVar1;
int4 local_14;
int4 local_10;
int4 local_c;
if (param_2 == 0) {
local_14 = -0x8000;
}
else {
local_14 = 0;
local_10 = 1;
for (local_c = 0; local_c < param_2; local_c = local_c + 1) {
iVar1 = *(int *)(param_1 + (long)local_c * 4);
if (iVar1 < 1) {
iVar1 = -iVar1;
}
local_14 = local_14 + iVar1;
if (*(int *)(param_1 + (long)local_c * 4) == 0) {
local_10 = 0;
}
if (*(int *)(param_1 + (long)local_c * 4) < 0) {
local_10 = -local_10;
}
}
local_14 = local_14 * local_10;
}
return local_14;
}
|
1,169 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1, 2, -1, -1, 9};
assert(func0(arr5, 7) == 20);
int arr6[] = {-1, 1, -1, 1};
assert(func0(arr6, 4) == 4);
int arr7[] = {-1, 1, 1, 1};
assert(func0(arr7, 4) == -4);
int arr8[] = {-1, 1, 1, 0};
assert(func0(arr8, 4) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
je 11c7 <func0+0x5e>
jle 11b7 <func0+0x4e>
mov %rdi,%rcx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%r9
mov $0x1,%r8d
mov $0x0,%eax
jmp 1197 <func0+0x2e>
mov %edx,%r8d
add $0x4,%rcx
cmp %r9,%rcx
je 11c2 <func0+0x59>
mov (%rcx),%edx
mov %edx,%edi
sar $0x1f,%edi
mov %edi,%esi
xor %edx,%esi
sub %edi,%esi
add %esi,%eax
test %edx,%edx
je 118b <func0+0x22>
mov %r8d,%esi
neg %esi
test %edx,%edx
cmovs %esi,%r8d
jmp 118e <func0+0x25>
mov $0x1,%r8d
mov $0x0,%eax
imul %r8d,%eax
retq
mov $0xffff8000,%eax
retq
|
func0:
endbr64
test esi, esi
jz short loc_11BC
jle short loc_11AE
mov rcx, rdi
movsxd rsi, esi
lea r8, [rdi+rsi*4]
mov edi, 1
mov eax, 0
jmp short loc_1194
loc_1189:
mov edi, edx
loc_118B:
add rcx, 4
cmp rcx, r8
jz short loc_11B8
loc_1194:
mov edx, [rcx]
mov esi, edx
neg esi
cmovs esi, edx
add eax, esi
test edx, edx
jz short loc_1189
mov esi, edi
neg esi
test edx, edx
cmovs edi, esi
jmp short loc_118B
loc_11AE:
mov edi, 1
mov eax, 0
loc_11B8:
imul eax, edi
retn
loc_11BC:
mov eax, 0FFFF8000h
retn
|
long long func0(int *a1, int a2)
{
int *v2; // rcx
int *v3; // r8
int v4; // edi
int v5; // eax
int v6; // edx
int v7; // esi
if ( !a2 )
return 4294934528LL;
if ( a2 <= 0 )
{
v4 = 1;
v5 = 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 1;
v5 = 0;
do
{
v6 = *v2;
v7 = -*v2;
if ( *v2 > 0 )
v7 = *v2;
v5 += v7;
if ( v6 )
{
if ( v6 < 0 )
v4 = -v4;
}
else
{
v4 = 0;
}
++v2;
}
while ( v2 != v3 );
}
return (unsigned int)(v4 * v5);
}
|
func0:
ENDBR64
TEST ESI,ESI
JZ 0x001011bc
JLE 0x001011ae
MOV RCX,RDI
MOVSXD RSI,ESI
LEA R8,[RDI + RSI*0x4]
MOV EDI,0x1
MOV EAX,0x0
JMP 0x00101194
LAB_00101189:
MOV EDI,EDX
LAB_0010118b:
ADD RCX,0x4
CMP RCX,R8
JZ 0x001011b8
LAB_00101194:
MOV EDX,dword ptr [RCX]
MOV ESI,EDX
NEG ESI
CMOVS ESI,EDX
ADD EAX,ESI
TEST EDX,EDX
JZ 0x00101189
MOV ESI,EDI
NEG ESI
TEST EDX,EDX
CMOVS EDI,ESI
JMP 0x0010118b
LAB_001011ae:
MOV EDI,0x1
MOV EAX,0x0
LAB_001011b8:
IMUL EAX,EDI
RET
LAB_001011bc:
MOV EAX,0xffff8000
RET
|
int func0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 == 0) {
return -0x8000;
}
if (param_2 < 1) {
iVar5 = 1;
iVar3 = 0;
}
else {
piVar1 = param_1 + param_2;
iVar5 = 1;
iVar3 = 0;
do {
iVar2 = *param_1;
iVar4 = -iVar2;
if (0 < iVar2) {
iVar4 = iVar2;
}
iVar3 = iVar3 + iVar4;
if (iVar2 == 0) {
iVar5 = 0;
}
else if (iVar2 < 0) {
iVar5 = -iVar5;
}
param_1 = param_1 + 1;
} while (param_1 != piVar1);
}
return iVar3 * iVar5;
}
|
1,170 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1, 2, -1, -1, 9};
assert(func0(arr5, 7) == 20);
int arr6[] = {-1, 1, -1, 1};
assert(func0(arr6, 4) == 4);
int arr7[] = {-1, 1, 1, 1};
assert(func0(arr7, 4) == -4);
int arr8[] = {-1, 1, 1, 0};
assert(func0(arr8, 4) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
je 1460 <func0+0x10>
jmp 13e0 <func0.part.0>
nopw 0x0(%rax,%rax,1)
mov $0xffff8000,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
|
func0_part_0:
test esi, esi
jle short loc_1400
movsxd rsi, esi
xor eax, eax
lea r8, [rdi+rsi*4]
mov esi, 1
jmp short loc_13DA
loc_13C8:
mov ecx, esi
neg ecx
test edx, edx
cmovs esi, ecx
add rdi, 4
cmp r8, rdi
jz short loc_13F4
loc_13DA:
mov edx, [rdi]
mov ecx, edx
neg ecx
cmovs ecx, edx
add eax, ecx
test edx, edx
jnz short loc_13C8
add rdi, 4
xor esi, esi
cmp r8, rdi
jnz short loc_13DA
loc_13F4:
imul eax, esi
retn
loc_1400:
xor eax, eax
retn
|
long long func0_part_0(int *a1, int a2)
{
int v2; // eax
int *v3; // r8
int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
v4 = 1;
do
{
while ( 1 )
{
v5 = *a1;
v6 = -*a1;
if ( *a1 > 0 )
v6 = *a1;
v2 += v6;
if ( v5 )
break;
++a1;
v4 = 0;
if ( v3 == a1 )
return (unsigned int)(v4 * v2);
}
if ( v5 < 0 )
v4 = -v4;
++a1;
}
while ( v3 != a1 );
return (unsigned int)(v4 * v2);
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x00101400
MOVSXD RSI,ESI
XOR EAX,EAX
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
JMP 0x001013da
LAB_001013c8:
MOV ECX,ESI
NEG ECX
TEST EDX,EDX
CMOVS ESI,ECX
ADD RDI,0x4
CMP R8,RDI
JZ 0x001013f4
LAB_001013da:
MOV EDX,dword ptr [RDI]
MOV ECX,EDX
NEG ECX
CMOVS ECX,EDX
ADD EAX,ECX
TEST EDX,EDX
JNZ 0x001013c8
ADD RDI,0x4
XOR ESI,ESI
CMP R8,RDI
JNZ 0x001013da
LAB_001013f4:
IMUL EAX,ESI
RET
LAB_00101400:
XOR EAX,EAX
RET
|
int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
while( true ) {
iVar5 = *param_1;
iVar3 = -iVar5;
if (0 < iVar5) {
iVar3 = iVar5;
}
iVar2 = iVar2 + iVar3;
if (iVar5 != 0) break;
param_1 = param_1 + 1;
iVar4 = 0;
iVar5 = 0;
if (piVar1 == param_1) goto LAB_001013f4;
}
if (iVar5 < 0) {
iVar4 = -iVar4;
}
param_1 = param_1 + 1;
iVar5 = iVar4;
} while (piVar1 != param_1);
LAB_001013f4:
return iVar2 * iVar5;
}
|
1,171 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int func0(int *arr, int arr_size) {
if (arr_size == 0) return -32768;
int sum = 0, prods = 1, i;
for (i = 0; i < arr_size; i++) {
sum += abs(arr[i]);
if (arr[i] == 0) prods = 0;
if (arr[i] < 0) prods = -prods;
}
return sum * prods;
}
|
#include <stdio.h>
#include <assert.h>
int main() {
int arr1[] = {1, 2, 2, -4};
assert(func0(arr1, 4) == -9);
int arr2[] = {0, 1};
assert(func0(arr2, 2) == 0);
int arr3[] = {1, 1, 1, 2, 3, -1, 1};
assert(func0(arr3, 7) == -10);
assert(func0(NULL, 0) == -32768);
int arr5[] = {2, 4, 1, 2, -1, -1, 9};
assert(func0(arr5, 7) == 20);
int arr6[] = {-1, 1, -1, 1};
assert(func0(arr6, 4) == 4);
int arr7[] = {-1, 1, 1, 1};
assert(func0(arr7, 4) == -4);
int arr8[] = {-1, 1, 1, 0};
assert(func0(arr8, 4) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
je 1493 <func0+0x63>
jle 1490 <func0+0x60>
lea -0x1(%rsi),%eax
xor %r8d,%r8d
lea 0x4(%rdi,%rax,4),%r9
mov $0x1,%eax
jmp 1462 <func0+0x32>
nopl 0x0(%rax)
mov %eax,%ecx
neg %ecx
test %edx,%edx
cmovs %ecx,%eax
add $0x4,%rdi
cmp %r9,%rdi
je 1481 <func0+0x51>
mov (%rdi),%edx
mov %edx,%esi
sar $0x1f,%esi
mov %esi,%ecx
xor %edx,%ecx
sub %esi,%ecx
add %ecx,%r8d
test %edx,%edx
jne 1450 <func0+0x20>
add $0x4,%rdi
xor %eax,%eax
cmp %r9,%rdi
jne 1462 <func0+0x32>
imul %r8d,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
xor %eax,%eax
retq
mov $0xffff8000,%eax
retq
nopl 0x0(%rax)
|
func0_part_0:
test esi, esi
jle short loc_1400
movsxd rsi, esi
xor eax, eax
lea r8, [rdi+rsi*4]
mov esi, 1
jmp short loc_13DA
loc_13C8:
mov ecx, esi
neg ecx
test edx, edx
cmovs esi, ecx
add rdi, 4
cmp r8, rdi
jz short loc_13F4
loc_13DA:
mov edx, [rdi]
mov ecx, edx
neg ecx
cmovs ecx, edx
add eax, ecx
test edx, edx
jnz short loc_13C8
add rdi, 4
xor esi, esi
cmp r8, rdi
jnz short loc_13DA
loc_13F4:
imul eax, esi
retn
loc_1400:
xor eax, eax
retn
|
long long func0_part_0(int *a1, int a2)
{
int v2; // eax
int *v3; // r8
int v4; // esi
int v5; // edx
int v6; // ecx
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
v4 = 1;
do
{
while ( 1 )
{
v5 = *a1;
v6 = -*a1;
if ( *a1 > 0 )
v6 = *a1;
v2 += v6;
if ( v5 )
break;
++a1;
v4 = 0;
if ( v3 == a1 )
return (unsigned int)(v4 * v2);
}
if ( v5 < 0 )
v4 = -v4;
++a1;
}
while ( v3 != a1 );
return (unsigned int)(v4 * v2);
}
|
func0.part.0:
TEST ESI,ESI
JLE 0x00101400
MOVSXD RSI,ESI
XOR EAX,EAX
LEA R8,[RDI + RSI*0x4]
MOV ESI,0x1
JMP 0x001013da
LAB_001013c8:
MOV ECX,ESI
NEG ECX
TEST EDX,EDX
CMOVS ESI,ECX
ADD RDI,0x4
CMP R8,RDI
JZ 0x001013f4
LAB_001013da:
MOV EDX,dword ptr [RDI]
MOV ECX,EDX
NEG ECX
CMOVS ECX,EDX
ADD EAX,ECX
TEST EDX,EDX
JNZ 0x001013c8
ADD RDI,0x4
XOR ESI,ESI
CMP R8,RDI
JNZ 0x001013da
LAB_001013f4:
IMUL EAX,ESI
RET
LAB_00101400:
XOR EAX,EAX
RET
|
int func0_part_0(int *param_1,int param_2)
{
int *piVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
if (param_2 < 1) {
return 0;
}
iVar2 = 0;
piVar1 = param_1 + param_2;
iVar4 = 1;
do {
while( true ) {
iVar5 = *param_1;
iVar3 = -iVar5;
if (0 < iVar5) {
iVar3 = iVar5;
}
iVar2 = iVar2 + iVar3;
if (iVar5 != 0) break;
param_1 = param_1 + 1;
iVar4 = 0;
iVar5 = 0;
if (piVar1 == param_1) goto LAB_001013f4;
}
if (iVar5 < 0) {
iVar4 = -iVar4;
}
param_1 = param_1 + 1;
iVar5 = iVar4;
} while (piVar1 != param_1);
LAB_001013f4:
return iVar2 * iVar5;
}
|
1,172 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if (x < N - 1 && grid[x + 1][y] < min) min = grid[x + 1][y];
if (y > 0 && grid[x][y - 1] < min) min = grid[x][y - 1];
if (y < N - 1 && grid[x][y + 1] < min) min = grid[x][y + 1];
*returnSize = k;
int *out = (int *)malloc(k * sizeof(int));
for (i = 0; i < k; i++)
if (i % 2 == 0) out[i] = 1;
else out[i] = min;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[1], grid1[2]};
int result1[] = {1, 2, 1};
int *out1 = func0(grid1_ptrs, 3, 3, &size);
assert(issame(out1, result1, size));
free(out1);
// Test case 2
int grid2[3][3] = {{5, 9, 3}, {4, 1, 6}, {7, 8, 2}};
int *grid2_ptrs[] = {grid2[0], grid2[1], grid2[2]};
int result2[] = {1};
int *out2 = func0(grid2_ptrs, 3, 1, &size);
assert(issame(out2, result2, size));
free(out2);
// Test case 3
int grid3[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int *grid3_ptrs[] = {grid3[0], grid3[1], grid3[2], grid3[3]};
int result3[] = {1, 2, 1, 2};
int *out3 = func0(grid3_ptrs, 4, 4, &size);
assert(issame(out3, result3, size));
free(out3);
// Test case 4
int grid4[4][4] = {{6, 4, 13, 10}, {5, 7, 12, 1}, {3, 16, 11, 15}, {8, 14, 9, 2}};
int *grid4_ptrs[] = {grid4[0], grid4[1], grid4[2], grid4[3]};
int result4[] = {1, 10, 1, 10, 1, 10, 1};
int *out4 = func0(grid4_ptrs, 4, 7, &size);
assert(issame(out4, result4, size));
free(out4);
// Test case 5
int grid5[4][4] = {{8, 14, 9, 2}, {6, 4, 13, 15}, {5, 7, 1, 12}, {3, 10, 11, 16}};
int *grid5_ptrs[] = {grid5[0], grid5[1], grid5[2], grid5[3]};
int result5[] = {1, 7, 1, 7, 1};
int *out5 = func0(grid5_ptrs, 4, 5, &size);
assert(issame(out5, result5, size));
free(out5);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %rcx,-0x38(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 121c <func0+0x73>
movl $0x0,-0x18(%rbp)
jmp 1210 <func0+0x67>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x18(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp $0x1,%eax
jne 120c <func0+0x63>
mov -0x1c(%rbp),%eax
mov %eax,-0x14(%rbp)
mov -0x18(%rbp),%eax
mov %eax,-0x10(%rbp)
addl $0x1,-0x18(%rbp)
mov -0x18(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11d5 <func0+0x2c>
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11cc <func0+0x23>
mov -0x2c(%rbp),%eax
imul %eax,%eax
mov %eax,-0xc(%rbp)
cmpl $0x0,-0x14(%rbp)
jle 1287 <func0+0xde>
mov -0x14(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 1287 <func0+0xde>
mov -0x14(%rbp),%eax
cltq
shl $0x3,%rax
lea -0x8(%rax),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x14(%rbp)
jge 12ee <func0+0x145>
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 12ee <func0+0x145>
mov -0x14(%rbp),%eax
cltq
add $0x1,%rax
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
cmpl $0x0,-0x10(%rbp)
jle 1350 <func0+0x1a7>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
sub $0x4,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 1350 <func0+0x1a7>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
shl $0x2,%rdx
sub $0x4,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x2c(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x10(%rbp)
jge 13b7 <func0+0x20e>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
cmp %eax,-0xc(%rbp)
jle 13b7 <func0+0x20e>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,8),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
mov (%rax),%rax
mov -0x10(%rbp),%edx
movslq %edx,%rdx
add $0x1,%rdx
shl $0x2,%rdx
add %rdx,%rax
mov (%rax),%eax
mov %eax,-0xc(%rbp)
mov -0x38(%rbp),%rax
mov -0x30(%rbp),%edx
mov %edx,(%rax)
mov -0x30(%rbp),%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
movl $0x0,-0x1c(%rbp)
jmp 1421 <func0+0x278>
mov -0x1c(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1404 <func0+0x25b>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
movl $0x1,(%rax)
jmp 141d <func0+0x274>
mov -0x1c(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rax,%rdx
mov -0xc(%rbp),%eax
mov %eax,(%rdx)
addl $0x1,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x30(%rbp),%eax
jl 13de <func0+0x235>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov [rbp+var_38], rcx
mov [rbp+var_1C], 0
jmp short loc_121C
loc_11CC:
mov [rbp+var_18], 0
jmp short loc_1210
loc_11D5:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_18]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp eax, 1
jnz short loc_120C
mov eax, [rbp+var_1C]
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
mov [rbp+var_10], eax
loc_120C:
add [rbp+var_18], 1
loc_1210:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_2C]
jl short loc_11D5
add [rbp+var_1C], 1
loc_121C:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_2C]
jl short loc_11CC
mov eax, [rbp+var_2C]
imul eax, eax
mov [rbp+var_C], eax
cmp [rbp+var_14], 0
jle short loc_1287
mov eax, [rbp+var_14]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jle short loc_1287
mov eax, [rbp+var_14]
cdqe
shl rax, 3
lea rdx, [rax-8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_1287:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_14], eax
jge short loc_12EE
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jle short loc_12EE
mov eax, [rbp+var_14]
cdqe
add rax, 1
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_12EE:
cmp [rbp+var_10], 0
jle short loc_1350
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
sub rdx, 4
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jle short loc_1350
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
shl rdx, 2
sub rdx, 4
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_1350:
mov eax, [rbp+var_2C]
sub eax, 1
cmp [rbp+var_10], eax
jge short loc_13B7
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
add rdx, 1
shl rdx, 2
add rax, rdx
mov eax, [rax]
cmp [rbp+var_C], eax
jle short loc_13B7
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*8]
mov rax, [rbp+var_28]
add rax, rdx
mov rax, [rax]
mov edx, [rbp+var_10]
movsxd rdx, edx
add rdx, 1
shl rdx, 2
add rax, rdx
mov eax, [rax]
mov [rbp+var_C], eax
loc_13B7:
mov rax, [rbp+var_38]
mov edx, [rbp+var_30]
mov [rax], edx
mov eax, [rbp+var_30]
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov [rbp+var_1C], 0
jmp short loc_1421
loc_13DE:
mov eax, [rbp+var_1C]
and eax, 1
test eax, eax
jnz short loc_1404
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
mov dword ptr [rax], 1
jmp short loc_141D
loc_1404:
mov eax, [rbp+var_1C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rdx, rax
mov eax, [rbp+var_C]
mov [rdx], eax
loc_141D:
add [rbp+var_1C], 1
loc_1421:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_30]
jl short loc_13DE
mov rax, [rbp+var_8]
leave
retn
|
_DWORD * func0(long long a1, int a2, int a3, _DWORD *a4)
{
int i; // [rsp+24h] [rbp-1Ch]
int k; // [rsp+24h] [rbp-1Ch]
int j; // [rsp+28h] [rbp-18h]
int v9; // [rsp+2Ch] [rbp-14h]
int v10; // [rsp+30h] [rbp-10h]
int v11; // [rsp+34h] [rbp-Ch]
_DWORD *v12; // [rsp+38h] [rbp-8h]
for ( i = 0; i < a2; ++i )
{
for ( j = 0; j < a2; ++j )
{
if ( *(_DWORD *)(4LL * j + *(_QWORD *)(8LL * i + a1)) == 1 )
{
v9 = i;
v10 = j;
}
}
}
v11 = a2 * a2;
if ( v9 > 0 && v11 > *(_DWORD *)(4LL * v10 + *(_QWORD *)(8LL * v9 - 8 + a1)) )
v11 = *(_DWORD *)(4LL * v10 + *(_QWORD *)(8LL * v9 - 8 + a1));
if ( v9 < a2 - 1 && v11 > *(_DWORD *)(4LL * v10 + *(_QWORD *)(8 * (v9 + 1LL) + a1)) )
v11 = *(_DWORD *)(4LL * v10 + *(_QWORD *)(8 * (v9 + 1LL) + a1));
if ( v10 > 0 && v11 > *(_DWORD *)(4LL * v10 - 4 + *(_QWORD *)(8LL * v9 + a1)) )
v11 = *(_DWORD *)(4LL * v10 - 4 + *(_QWORD *)(8LL * v9 + a1));
if ( v10 < a2 - 1 && v11 > *(_DWORD *)(4 * (v10 + 1LL) + *(_QWORD *)(8LL * v9 + a1)) )
v11 = *(_DWORD *)(4 * (v10 + 1LL) + *(_QWORD *)(8LL * v9 + a1));
*a4 = a3;
v12 = malloc(4LL * a3);
for ( k = 0; k < a3; ++k )
{
if ( (k & 1) != 0 )
v12[k] = v11;
else
v12[k] = 1;
}
return v12;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x30],EDX
MOV qword ptr [RBP + -0x38],RCX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x0010121c
LAB_001011cc:
MOV dword ptr [RBP + -0x18],0x0
JMP 0x00101210
LAB_001011d5:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x18]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP EAX,0x1
JNZ 0x0010120c
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x10],EAX
LAB_0010120c:
ADD dword ptr [RBP + -0x18],0x1
LAB_00101210:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011d5
ADD dword ptr [RBP + -0x1c],0x1
LAB_0010121c:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011cc
MOV EAX,dword ptr [RBP + -0x2c]
IMUL EAX,EAX
MOV dword ptr [RBP + -0xc],EAX
CMP dword ptr [RBP + -0x14],0x0
JLE 0x00101287
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x00101287
MOV EAX,dword ptr [RBP + -0x14]
CDQE
SHL RAX,0x3
LEA RDX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_00101287:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x14],EAX
JGE 0x001012ee
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x001012ee
MOV EAX,dword ptr [RBP + -0x14]
CDQE
ADD RAX,0x1
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_001012ee:
CMP dword ptr [RBP + -0x10],0x0
JLE 0x00101350
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
SUB RDX,0x4
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x00101350
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
SHL RDX,0x2
SUB RDX,0x4
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_00101350:
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,0x1
CMP dword ptr [RBP + -0x10],EAX
JGE 0x001013b7
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
ADD RDX,0x1
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
CMP dword ptr [RBP + -0xc],EAX
JLE 0x001013b7
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x8]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOV RAX,qword ptr [RAX]
MOV EDX,dword ptr [RBP + -0x10]
MOVSXD RDX,EDX
ADD RDX,0x1
SHL RDX,0x2
ADD RAX,RDX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
LAB_001013b7:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x30]
MOV dword ptr [RAX],EDX
MOV EAX,dword ptr [RBP + -0x30]
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x1c],0x0
JMP 0x00101421
LAB_001013de:
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101404
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV dword ptr [RAX],0x1
JMP 0x0010141d
LAB_00101404:
MOV EAX,dword ptr [RBP + -0x1c]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RDX,RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RDX],EAX
LAB_0010141d:
ADD dword ptr [RBP + -0x1c],0x1
LAB_00101421:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x30]
JL 0x001013de
MOV RAX,qword ptr [RBP + -0x8]
LEAVE
RET
|
void * func0(long param_1,int param_2,int param_3,int *param_4)
{
void *pvVar1;
int4 local_24;
int4 local_20;
int4 local_1c;
int4 local_18;
int4 local_14;
for (local_24 = 0; (int)local_24 < param_2; local_24 = local_24 + 1) {
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
if (*(int *)(*(long *)(param_1 + (long)(int)local_24 * 8) + (long)local_20 * 4) == 1) {
local_1c = local_24;
local_18 = local_20;
}
}
}
local_14 = param_2 * param_2;
if ((0 < local_1c) &&
(*(int *)(*(long *)(param_1 + (long)local_1c * 8 + -8) + (long)local_18 * 4) < local_14)) {
local_14 = *(int *)(*(long *)(param_1 + (long)local_1c * 8 + -8) + (long)local_18 * 4);
}
if ((local_1c < param_2 + -1) &&
(*(int *)(*(long *)(param_1 + ((long)local_1c + 1) * 8) + (long)local_18 * 4) < local_14)) {
local_14 = *(int *)(*(long *)(param_1 + ((long)local_1c + 1) * 8) + (long)local_18 * 4);
}
if ((0 < local_18) &&
(*(int *)(*(long *)(param_1 + (long)local_1c * 8) + (long)local_18 * 4 + -4) < local_14)) {
local_14 = *(int *)(*(long *)(param_1 + (long)local_1c * 8) + (long)local_18 * 4 + -4);
}
if ((local_18 < param_2 + -1) &&
(*(int *)(*(long *)(param_1 + (long)local_1c * 8) + ((long)local_18 + 1) * 4) < local_14)) {
local_14 = *(int *)(*(long *)(param_1 + (long)local_1c * 8) + ((long)local_18 + 1) * 4);
}
*param_4 = param_3;
pvVar1 = malloc((long)param_3 << 2);
for (local_24 = 0; (int)local_24 < param_3; local_24 = local_24 + 1) {
if ((local_24 & 1) == 0) {
*(int4 *)((long)pvVar1 + (long)(int)local_24 * 4) = 1;
}
else {
*(int *)((long)(int)local_24 * 4 + (long)pvVar1) = local_14;
}
}
return pvVar1;
}
|
1,173 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if (x < N - 1 && grid[x + 1][y] < min) min = grid[x + 1][y];
if (y > 0 && grid[x][y - 1] < min) min = grid[x][y - 1];
if (y < N - 1 && grid[x][y + 1] < min) min = grid[x][y + 1];
*returnSize = k;
int *out = (int *)malloc(k * sizeof(int));
for (i = 0; i < k; i++)
if (i % 2 == 0) out[i] = 1;
else out[i] = min;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[1], grid1[2]};
int result1[] = {1, 2, 1};
int *out1 = func0(grid1_ptrs, 3, 3, &size);
assert(issame(out1, result1, size));
free(out1);
// Test case 2
int grid2[3][3] = {{5, 9, 3}, {4, 1, 6}, {7, 8, 2}};
int *grid2_ptrs[] = {grid2[0], grid2[1], grid2[2]};
int result2[] = {1};
int *out2 = func0(grid2_ptrs, 3, 1, &size);
assert(issame(out2, result2, size));
free(out2);
// Test case 3
int grid3[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int *grid3_ptrs[] = {grid3[0], grid3[1], grid3[2], grid3[3]};
int result3[] = {1, 2, 1, 2};
int *out3 = func0(grid3_ptrs, 4, 4, &size);
assert(issame(out3, result3, size));
free(out3);
// Test case 4
int grid4[4][4] = {{6, 4, 13, 10}, {5, 7, 12, 1}, {3, 16, 11, 15}, {8, 14, 9, 2}};
int *grid4_ptrs[] = {grid4[0], grid4[1], grid4[2], grid4[3]};
int result4[] = {1, 10, 1, 10, 1, 10, 1};
int *out4 = func0(grid4_ptrs, 4, 7, &size);
assert(issame(out4, result4, size));
free(out4);
// Test case 5
int grid5[4][4] = {{8, 14, 9, 2}, {6, 4, 13, 15}, {5, 7, 1, 12}, {3, 10, 11, 16}};
int *grid5_ptrs[] = {grid5[0], grid5[1], grid5[2], grid5[3]};
int result5[] = {1, 7, 1, 7, 1};
int *out5 = func0(grid5_ptrs, 4, 5, &size);
assert(issame(out5, result5, size));
free(out5);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
mov %rcx,%r12
test %esi,%esi
jle 1200 <func0+0x57>
lea -0x1(%rsi),%r11d
mov $0x0,%ebp
mov $0x0,%r13d
jmp 11f5 <func0+0x4c>
mov %r10,%rax
cmpl $0x1,(%rdx,%rax,4)
cmove %eax,%r8d
cmove %ecx,%r9d
lea 0x1(%rax),%r10
cmp %r11,%rax
jne 11d1 <func0+0x28>
lea 0x1(%rbp),%rax
cmp %r11,%rbp
je 1200 <func0+0x57>
mov %rax,%rbp
mov %ebp,%ecx
mov (%rdi,%rbp,8),%rdx
mov %r13,%rax
jmp 11d4 <func0+0x2b>
mov %esi,%ebp
imul %esi,%ebp
test %r9d,%r9d
jle 121d <func0+0x74>
movslq %r9d,%rdx
movslq %r8d,%rax
mov -0x8(%rdi,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
sub $0x1,%esi
cmp %r9d,%esi
jle 1238 <func0+0x8f>
movslq %r9d,%rdx
movslq %r8d,%rax
mov 0x8(%rdi,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
test %r8d,%r8d
jle 1250 <func0+0xa7>
movslq %r9d,%rdx
movslq %r8d,%rax
mov (%rdi,%rdx,8),%rdx
mov -0x4(%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
cmp %r8d,%esi
jle 1269 <func0+0xc0>
movslq %r9d,%r9
movslq %r8d,%r8
mov (%rdi,%r9,8),%rax
mov 0x4(%rax,%r8,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
mov %ebx,(%r12)
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %ebx,%ebx
jle 12a3 <func0+0xfa>
lea -0x1(%rbx),%edi
mov $0x0,%edx
mov $0x1,%esi
jmp 128f <func0+0xe6>
mov %rcx,%rdx
test $0x1,%dl
mov %esi,%ecx
cmovne %ebp,%ecx
mov %ecx,(%rax,%rdx,4)
lea 0x1(%rdx),%rcx
cmp %rdx,%rdi
jne 128c <func0+0xe3>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
|
func0:
endbr64
push r12
push rbp
push rbx
mov r10, rdi
mov r11d, esi
mov ebx, edx
mov r12, rcx
test esi, esi
jle short loc_11F1
movsxd rdx, esi
mov edi, 0
loc_11C8:
mov esi, edi
mov rcx, [r10+rdi*8]
mov eax, 0
loc_11D3:
cmp dword ptr [rcx+rax*4], 1
cmovz r8d, eax
cmovz r9d, esi
add rax, 1
cmp rax, rdx
jnz short loc_11D3
add rdi, 1
cmp rdi, rdx
jnz short loc_11C8
loc_11F1:
mov ebp, r11d
imul ebp, r11d
test r9d, r9d
jle short loc_1210
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8-8]
mov eax, [rdx+rax*4]
cmp ebp, eax
cmovg ebp, eax
loc_1210:
sub r11d, 1
cmp r11d, r9d
jle short loc_122C
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8+8]
mov eax, [rdx+rax*4]
cmp ebp, eax
cmovg ebp, eax
loc_122C:
test r8d, r8d
jle short loc_1244
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8]
mov eax, [rdx+rax*4-4]
cmp ebp, eax
cmovg ebp, eax
loc_1244:
cmp r11d, r8d
jle short loc_125D
movsxd r9, r9d
movsxd r8, r8d
mov rax, [r10+r9*8]
mov eax, [rax+r8*4+4]
cmp ebp, eax
cmovg ebp, eax
loc_125D:
mov [r12], ebx
movsxd r12, ebx
lea rdi, ds:0[r12*4]; size
call _malloc
test ebx, ebx
jle short loc_1296
mov edx, 0
jmp short loc_1288
loc_127C:
mov [rax+rdx*4], ebp
loc_127F:
add rdx, 1
cmp r12, rdx
jz short loc_1296
loc_1288:
test dl, 1
jnz short loc_127C
mov dword ptr [rax+rdx*4], 1
jmp short loc_127F
loc_1296:
pop rbx
pop rbp
pop r12
retn
|
_DWORD * func0(long long a1, int a2, int a3, int *a4, int a5, int a6)
{
long long i; // rdi
long long j; // rax
int v10; // ebp
_DWORD *result; // rax
long long v12; // rdx
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
for ( j = 0LL; j != a2; ++j )
{
if ( *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + 4 * j) == 1 )
{
a5 = j;
a6 = i;
}
}
}
}
v10 = a2 * a2;
if ( a6 > 0 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 - 8) + 4LL * a5) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 - 8) + 4LL * a5);
if ( a2 - 1 > a6 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 + 8) + 4LL * a5) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 + 8) + 4LL * a5);
if ( a5 > 0 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 - 4) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 - 4);
if ( a2 - 1 > a5 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 + 4) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 + 4);
*a4 = a3;
result = malloc(4LL * a3);
if ( a3 > 0 )
{
v12 = 0LL;
do
{
if ( (v12 & 1) != 0 )
result[v12] = v10;
else
result[v12] = 1;
++v12;
}
while ( a3 != v12 );
}
return result;
}
|
func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,RDI
MOV R11D,ESI
MOV EBX,EDX
MOV R12,RCX
TEST ESI,ESI
JLE 0x001011f1
MOVSXD RDX,ESI
MOV EDI,0x0
LAB_001011c8:
MOV ESI,EDI
MOV RCX,qword ptr [R10 + RDI*0x8]
MOV EAX,0x0
LAB_001011d3:
CMP dword ptr [RCX + RAX*0x4],0x1
CMOVZ R8D,EAX
CMOVZ R9D,ESI
ADD RAX,0x1
CMP RAX,RDX
JNZ 0x001011d3
ADD RDI,0x1
CMP RDI,RDX
JNZ 0x001011c8
LAB_001011f1:
MOV EBP,R11D
IMUL EBP,R11D
TEST R9D,R9D
JLE 0x00101210
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8 + -0x8]
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_00101210:
SUB R11D,0x1
CMP R11D,R9D
JLE 0x0010122c
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8 + 0x8]
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_0010122c:
TEST R8D,R8D
JLE 0x00101244
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8]
MOV EAX,dword ptr [RDX + RAX*0x4 + -0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_00101244:
CMP R11D,R8D
JLE 0x0010125d
MOVSXD R9,R9D
MOVSXD R8,R8D
MOV RAX,qword ptr [R10 + R9*0x8]
MOV EAX,dword ptr [RAX + R8*0x4 + 0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_0010125d:
MOV dword ptr [R12],EBX
MOVSXD R12,EBX
LEA RDI,[R12*0x4]
CALL 0x001010b0
TEST EBX,EBX
JLE 0x00101296
MOV EDX,0x0
JMP 0x00101288
LAB_0010127c:
MOV dword ptr [RAX + RDX*0x4],EBP
LAB_0010127f:
ADD RDX,0x1
CMP R12,RDX
JZ 0x00101296
LAB_00101288:
TEST DL,0x1
JNZ 0x0010127c
MOV dword ptr [RAX + RDX*0x4],0x1
JMP 0x0010127f
LAB_00101296:
POP RBX
POP RBP
POP R12
RET
|
void func0(long param_1,int param_2,int param_3,int *param_4,int param_5,int param_6)
{
int iVar1;
long lVar2;
void *pvVar3;
ulong uVar4;
int iVar5;
long lVar6;
bool bVar7;
if (0 < param_2) {
lVar6 = 0;
do {
lVar2 = 0;
do {
bVar7 = *(int *)(*(long *)(param_1 + lVar6 * 8) + lVar2 * 4) == 1;
if (bVar7) {
param_5 = (int)lVar2;
}
if (bVar7) {
param_6 = (int)lVar6;
}
lVar2 = lVar2 + 1;
} while (lVar2 != param_2);
lVar6 = lVar6 + 1;
} while (lVar6 != param_2);
}
iVar5 = param_2 * param_2;
if ((0 < param_6) &&
(iVar1 = *(int *)(*(long *)(param_1 + -8 + (long)param_6 * 8) + (long)param_5 * 4),
iVar1 < iVar5)) {
iVar5 = iVar1;
}
if ((param_6 < param_2 + -1) &&
(iVar1 = *(int *)(*(long *)(param_1 + 8 + (long)param_6 * 8) + (long)param_5 * 4),
iVar1 < iVar5)) {
iVar5 = iVar1;
}
if ((0 < param_5) &&
(iVar1 = *(int *)(*(long *)(param_1 + (long)param_6 * 8) + -4 + (long)param_5 * 4),
iVar1 < iVar5)) {
iVar5 = iVar1;
}
if ((param_5 < param_2 + -1) &&
(iVar1 = *(int *)(*(long *)(param_1 + (long)param_6 * 8) + 4 + (long)param_5 * 4),
iVar1 < iVar5)) {
iVar5 = iVar1;
}
*param_4 = param_3;
pvVar3 = malloc((long)param_3 * 4);
if (0 < param_3) {
uVar4 = 0;
do {
if ((uVar4 & 1) == 0) {
*(int4 *)((long)pvVar3 + uVar4 * 4) = 1;
}
else {
*(int *)((long)pvVar3 + uVar4 * 4) = iVar5;
}
uVar4 = uVar4 + 1;
} while ((long)param_3 != uVar4);
}
return;
}
|
1,174 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if (x < N - 1 && grid[x + 1][y] < min) min = grid[x + 1][y];
if (y > 0 && grid[x][y - 1] < min) min = grid[x][y - 1];
if (y < N - 1 && grid[x][y + 1] < min) min = grid[x][y + 1];
*returnSize = k;
int *out = (int *)malloc(k * sizeof(int));
for (i = 0; i < k; i++)
if (i % 2 == 0) out[i] = 1;
else out[i] = min;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[1], grid1[2]};
int result1[] = {1, 2, 1};
int *out1 = func0(grid1_ptrs, 3, 3, &size);
assert(issame(out1, result1, size));
free(out1);
// Test case 2
int grid2[3][3] = {{5, 9, 3}, {4, 1, 6}, {7, 8, 2}};
int *grid2_ptrs[] = {grid2[0], grid2[1], grid2[2]};
int result2[] = {1};
int *out2 = func0(grid2_ptrs, 3, 1, &size);
assert(issame(out2, result2, size));
free(out2);
// Test case 3
int grid3[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int *grid3_ptrs[] = {grid3[0], grid3[1], grid3[2], grid3[3]};
int result3[] = {1, 2, 1, 2};
int *out3 = func0(grid3_ptrs, 4, 4, &size);
assert(issame(out3, result3, size));
free(out3);
// Test case 4
int grid4[4][4] = {{6, 4, 13, 10}, {5, 7, 12, 1}, {3, 16, 11, 15}, {8, 14, 9, 2}};
int *grid4_ptrs[] = {grid4[0], grid4[1], grid4[2], grid4[3]};
int result4[] = {1, 10, 1, 10, 1, 10, 1};
int *out4 = func0(grid4_ptrs, 4, 7, &size);
assert(issame(out4, result4, size));
free(out4);
// Test case 5
int grid5[4][4] = {{8, 14, 9, 2}, {6, 4, 13, 15}, {5, 7, 1, 12}, {3, 10, 11, 16}};
int *grid5_ptrs[] = {grid5[0], grid5[1], grid5[2], grid5[3]};
int result5[] = {1, 7, 1, 7, 1};
int *out5 = func0(grid5_ptrs, 4, 5, &size);
assert(issame(out5, result5, size));
free(out5);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %r13
lea -0x1(%rsi),%r13d
push %r12
mov %rcx,%r12
push %rbp
mov %esi,%ebp
push %rbx
mov %edx,%ebx
sub $0x8,%rsp
test %esi,%esi
jle 1880 <func0+0x60>
lea -0x1(%rsi),%edx
xor %esi,%esi
mov %rdx,%r13
nopl (%rax)
mov (%rdi,%rsi,8),%r8
movslq %esi,%rcx
xor %eax,%eax
jmp 185b <func0+0x3b>
nopl 0x0(%rax,%rax,1)
mov %r11,%rax
cmpl $0x1,(%r8,%rax,4)
lea 0x1(%rax),%r11
cmove %eax,%r9d
cmove %rcx,%r10
cmp %rdx,%rax
jne 1858 <func0+0x38>
lea 0x1(%rsi),%rax
cmp %rsi,%rdx
je 1880 <func0+0x60>
mov %rax,%rsi
jmp 1848 <func0+0x28>
imul %ebp,%ebp
test %r10d,%r10d
je 189b <func0+0x7b>
movslq %r10d,%rdx
movslq %r9d,%rax
mov -0x8(%rdi,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
cmp %r10d,%r13d
jle 18b3 <func0+0x93>
movslq %r10d,%rdx
movslq %r9d,%rax
mov 0x8(%rdi,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
test %r9d,%r9d
je 18cb <func0+0xab>
movslq %r10d,%rdx
movslq %r9d,%rax
mov (%rdi,%rdx,8),%rdx
mov -0x4(%rdx,%rax,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
cmp %r9d,%r13d
jle 18e1 <func0+0xc1>
mov (%rdi,%r10,8),%rax
movslq %r9d,%r9
mov 0x4(%rax,%r9,4),%eax
cmp %eax,%ebp
cmovg %eax,%ebp
mov %ebx,(%r12)
movslq %ebx,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
lea -0x1(%rbx),%edi
xor %ecx,%ecx
mov $0x1,%esi
test %ebx,%ebx
jg 190b <func0+0xeb>
jmp 191f <func0+0xff>
nopl 0x0(%rax)
mov %rdx,%rcx
test $0x1,%cl
mov %esi,%edx
cmovne %ebp,%edx
mov %edx,(%rax,%rcx,4)
lea 0x1(%rcx),%rdx
cmp %rcx,%rdi
jne 1908 <func0+0xe8>
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r12
mov r10, rdi
mov r11d, esi
mov r12, rcx
push rbp
mov ebp, edx
push rbx
test esi, esi
jle short loc_17AE
movsxd rsi, esi
xor edi, edi
nop dword ptr [rax+00h]
loc_1780:
mov rdx, [r10+rdi*8]
mov ecx, edi
xor eax, eax
nop dword ptr [rax+rax+00000000h]
loc_1790:
cmp dword ptr [rdx+rax*4], 1
cmovz r8d, eax
cmovz r9d, ecx
add rax, 1
cmp rax, rsi
jnz short loc_1790
add rdi, 1
cmp rdi, rsi
jnz short loc_1780
loc_17AE:
mov ebx, r11d
imul ebx, r11d
test r9d, r9d
jle short loc_17CD
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8-8]
mov eax, [rdx+rax*4]
cmp ebx, eax
cmovg ebx, eax
loc_17CD:
sub r11d, 1
cmp r11d, r9d
jle short loc_17E9
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8+8]
mov eax, [rdx+rax*4]
cmp ebx, eax
cmovg ebx, eax
loc_17E9:
test r8d, r8d
jle short loc_1801
movsxd rdx, r9d
movsxd rax, r8d
mov rdx, [r10+rdx*8]
mov eax, [rdx+rax*4-4]
cmp ebx, eax
cmovg ebx, eax
loc_1801:
cmp r11d, r8d
jle short loc_181A
movsxd r9, r9d
movsxd r8, r8d
mov rax, [r10+r9*8]
mov eax, [rax+r8*4+4]
cmp ebx, eax
cmovg ebx, eax
loc_181A:
mov [r12], ebp
movsxd r12, ebp
lea rdi, ds:0[r12*4]; size
call _malloc
xor edx, edx
mov esi, 1
test ebp, ebp
jle short loc_1854
nop dword ptr [rax+00000000h]
loc_1840:
test dl, 1
mov ecx, esi
cmovnz ecx, ebx
mov [rax+rdx*4], ecx
add rdx, 1
cmp r12, rdx
jnz short loc_1840
loc_1854:
pop rbx
pop rbp
pop r12
retn
|
_DWORD * func0(long long a1, int a2, int a3, int *a4, int a5, int a6)
{
long long i; // rdi
long long j; // rax
int v10; // ebx
_DWORD *result; // rax
long long v12; // rdx
int v13; // ecx
if ( a2 > 0 )
{
for ( i = 0LL; i != a2; ++i )
{
for ( j = 0LL; j != a2; ++j )
{
if ( *(_DWORD *)(*(_QWORD *)(a1 + 8 * i) + 4 * j) == 1 )
{
a5 = j;
a6 = i;
}
}
}
}
v10 = a2 * a2;
if ( a6 > 0 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 - 8) + 4LL * a5) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 - 8) + 4LL * a5);
if ( a2 - 1 > a6 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 + 8) + 4LL * a5) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6 + 8) + 4LL * a5);
if ( a5 > 0 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 - 4) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 - 4);
if ( a2 - 1 > a5 && v10 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 + 4) )
v10 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * a6) + 4LL * a5 + 4);
*a4 = a3;
result = malloc(4LL * a3);
v12 = 0LL;
if ( a3 > 0 )
{
do
{
v13 = 1;
if ( (v12 & 1) != 0 )
v13 = v10;
result[v12++] = v13;
}
while ( a3 != v12 );
}
return result;
}
|
func0:
ENDBR64
PUSH R12
MOV R10,RDI
MOV R11D,ESI
MOV R12,RCX
PUSH RBP
MOV EBP,EDX
PUSH RBX
TEST ESI,ESI
JLE 0x001017ae
MOVSXD RSI,ESI
XOR EDI,EDI
NOP dword ptr [RAX]
LAB_00101780:
MOV RDX,qword ptr [R10 + RDI*0x8]
MOV ECX,EDI
XOR EAX,EAX
NOP dword ptr [RAX + RAX*0x1]
LAB_00101790:
CMP dword ptr [RDX + RAX*0x4],0x1
CMOVZ R8D,EAX
CMOVZ R9D,ECX
ADD RAX,0x1
CMP RAX,RSI
JNZ 0x00101790
ADD RDI,0x1
CMP RDI,RSI
JNZ 0x00101780
LAB_001017ae:
MOV EBX,R11D
IMUL EBX,R11D
TEST R9D,R9D
JLE 0x001017cd
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8 + -0x8]
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP EBX,EAX
CMOVG EBX,EAX
LAB_001017cd:
SUB R11D,0x1
CMP R11D,R9D
JLE 0x001017e9
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8 + 0x8]
MOV EAX,dword ptr [RDX + RAX*0x4]
CMP EBX,EAX
CMOVG EBX,EAX
LAB_001017e9:
TEST R8D,R8D
JLE 0x00101801
MOVSXD RDX,R9D
MOVSXD RAX,R8D
MOV RDX,qword ptr [R10 + RDX*0x8]
MOV EAX,dword ptr [RDX + RAX*0x4 + -0x4]
CMP EBX,EAX
CMOVG EBX,EAX
LAB_00101801:
CMP R11D,R8D
JLE 0x0010181a
MOVSXD R9,R9D
MOVSXD R8,R8D
MOV RAX,qword ptr [R10 + R9*0x8]
MOV EAX,dword ptr [RAX + R8*0x4 + 0x4]
CMP EBX,EAX
CMOVG EBX,EAX
LAB_0010181a:
MOV dword ptr [R12],EBP
MOVSXD R12,EBP
LEA RDI,[R12*0x4]
CALL 0x001010b0
XOR EDX,EDX
MOV ESI,0x1
TEST EBP,EBP
JLE 0x00101854
NOP dword ptr [RAX]
LAB_00101840:
TEST DL,0x1
MOV ECX,ESI
CMOVNZ ECX,EBX
MOV dword ptr [RAX + RDX*0x4],ECX
ADD RDX,0x1
CMP R12,RDX
JNZ 0x00101840
LAB_00101854:
POP RBX
POP RBP
POP R12
RET
|
void func0(long param_1,int param_2,int param_3,int *param_4,int param_5,int param_6)
{
long lVar1;
void *pvVar2;
int iVar3;
ulong uVar4;
int iVar5;
long lVar6;
bool bVar7;
if (0 < param_2) {
lVar6 = 0;
do {
lVar1 = 0;
do {
bVar7 = *(int *)(*(long *)(param_1 + lVar6 * 8) + lVar1 * 4) == 1;
if (bVar7) {
param_5 = (int)lVar1;
}
if (bVar7) {
param_6 = (int)lVar6;
}
lVar1 = lVar1 + 1;
} while (lVar1 != param_2);
lVar6 = lVar6 + 1;
} while (lVar6 != param_2);
}
iVar5 = param_2 * param_2;
if ((0 < param_6) &&
(iVar3 = *(int *)(*(long *)(param_1 + -8 + (long)param_6 * 8) + (long)param_5 * 4),
iVar3 < iVar5)) {
iVar5 = iVar3;
}
if ((param_6 < param_2 + -1) &&
(iVar3 = *(int *)(*(long *)(param_1 + 8 + (long)param_6 * 8) + (long)param_5 * 4),
iVar3 < iVar5)) {
iVar5 = iVar3;
}
if ((0 < param_5) &&
(iVar3 = *(int *)(*(long *)(param_1 + (long)param_6 * 8) + -4 + (long)param_5 * 4),
iVar3 < iVar5)) {
iVar5 = iVar3;
}
if ((param_5 < param_2 + -1) &&
(iVar3 = *(int *)(*(long *)(param_1 + (long)param_6 * 8) + 4 + (long)param_5 * 4),
iVar3 < iVar5)) {
iVar5 = iVar3;
}
*param_4 = param_3;
pvVar2 = malloc((long)param_3 * 4);
uVar4 = 0;
if (0 < param_3) {
do {
iVar3 = 1;
if ((uVar4 & 1) != 0) {
iVar3 = iVar5;
}
*(int *)((long)pvVar2 + uVar4 * 4) = iVar3;
uVar4 = uVar4 + 1;
} while ((long)param_3 != uVar4);
}
return;
}
|
1,175 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int *func0(int **grid, int N, int k, int *returnSize) {
int i, j, x, y, min;
for (i = 0; i < N; i++)
for (j = 0; j < N; j++)
if (grid[i][j] == 1) {
x = i;
y = j;
}
min = N * N;
if (x > 0 && grid[x - 1][y] < min) min = grid[x - 1][y];
if (x < N - 1 && grid[x + 1][y] < min) min = grid[x + 1][y];
if (y > 0 && grid[x][y - 1] < min) min = grid[x][y - 1];
if (y < N - 1 && grid[x][y + 1] < min) min = grid[x][y + 1];
*returnSize = k;
int *out = (int *)malloc(k * sizeof(int));
for (i = 0; i < k; i++)
if (i % 2 == 0) out[i] = 1;
else out[i] = min;
return out;
}
|
#include <stdio.h>
#include <assert.h>
int issame(int *a, int *b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
// Test case 1
int grid1[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int *grid1_ptrs[] = {grid1[0], grid1[1], grid1[2]};
int result1[] = {1, 2, 1};
int *out1 = func0(grid1_ptrs, 3, 3, &size);
assert(issame(out1, result1, size));
free(out1);
// Test case 2
int grid2[3][3] = {{5, 9, 3}, {4, 1, 6}, {7, 8, 2}};
int *grid2_ptrs[] = {grid2[0], grid2[1], grid2[2]};
int result2[] = {1};
int *out2 = func0(grid2_ptrs, 3, 1, &size);
assert(issame(out2, result2, size));
free(out2);
// Test case 3
int grid3[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};
int *grid3_ptrs[] = {grid3[0], grid3[1], grid3[2], grid3[3]};
int result3[] = {1, 2, 1, 2};
int *out3 = func0(grid3_ptrs, 4, 4, &size);
assert(issame(out3, result3, size));
free(out3);
// Test case 4
int grid4[4][4] = {{6, 4, 13, 10}, {5, 7, 12, 1}, {3, 16, 11, 15}, {8, 14, 9, 2}};
int *grid4_ptrs[] = {grid4[0], grid4[1], grid4[2], grid4[3]};
int result4[] = {1, 10, 1, 10, 1, 10, 1};
int *out4 = func0(grid4_ptrs, 4, 7, &size);
assert(issame(out4, result4, size));
free(out4);
// Test case 5
int grid5[4][4] = {{8, 14, 9, 2}, {6, 4, 13, 15}, {5, 7, 1, 12}, {3, 10, 11, 16}};
int *grid5_ptrs[] = {grid5[0], grid5[1], grid5[2], grid5[3]};
int result5[] = {1, 7, 1, 7, 1};
int *out5 = func0(grid5_ptrs, 4, 5, &size);
assert(issame(out5, result5, size));
free(out5);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %r15
push %r14
lea -0x1(%rsi),%r14d
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %edx,0x14(%rsp)
mov %rcx,0x18(%rsp)
test %esi,%esi
jle 1a18 <func0+0x308>
lea -0x1(%rsi),%eax
mov %esi,%r15d
xor %edi,%edi
mov %esi,%r13d
mov %rax,%r14
shr $0x2,%r15d
mov %rax,0x8(%rsp)
and $0xfffffffc,%r13d
mov (%r12,%rdi,8),%rax
shl $0x4,%r15
pcmpeqd %xmm9,%xmm9
mov %edi,%edx
movdqa 0x994(%rip),%xmm7
movdqa 0x99b(%rip),%xmm8
cmp $0xa,%r14d
jbe 19ef <func0+0x2df>
movd %edi,%xmm5
movd %ebp,%xmm6
lea (%r15,%rax,1),%r9
mov %rax,%rcx
pshufd $0x0,%xmm5,%xmm11
pshufd $0x0,%xmm6,%xmm2
pxor %xmm1,%xmm1
movdqa 0x93a(%rip),%xmm6
movdqa 0x942(%rip),%xmm5
movdqa %xmm9,%xmm3
nopl 0x0(%rax,%rax,1)
movdqu (%rcx),%xmm0
movdqa %xmm5,%xmm4
add $0x10,%rcx
paddd %xmm7,%xmm5
movdqa %xmm11,%xmm10
pcmpeqd %xmm8,%xmm0
movdqa %xmm0,%xmm13
pand %xmm0,%xmm4
movdqa %xmm0,%xmm12
pandn %xmm3,%xmm13
pand %xmm0,%xmm10
pandn %xmm2,%xmm12
movdqa %xmm13,%xmm3
movdqa %xmm12,%xmm2
por %xmm4,%xmm3
movdqa %xmm6,%xmm4
por %xmm10,%xmm2
pand %xmm0,%xmm4
pandn %xmm1,%xmm0
paddd %xmm7,%xmm6
movdqa %xmm0,%xmm1
por %xmm4,%xmm1
cmp %rcx,%r9
jne 17b8 <func0+0xa8>
movdqa %xmm3,%xmm4
movd %xmm1,%ebx
psrldq $0x8,%xmm4
movdqa %xmm4,%xmm0
pcmpgtd %xmm3,%xmm0
pand %xmm0,%xmm4
pandn %xmm3,%xmm0
movdqa %xmm0,%xmm3
por %xmm4,%xmm3
movdqa %xmm3,%xmm4
psrldq $0x4,%xmm4
movdqa %xmm4,%xmm0
pcmpgtd %xmm3,%xmm0
pand %xmm0,%xmm4
pandn %xmm3,%xmm0
por %xmm4,%xmm0
movd %xmm0,%ecx
pshufd $0x55,%xmm1,%xmm0
cmp $0xffffffff,%ecx
movd %xmm0,%r10d
cmovne %ecx,%r8d
movd %xmm0,%ecx
movdqa %xmm1,%xmm0
cmp %r10d,%ebx
punpckhdq %xmm1,%xmm0
cmovae %ebx,%ecx
movd %xmm0,%r9d
cmp %r9d,%ecx
jb 1a00 <func0+0x2f0>
pshufd $0x55,%xmm2,%xmm0
movd %xmm2,%r11d
cmp %r10d,%ebx
movd %xmm0,%ebp
cmovb %ebp,%r11d
pshufd $0xff,%xmm1,%xmm1
pshufd $0xff,%xmm2,%xmm2
cmp %r9d,%ecx
cmovb %r9d,%ecx
movd %xmm1,%r9d
movd %xmm2,%ebp
cmp %r9d,%ecx
mov %r13d,%r9d
cmovae %r11d,%ebp
cmp %r13d,%esi
je 19d1 <func0+0x2c1>
movslq %r9d,%r10
cmpl $0x1,(%rax,%r10,4)
lea 0x0(,%r10,4),%rcx
lea 0x1(%r9),%r10d
cmove %r9d,%r8d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x4(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x2(%r9),%r10d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x8(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x3(%r9),%r10d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0xc(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x4(%r9),%r10d
cmove %edx,%ebp
cmp %esi,%r10d
jge 19d1 <func0+0x2c1>
cmpl $0x1,0x10(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x5(%r9),%r10d
cmove %edx,%ebp
cmp %esi,%r10d
jge 19d1 <func0+0x2c1>
cmpl $0x1,0x14(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x6(%r9),%r10d
cmove %edx,%ebp
cmp %esi,%r10d
jge 19d1 <func0+0x2c1>
cmpl $0x1,0x18(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x7(%r9),%r10d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x1c(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x8(%r9),%r10d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x20(%rax,%rcx,1)
cmove %r10d,%r8d
lea 0x9(%r9),%r10d
cmove %edx,%ebp
cmp %r10d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x24(%rax,%rcx,1)
cmove %r10d,%r8d
cmove %edx,%ebp
add $0xa,%r9d
cmp %r9d,%esi
jle 19d1 <func0+0x2c1>
cmpl $0x1,0x28(%rax,%rcx,1)
cmove %r9d,%r8d
cmove %edx,%ebp
lea 0x1(%rdi),%rax
cmp 0x8(%rsp),%rdi
je 1a18 <func0+0x308>
mov %rax,%rdi
mov (%r12,%rdi,8),%rax
mov %edi,%edx
cmp $0xa,%r14d
ja 1780 <func0+0x70>
xor %r9d,%r9d
jmpq 18d8 <func0+0x1c8>
nopw 0x0(%rax,%rax,1)
movdqa %xmm2,%xmm0
punpckhdq %xmm2,%xmm0
movd %xmm0,%r11d
jmpq 18ab <func0+0x19b>
nopw 0x0(%rax,%rax,1)
mov %esi,%ebx
imul %esi,%ebx
test %ebp,%ebp
jle 1a34 <func0+0x324>
movslq %ebp,%rdx
movslq %r8d,%rax
mov -0x8(%r12,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebx
cmovg %eax,%ebx
cmp %ebp,%r14d
jle 1a4c <func0+0x33c>
movslq %ebp,%rdx
movslq %r8d,%rax
mov 0x8(%r12,%rdx,8),%rdx
mov (%rdx,%rax,4),%eax
cmp %eax,%ebx
cmovg %eax,%ebx
test %r8d,%r8d
jle 1a64 <func0+0x354>
movslq %ebp,%rdx
movslq %r8d,%rax
mov (%r12,%rdx,8),%rdx
mov -0x4(%rdx,%rax,4),%eax
cmp %eax,%ebx
cmovg %eax,%ebx
cmp %r8d,%r14d
jle 1a7d <func0+0x36d>
movslq %ebp,%rbp
movslq %r8d,%r8
mov (%r12,%rbp,8),%rax
mov 0x4(%rax,%r8,4),%eax
cmp %eax,%ebx
cmovg %eax,%ebx
movslq 0x14(%rsp),%rdi
mov 0x18(%rsp),%rax
mov %edi,(%rax)
mov %rdi,%r15
shl $0x2,%rdi
callq 10b0 <malloc@plt>
test %r15d,%r15d
jle 1b5c <func0+0x44c>
lea -0x1(%r15),%edx
cmp $0x2,%edx
jbe 1b6b <func0+0x45b>
movd %ebx,%xmm7
shr $0x2,%r15d
mov %rax,%rdx
pxor %xmm4,%xmm4
mov %r15d,%ecx
movdqa 0x62b(%rip),%xmm1
movdqa 0x633(%rip),%xmm5
pshufd $0x0,%xmm7,%xmm6
shl $0x4,%rcx
movdqa 0x632(%rip),%xmm2
add %rax,%rcx
nopl 0x0(%rax)
movdqa %xmm1,%xmm0
movdqa %xmm2,%xmm3
paddd %xmm5,%xmm1
add $0x10,%rdx
pand %xmm2,%xmm0
pcmpeqd %xmm4,%xmm0
pand %xmm0,%xmm3
pandn %xmm6,%xmm0
por %xmm3,%xmm0
movups %xmm0,-0x10(%rdx)
cmp %rcx,%rdx
jne 1ae8 <func0+0x3d8>
mov 0x14(%rsp),%edi
mov %edi,%edx
and $0xfffffffc,%edx
test $0x3,%dil
je 1b5c <func0+0x44c>
movslq %edx,%rcx
mov %edi,%r11d
lea (%rax,%rcx,4),%rcx
movl $0x1,(%rcx)
lea 0x1(%rdx),%ecx
cmp %r11d,%ecx
jge 1b5c <func0+0x44c>
movslq %ecx,%r8
mov $0x1,%edi
and $0x1,%ecx
cmove %edi,%ebx
add $0x2,%edx
mov %ebx,(%rax,%r8,4)
cmp %edx,%r11d
jle 1b5c <func0+0x44c>
movslq %edx,%rdx
mov %edi,(%rax,%rdx,4)
add $0x28,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
pop %r14
pop %r15
retq
mov 0x14(%rsp),%r11d
mov %rax,%rcx
xor %edx,%edx
jmp 1b2e <func0+0x41e>
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push r15
lea r15d, [rsi-1]
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
mov ebx, edx
mov rdx, rcx
sub rsp, 28h
test esi, esi
jle loc_19CA
movsxd rdi, esi
mov ecx, esi
mov [rsp+58h+var_44], ebx
mov r14d, esi
shr ecx, 2
mov [rsp+58h+var_50], rdi
lea r15d, [rsi-1]
and r14d, 0FFFFFFFCh
mov [rsp+58h+var_40], rdx
shl rcx, 4
movdqa xmm7, cs:xmmword_20E0
xor r9d, r9d
movdqa xmm9, cs:xmmword_20F0
mov r13, rcx
pcmpeqd xmm10, xmm10
nop word ptr [rax+rax+00000000h]
loc_17D0:
mov rdx, [r12+r9*8]
mov r11d, r9d
cmp r15d, 5
jbe loc_1B30
movd xmm4, eax
lea rcx, [rdx+r13]
pxor xmm2, xmm2
mov rax, rdx
pshufd xmm5, xmm4, 0
movd xmm4, r9d
movdqa xmm6, xmm10
movdqa xmm3, cs:xmmword_20D0
pshufd xmm11, xmm4, 0
movdqa xmm4, cs:xmmword_20C0
nop dword ptr [rax]
loc_1818:
movdqu xmm0, xmmword ptr [rax]
movdqa xmm8, xmm11
movdqa xmm1, xmm3
add rax, 10h
paddd xmm3, xmm7
pcmpeqd xmm0, xmm9
movdqa xmm12, xmm0
pand xmm8, xmm0
pand xmm1, xmm0
pandn xmm12, xmm5
movdqa xmm5, xmm12
por xmm5, xmm8
movdqa xmm8, xmm0
pandn xmm8, xmm6
movdqa xmm6, xmm8
por xmm6, xmm1
movdqa xmm1, xmm4
paddd xmm4, xmm7
pand xmm1, xmm0
pandn xmm0, xmm2
movdqa xmm2, xmm0
por xmm2, xmm1
cmp rax, rcx
jnz short loc_1818
movdqa xmm0, xmm6
movd ebp, xmm2
psrldq xmm0, 8
movdqa xmm1, xmm0
pcmpgtd xmm1, xmm6
pand xmm0, xmm1
pandn xmm1, xmm6
por xmm1, xmm0
movdqa xmm3, xmm1
psrldq xmm3, 4
movdqa xmm0, xmm3
pcmpgtd xmm0, xmm1
pand xmm3, xmm0
pandn xmm0, xmm1
por xmm0, xmm3
movd eax, xmm0
pshufd xmm0, xmm2, 55h ; 'U'
movd r10d, xmm0
cmp eax, 0FFFFFFFFh
movdqa xmm0, xmm2
cmovnz r8d, eax
mov ecx, r10d
punpckhdq xmm0, xmm2
cmp ebp, r10d
cmovnb ecx, ebp
movd edi, xmm0
pshufd xmm0, xmm5, 0FFh
movd ebx, xmm0
cmp ecx, edi
jnb loc_1B00
punpckhdq xmm5, xmm5
movd eax, xmm5
loc_1900:
cmp ecx, edi
pshufd xmm2, xmm2, 0FFh
cmovb ecx, edi
movd edi, xmm2
cmp ecx, edi
mov ecx, r14d
cmovb eax, ebx
cmp esi, r14d
jz loc_19AF
loc_191F:
movsxd r10, ecx
cmp dword ptr [rdx+r10*4], 1
lea rdi, ds:0[r10*4]
lea r10d, [rcx+1]
cmovz r8d, ecx
cmovz eax, r11d
cmp esi, r10d
jle short loc_19AF
cmp dword ptr [rdx+rdi+4], 1
cmovnz r10d, r8d
lea r8d, [rcx+2]
cmovz eax, r11d
cmp esi, r8d
jle loc_1B20
cmp dword ptr [rdx+rdi+8], 1
cmovnz r8d, r10d
lea r10d, [rcx+3]
cmovz eax, r11d
cmp esi, r10d
jle short loc_19AF
cmp dword ptr [rdx+rdi+0Ch], 1
lea ebx, [rcx+4]
cmovnz r10d, r8d
cmovz eax, r11d
cmp ebx, esi
jge loc_1B20
lea r8d, [rcx+5]
cmp dword ptr [rdx+rdi+10h], 1
cmovnz ebx, r10d
cmovz eax, r11d
cmp r8d, esi
jge loc_1B37
cmp dword ptr [rdx+rdi+14h], 1
cmovnz r8d, ebx
cmovz eax, r11d
loc_19AF:
mov rbx, [rsp+58h+var_50]
add r9, 1
cmp r9, rbx
jnz loc_17D0
mov ebx, [rsp+58h+var_44]
mov rdx, [rsp+58h+var_40]
loc_19CA:
imul esi, esi
mov ebp, esi
test eax, eax
jle short loc_19E6
movsxd rsi, eax
movsxd rcx, r8d
mov rsi, [r12+rsi*8-8]
mov ecx, [rsi+rcx*4]
cmp ebp, ecx
cmovg ebp, ecx
loc_19E6:
cmp r15d, eax
jle short loc_19FE
movsxd rsi, eax
movsxd rcx, r8d
mov rsi, [r12+rsi*8+8]
mov ecx, [rsi+rcx*4]
cmp ebp, ecx
cmovg ebp, ecx
loc_19FE:
test r8d, r8d
jle short loc_1A16
movsxd rsi, eax
movsxd rcx, r8d
mov rsi, [r12+rsi*8]
mov ecx, [rsi+rcx*4-4]
cmp ebp, ecx
cmovg ebp, ecx
loc_1A16:
cmp r15d, r8d
jle short loc_1A2E
cdqe
movsxd r8, r8d
mov rax, [r12+rax*8]
mov eax, [rax+r8*4+4]
cmp ebp, eax
cmovg ebp, eax
loc_1A2E:
mov [rdx], ebx
movsxd rdi, ebx
shl rdi, 2; size
call _malloc
test ebx, ebx
jle loc_1AEC
lea edx, [rbx-1]
cmp edx, 2
jbe loc_1B3F
mov ecx, ebx
movd xmm7, ebp
movdqa xmm1, cs:xmmword_20D0
movdqa xmm5, cs:xmmword_20E0
shr ecx, 2
pshufd xmm6, xmm7, 0
pxor xmm4, xmm4
mov rdx, rax
shl rcx, 4
movdqa xmm2, cs:xmmword_20F0
add rcx, rax
nop dword ptr [rax+00h]
loc_1A88:
movdqa xmm0, xmm1
movdqa xmm3, xmm2
paddd xmm1, xmm5
add rdx, 10h
pand xmm0, xmm2
pcmpeqd xmm0, xmm4
pand xmm3, xmm0
pandn xmm0, xmm6
por xmm0, xmm3
movups xmmword ptr [rdx-10h], xmm0
cmp rcx, rdx
jnz short loc_1A88
mov edx, ebx
and edx, 0FFFFFFFCh
test bl, 3
jz short loc_1AEC
mov ecx, edx
lea edi, [rdx+1]
mov dword ptr [rax+rcx*4], 1
lea rcx, ds:4[rcx*4]
lea rsi, [rax+rcx]
cmp ebx, edi
jle short loc_1AEC
loc_1ADB:
add edx, 2
mov [rsi], ebp
cmp edx, ebx
jge short loc_1AEC
mov dword ptr [rax+rcx+4], 1
loc_1AEC:
add rsp, 28h
pop rbx
pop rbp
pop r12
pop r13
pop r14
pop r15
retn
loc_1B00:
pshufd xmm0, xmm5, 55h ; 'U'
movd eax, xmm5
cmp ebp, r10d
movd [rsp+58h+var_48], xmm0
cmovb eax, [rsp+58h+var_48]
jmp loc_1900
loc_1B20:
mov r8d, r10d
jmp loc_19AF
loc_1B30:
xor ecx, ecx
jmp loc_191F
loc_1B37:
mov r8d, ebx
jmp loc_19AF
loc_1B3F:
mov dword ptr [rax], 1
lea rsi, [rax+4]
mov ecx, 4
xor edx, edx
cmp ebx, 1
jnz short loc_1ADB
jmp short loc_1AEC
|
__m128i * func0(long long a1, int a2, int a3, int *a4, int a5)
{
signed int v5; // eax
signed int v6; // r15d
int *v9; // rdx
__m128i si128; // xmm7
long long v11; // r9
__m128i v12; // xmm9
long long v13; // rdx
__m128i v14; // xmm4
__m128i v15; // xmm2
const __m128i *v16; // rax
__m128i v17; // xmm5
__m128i v18; // xmm6
__m128i v19; // xmm3
__m128i v20; // xmm11
__m128i v21; // xmm4
__m128i v22; // xmm0
__m128i v23; // xmm1
__m128i v24; // xmm0
__m128i v25; // xmm1
unsigned int v26; // ebp
__m128i v27; // xmm0
__m128i v28; // xmm1
__m128i v29; // xmm1
__m128i v30; // xmm3
__m128i v31; // xmm0
int v32; // eax
unsigned int v33; // r10d
unsigned int v34; // ecx
__m128i v35; // xmm0
unsigned int v36; // edi
int v37; // ebx
__m128i v38; // xmm2
bool v39; // cf
signed int v40; // ecx
long long v41; // rdi
int v42; // r10d
int v43; // ebx
signed int v44; // ebp
signed int v45; // eax
__m128i *result; // rax
__m128i v47; // xmm1
__m128i v48; // xmm5
__m128i v49; // xmm6
__m128i *v50; // rdx
__m128i v51; // xmm2
__m128i v52; // xmm0
__m128i v53; // xmm0
unsigned int v54; // edx
long long v55; // rcx
signed int *v56; // rsi
int v57; // [rsp+10h] [rbp-48h]
int v58; // [rsp+14h] [rbp-44h]
v6 = a2 - 1;
v9 = a4;
if ( a2 > 0 )
{
v58 = a3;
v6 = a2 - 1;
si128 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v11 = 0LL;
v12 = _mm_load_si128((const __m128i *)&xmmword_20F0);
while ( 1 )
{
v13 = *(_QWORD *)(a1 + 8 * v11);
if ( (unsigned int)v6 <= 5 )
{
v40 = 0;
}
else
{
v14 = _mm_cvtsi32_si128(v5);
v15 = 0LL;
v16 = *(const __m128i **)(a1 + 8 * v11);
v17 = _mm_shuffle_epi32(v14, 0);
v18 = (__m128i)-1LL;
v19 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v20 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v11), 0);
v21 = _mm_load_si128((const __m128i *)&xmmword_20C0);
do
{
v22 = _mm_loadu_si128(v16);
v23 = v19;
++v16;
v19 = _mm_add_epi32(v19, si128);
v24 = _mm_cmpeq_epi32(v22, v12);
v17 = _mm_or_si128(_mm_andnot_si128(v24, v17), _mm_and_si128(v20, v24));
v18 = _mm_or_si128(_mm_andnot_si128(v24, v18), _mm_and_si128(v23, v24));
v25 = v21;
v21 = _mm_add_epi32(v21, si128);
v15 = _mm_or_si128(_mm_andnot_si128(v24, v15), _mm_and_si128(v25, v24));
}
while ( v16 != (const __m128i *)(v13 + 16LL * ((unsigned int)a2 >> 2)) );
v26 = _mm_cvtsi128_si32(v15);
v27 = _mm_srli_si128(v18, 8);
v28 = _mm_cmpgt_epi32(v27, v18);
v29 = _mm_or_si128(_mm_andnot_si128(v28, v18), _mm_and_si128(v27, v28));
v30 = _mm_srli_si128(v29, 4);
v31 = _mm_cmpgt_epi32(v30, v29);
v32 = _mm_cvtsi128_si32(_mm_or_si128(_mm_andnot_si128(v31, v29), _mm_and_si128(v30, v31)));
v33 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v15, 85));
if ( v32 != -1 )
a5 = v32;
v34 = v33;
v35 = _mm_unpackhi_epi32(v15, v15);
if ( v26 >= v33 )
v34 = v26;
v36 = _mm_cvtsi128_si32(v35);
v37 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v17, 255));
if ( v34 >= v36 )
{
v5 = _mm_cvtsi128_si32(v17);
v57 = _mm_cvtsi128_si32(_mm_shuffle_epi32(v17, 85));
if ( v26 < v33 )
v5 = v57;
}
else
{
v5 = _mm_cvtsi128_si32(_mm_unpackhi_epi32(v17, v17));
}
v38 = _mm_shuffle_epi32(v15, 255);
if ( v34 < v36 )
v34 = v36;
v39 = v34 < _mm_cvtsi128_si32(v38);
v40 = a2 & 0xFFFFFFFC;
if ( v39 )
v5 = v37;
if ( a2 == (a2 & 0xFFFFFFFC) )
goto LABEL_41;
}
v41 = 4LL * v40;
v42 = v40 + 1;
if ( *(_DWORD *)(v13 + v41) == 1 )
{
a5 = v40;
v5 = v11;
}
if ( a2 > v42 )
{
if ( *(_DWORD *)(v13 + v41 + 4) != 1 )
v42 = a5;
a5 = v40 + 2;
if ( *(_DWORD *)(v13 + v41 + 4) == 1 )
v5 = v11;
if ( a2 <= a5 )
goto LABEL_67;
if ( *(_DWORD *)(v13 + v41 + 8) != 1 )
a5 = v42;
v42 = v40 + 3;
if ( *(_DWORD *)(v13 + v41 + 8) == 1 )
v5 = v11;
if ( a2 <= v42 )
goto LABEL_41;
v43 = v40 + 4;
if ( *(_DWORD *)(v13 + v41 + 12) == 1 )
v5 = v11;
else
v42 = a5;
if ( v43 >= a2 )
{
LABEL_67:
a5 = v42;
}
else
{
a5 = v40 + 5;
if ( *(_DWORD *)(v13 + v41 + 16) == 1 )
v5 = v11;
else
v43 = v42;
if ( a5 >= a2 )
{
a5 = v43;
}
else if ( *(_DWORD *)(v13 + v41 + 20) == 1 )
{
v5 = v11;
}
else
{
a5 = v43;
}
}
}
LABEL_41:
if ( ++v11 == a2 )
{
a3 = v58;
v9 = a4;
break;
}
}
}
v44 = a2 * a2;
if ( v5 > 0 && v44 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5 - 8) + 4LL * a5) )
v44 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5 - 8) + 4LL * a5);
if ( v6 > v5 && v44 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5 + 8) + 4LL * a5) )
v44 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5 + 8) + 4LL * a5);
if ( a5 > 0 && v44 > *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5) + 4LL * a5 - 4) )
v44 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5) + 4LL * a5 - 4);
if ( v6 > a5 )
{
v45 = *(_DWORD *)(*(_QWORD *)(a1 + 8LL * v5) + 4LL * a5 + 4);
if ( v44 > v45 )
v44 = v45;
}
*v9 = a3;
result = (__m128i *)malloc(4LL * a3);
if ( a3 > 0 )
{
if ( (unsigned int)(a3 - 1) <= 2 )
{
result->m128i_i32[0] = 1;
v56 = &result->m128i_i32[1];
v55 = 4LL;
v54 = 0;
if ( a3 == 1 )
return result;
goto LABEL_61;
}
v47 = _mm_load_si128((const __m128i *)&xmmword_20D0);
v48 = _mm_load_si128((const __m128i *)&xmmword_20E0);
v49 = _mm_shuffle_epi32(_mm_cvtsi32_si128(v44), 0);
v50 = result;
v51 = _mm_load_si128((const __m128i *)&xmmword_20F0);
do
{
v52 = v47;
v47 = _mm_add_epi32(v47, v48);
++v50;
v53 = _mm_cmpeq_epi32(_mm_and_si128(v52, v51), (__m128i)0LL);
v50[-1] = _mm_or_si128(_mm_andnot_si128(v53, v49), _mm_and_si128(v51, v53));
}
while ( &result[(unsigned int)a3 >> 2] != v50 );
v54 = a3 & 0x7FFFFFFC;
if ( (a3 & 3) != 0 )
{
result->m128i_i32[v54] = 1;
v55 = 4LL * v54 + 4;
v56 = (__int32 *)((char *)result->m128i_i32 + v55);
if ( a3 > (int)(v54 + 1) )
{
LABEL_61:
*v56 = v44;
if ( (int)(v54 + 2) < a3 )
*(__int32 *)((char *)&result->m128i_i32[1] + v55) = 1;
}
}
}
return result;
}
|
func0:
ENDBR64
PUSH R15
LEA R15D,[RSI + -0x1]
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
MOV EBX,EDX
MOV RDX,RCX
SUB RSP,0x28
TEST ESI,ESI
JLE 0x001019ca
MOVSXD RDI,ESI
MOV ECX,ESI
MOV dword ptr [RSP + 0x14],EBX
MOV R14D,ESI
SHR ECX,0x2
MOV qword ptr [RSP + 0x8],RDI
LEA R15D,[RSI + -0x1]
AND R14D,0xfffffffc
MOV qword ptr [RSP + 0x18],RDX
SHL RCX,0x4
MOVDQA XMM7,xmmword ptr [0x001020e0]
XOR R9D,R9D
MOVDQA XMM9,xmmword ptr [0x001020f0]
MOV R13,RCX
PCMPEQD XMM10,XMM10
NOP word ptr [RAX + RAX*0x1]
LAB_001017d0:
MOV RDX,qword ptr [R12 + R9*0x8]
MOV R11D,R9D
CMP R15D,0x5
JBE 0x00101b30
MOVD XMM4,EAX
LEA RCX,[RDX + R13*0x1]
PXOR XMM2,XMM2
MOV RAX,RDX
PSHUFD XMM5,XMM4,0x0
MOVD XMM4,R9D
MOVDQA XMM6,XMM10
MOVDQA XMM3,xmmword ptr [0x001020d0]
PSHUFD XMM11,XMM4,0x0
MOVDQA XMM4,xmmword ptr [0x001020c0]
NOP dword ptr [RAX]
LAB_00101818:
MOVDQU XMM0,xmmword ptr [RAX]
MOVDQA XMM8,XMM11
MOVDQA XMM1,XMM3
ADD RAX,0x10
PADDD XMM3,XMM7
PCMPEQD XMM0,XMM9
MOVDQA XMM12,XMM0
PAND XMM8,XMM0
PAND XMM1,XMM0
PANDN XMM12,XMM5
MOVDQA XMM5,XMM12
POR XMM5,XMM8
MOVDQA XMM8,XMM0
PANDN XMM8,XMM6
MOVDQA XMM6,XMM8
POR XMM6,XMM1
MOVDQA XMM1,XMM4
PADDD XMM4,XMM7
PAND XMM1,XMM0
PANDN XMM0,XMM2
MOVDQA XMM2,XMM0
POR XMM2,XMM1
CMP RAX,RCX
JNZ 0x00101818
MOVDQA XMM0,XMM6
MOVD EBP,XMM2
PSRLDQ XMM0,0x8
MOVDQA XMM1,XMM0
PCMPGTD XMM1,XMM6
PAND XMM0,XMM1
PANDN XMM1,XMM6
POR XMM1,XMM0
MOVDQA XMM3,XMM1
PSRLDQ XMM3,0x4
MOVDQA XMM0,XMM3
PCMPGTD XMM0,XMM1
PAND XMM3,XMM0
PANDN XMM0,XMM1
POR XMM0,XMM3
MOVD EAX,XMM0
PSHUFD XMM0,XMM2,0x55
MOVD R10D,XMM0
CMP EAX,-0x1
MOVDQA XMM0,XMM2
CMOVNZ R8D,EAX
MOV ECX,R10D
PUNPCKHDQ XMM0,XMM2
CMP EBP,R10D
CMOVNC ECX,EBP
MOVD EDI,XMM0
PSHUFD XMM0,XMM5,0xff
MOVD EBX,XMM0
CMP ECX,EDI
JNC 0x00101b00
PUNPCKHDQ XMM5,XMM5
MOVD EAX,XMM5
LAB_00101900:
CMP ECX,EDI
PSHUFD XMM2,XMM2,0xff
CMOVC ECX,EDI
MOVD EDI,XMM2
CMP ECX,EDI
MOV ECX,R14D
CMOVC EAX,EBX
CMP ESI,R14D
JZ 0x001019af
LAB_0010191f:
MOVSXD R10,ECX
CMP dword ptr [RDX + R10*0x4],0x1
LEA RDI,[R10*0x4]
LEA R10D,[RCX + 0x1]
CMOVZ R8D,ECX
CMOVZ EAX,R11D
CMP ESI,R10D
JLE 0x001019af
CMP dword ptr [RDX + RDI*0x1 + 0x4],0x1
CMOVNZ R10D,R8D
LEA R8D,[RCX + 0x2]
CMOVZ EAX,R11D
CMP ESI,R8D
JLE 0x00101b20
CMP dword ptr [RDX + RDI*0x1 + 0x8],0x1
CMOVNZ R8D,R10D
LEA R10D,[RCX + 0x3]
CMOVZ EAX,R11D
CMP ESI,R10D
JLE 0x001019af
CMP dword ptr [RDX + RDI*0x1 + 0xc],0x1
LEA EBX,[RCX + 0x4]
CMOVNZ R10D,R8D
CMOVZ EAX,R11D
CMP EBX,ESI
JGE 0x00101b20
LEA R8D,[RCX + 0x5]
CMP dword ptr [RDX + RDI*0x1 + 0x10],0x1
CMOVNZ EBX,R10D
CMOVZ EAX,R11D
CMP R8D,ESI
JGE 0x00101b37
CMP dword ptr [RDX + RDI*0x1 + 0x14],0x1
CMOVNZ R8D,EBX
CMOVZ EAX,R11D
LAB_001019af:
MOV RBX,qword ptr [RSP + 0x8]
ADD R9,0x1
CMP R9,RBX
JNZ 0x001017d0
MOV EBX,dword ptr [RSP + 0x14]
MOV RDX,qword ptr [RSP + 0x18]
LAB_001019ca:
IMUL ESI,ESI
MOV EBP,ESI
TEST EAX,EAX
JLE 0x001019e6
MOVSXD RSI,EAX
MOVSXD RCX,R8D
MOV RSI,qword ptr [R12 + RSI*0x8 + -0x8]
MOV ECX,dword ptr [RSI + RCX*0x4]
CMP EBP,ECX
CMOVG EBP,ECX
LAB_001019e6:
CMP R15D,EAX
JLE 0x001019fe
MOVSXD RSI,EAX
MOVSXD RCX,R8D
MOV RSI,qword ptr [R12 + RSI*0x8 + 0x8]
MOV ECX,dword ptr [RSI + RCX*0x4]
CMP EBP,ECX
CMOVG EBP,ECX
LAB_001019fe:
TEST R8D,R8D
JLE 0x00101a16
MOVSXD RSI,EAX
MOVSXD RCX,R8D
MOV RSI,qword ptr [R12 + RSI*0x8]
MOV ECX,dword ptr [RSI + RCX*0x4 + -0x4]
CMP EBP,ECX
CMOVG EBP,ECX
LAB_00101a16:
CMP R15D,R8D
JLE 0x00101a2e
CDQE
MOVSXD R8,R8D
MOV RAX,qword ptr [R12 + RAX*0x8]
MOV EAX,dword ptr [RAX + R8*0x4 + 0x4]
CMP EBP,EAX
CMOVG EBP,EAX
LAB_00101a2e:
MOV dword ptr [RDX],EBX
MOVSXD RDI,EBX
SHL RDI,0x2
CALL 0x001010b0
TEST EBX,EBX
JLE 0x00101aec
LEA EDX,[RBX + -0x1]
CMP EDX,0x2
JBE 0x00101b3f
MOV ECX,EBX
MOVD XMM7,EBP
MOVDQA XMM1,xmmword ptr [0x001020d0]
MOVDQA XMM5,xmmword ptr [0x001020e0]
SHR ECX,0x2
PSHUFD XMM6,XMM7,0x0
PXOR XMM4,XMM4
MOV RDX,RAX
SHL RCX,0x4
MOVDQA XMM2,xmmword ptr [0x001020f0]
ADD RCX,RAX
NOP dword ptr [RAX]
LAB_00101a88:
MOVDQA XMM0,XMM1
MOVDQA XMM3,XMM2
PADDD XMM1,XMM5
ADD RDX,0x10
PAND XMM0,XMM2
PCMPEQD XMM0,XMM4
PAND XMM3,XMM0
PANDN XMM0,XMM6
POR XMM0,XMM3
MOVUPS xmmword ptr [RDX + -0x10],XMM0
CMP RCX,RDX
JNZ 0x00101a88
MOV EDX,EBX
AND EDX,0xfffffffc
TEST BL,0x3
JZ 0x00101aec
MOV ECX,EDX
LEA EDI,[RDX + 0x1]
MOV dword ptr [RAX + RCX*0x4],0x1
LEA RCX,[0x4 + RCX*0x4]
LEA RSI,[RAX + RCX*0x1]
CMP EBX,EDI
JLE 0x00101aec
LAB_00101adb:
ADD EDX,0x2
MOV dword ptr [RSI],EBP
CMP EDX,EBX
JGE 0x00101aec
MOV dword ptr [RAX + RCX*0x1 + 0x4],0x1
LAB_00101aec:
ADD RSP,0x28
POP RBX
POP RBP
POP R12
POP R13
POP R14
POP R15
RET
LAB_00101b00:
PSHUFD XMM0,XMM5,0x55
MOVD EAX,XMM5
CMP EBP,R10D
MOVD dword ptr [RSP + 0x10],XMM0
CMOVC EAX,dword ptr [RSP + 0x10]
JMP 0x00101900
LAB_00101b20:
MOV R8D,R10D
JMP 0x001019af
LAB_00101b30:
XOR ECX,ECX
JMP 0x0010191f
LAB_00101b37:
MOV R8D,EBX
JMP 0x001019af
LAB_00101b3f:
MOV dword ptr [RAX],0x1
LEA RSI,[RAX + 0x4]
MOV ECX,0x4
XOR EDX,EDX
CMP EBX,0x1
JNZ 0x00101adb
JMP 0x00101aec
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void func0(long param_1,uint param_2,uint param_3,uint *param_4,uint param_5)
{
uint *puVar1;
uint *puVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
uint in_EAX;
uint uVar7;
uint *puVar8;
uint *puVar9;
ulong uVar10;
uint *puVar11;
uint uVar12;
uint uVar13;
long lVar14;
uint uVar15;
uint uVar16;
uint uVar17;
uint uVar18;
uint uVar19;
uint uVar20;
uint uVar21;
uint uVar22;
uint uVar23;
uint uVar24;
uint uVar25;
uint uVar26;
uint uVar27;
uint uVar28;
uint uVar29;
uint uVar30;
uint uVar31;
uint uVar32;
uint uVar33;
uint uVar34;
uint uVar35;
if (0 < (int)param_2) {
lVar14 = 0;
do {
puVar9 = *(uint **)(param_1 + lVar14 * 8);
uVar12 = (uint)lVar14;
if (param_2 - 1 < 6) {
uVar16 = 0;
LAB_0010191f:
uVar13 = param_5;
if (puVar9[(int)uVar16] == 1) {
in_EAX = uVar12;
uVar13 = uVar16;
}
param_5 = uVar13;
if ((int)(uVar16 + 1) < (int)param_2) {
param_5 = uVar16 + 1;
if (puVar9[(long)(int)uVar16 + 1] != 1) {
param_5 = uVar13;
}
if (puVar9[(long)(int)uVar16 + 1] == 1) {
in_EAX = uVar12;
}
if ((int)(uVar16 + 2) < (int)param_2) {
uVar13 = uVar16 + 2;
if (puVar9[(long)(int)uVar16 + 2] != 1) {
uVar13 = param_5;
}
if (puVar9[(long)(int)uVar16 + 2] == 1) {
in_EAX = uVar12;
}
param_5 = uVar13;
if ((int)(uVar16 + 3) < (int)param_2) {
if (puVar9[(long)(int)uVar16 + 3] == 1) {
in_EAX = uVar12;
param_5 = uVar16 + 3;
}
if ((int)(uVar16 + 4) < (int)param_2) {
if (puVar9[(long)(int)uVar16 + 4] == 1) {
in_EAX = uVar12;
param_5 = uVar16 + 4;
}
if (((int)(uVar16 + 5) < (int)param_2) && (puVar9[(long)(int)uVar16 + 5] == 1)) {
in_EAX = uVar12;
param_5 = uVar16 + 5;
}
}
}
}
}
}
else {
uVar24 = 0;
uVar25 = 0;
uVar26 = 0;
uVar27 = 0;
uVar16 = 0xffffffff;
uVar13 = 0xffffffff;
uVar34 = 0xffffffff;
uVar35 = 0xffffffff;
puVar8 = puVar9;
uVar32 = in_EAX;
uVar7 = in_EAX;
uVar33 = in_EAX;
uVar31 = (uint)DAT_001020c0;
uVar17 = DAT_001020c0._4_4_;
uVar19 = _UNK_001020c8;
uVar21 = _UNK_001020cc;
uVar23 = _DAT_001020d0;
uVar28 = _UNK_001020d4;
uVar29 = _UNK_001020d8;
uVar30 = _UNK_001020dc;
do {
uVar15 = *puVar8;
puVar11 = puVar8 + 1;
puVar1 = puVar8 + 2;
puVar2 = puVar8 + 3;
puVar8 = puVar8 + 4;
uVar15 = -(uint)(uVar15 == _DAT_001020f0);
uVar18 = -(uint)(*puVar11 == _UNK_001020f4);
uVar20 = -(uint)(*puVar1 == _UNK_001020f8);
uVar22 = -(uint)(*puVar2 == _UNK_001020fc);
in_EAX = ~uVar15 & in_EAX | uVar12 & uVar15;
uVar32 = ~uVar18 & uVar32 | uVar12 & uVar18;
uVar7 = ~uVar20 & uVar7 | uVar12 & uVar20;
uVar33 = ~uVar22 & uVar33 | uVar12 & uVar22;
uVar13 = ~uVar15 & uVar13 | uVar23 & uVar15;
uVar34 = ~uVar18 & uVar34 | uVar28 & uVar18;
uVar35 = ~uVar20 & uVar35 | uVar29 & uVar20;
uVar16 = ~uVar22 & uVar16 | uVar30 & uVar22;
uVar24 = ~uVar15 & uVar24 | uVar31 & uVar15;
uVar25 = ~uVar18 & uVar25 | uVar17 & uVar18;
uVar26 = ~uVar20 & uVar26 | uVar19 & uVar20;
uVar27 = ~uVar22 & uVar27 | uVar21 & uVar22;
uVar31 = uVar31 + _DAT_001020e0;
uVar17 = uVar17 + _UNK_001020e4;
uVar19 = uVar19 + _UNK_001020e8;
uVar21 = uVar21 + _UNK_001020ec;
uVar23 = uVar23 + _DAT_001020e0;
uVar28 = uVar28 + _UNK_001020e4;
uVar29 = uVar29 + _UNK_001020e8;
uVar30 = uVar30 + _UNK_001020ec;
} while (puVar8 != puVar9 + (ulong)(param_2 >> 2) * 4);
uVar13 = ~-(uint)((int)uVar13 < (int)uVar35) & uVar13 |
uVar35 & -(uint)((int)uVar13 < (int)uVar35);
uVar34 = ~-(uint)((int)uVar34 < (int)uVar16) & uVar34 |
uVar16 & -(uint)((int)uVar34 < (int)uVar16);
uVar16 = -(uint)((int)uVar13 < (int)uVar34);
uVar16 = ~uVar16 & uVar13 | uVar34 & uVar16;
if (uVar16 != 0xffffffff) {
param_5 = uVar16;
}
uVar16 = uVar25;
if (uVar25 <= uVar24) {
uVar16 = uVar24;
}
if ((uVar26 <= uVar16) && (uVar7 = in_EAX, uVar24 < uVar25)) {
uVar7 = uVar32;
}
if (uVar16 < uVar26) {
uVar16 = uVar26;
}
in_EAX = uVar7;
if (uVar16 < uVar27) {
in_EAX = uVar33;
}
uVar16 = param_2 & 0xfffffffc;
if (param_2 != (param_2 & 0xfffffffc)) goto LAB_0010191f;
}
lVar14 = lVar14 + 1;
} while (lVar14 != (int)param_2);
}
uVar12 = param_2 * param_2;
if ((0 < (int)in_EAX) &&
(uVar16 = *(uint *)(*(long *)(param_1 + -8 + (long)(int)in_EAX * 8) + (long)(int)param_5 * 4),
(int)uVar16 < (int)uVar12)) {
uVar12 = uVar16;
}
if (((int)in_EAX < (int)(param_2 - 1)) &&
(uVar16 = *(uint *)(*(long *)(param_1 + 8 + (long)(int)in_EAX * 8) + (long)(int)param_5 * 4),
(int)uVar16 < (int)uVar12)) {
uVar12 = uVar16;
}
if ((0 < (int)param_5) &&
(uVar16 = *(uint *)(*(long *)(param_1 + (long)(int)in_EAX * 8) + -4 + (long)(int)param_5 * 4),
(int)uVar16 < (int)uVar12)) {
uVar12 = uVar16;
}
if (((int)param_5 < (int)(param_2 - 1)) &&
(uVar16 = *(uint *)(*(long *)(param_1 + (long)(int)in_EAX * 8) + 4 + (long)(int)param_5 * 4),
(int)uVar16 < (int)uVar12)) {
uVar12 = uVar16;
}
*param_4 = param_3;
puVar9 = (uint *)malloc((long)(int)param_3 << 2);
uVar35 = _UNK_001020fc;
uVar34 = _UNK_001020f8;
uVar13 = _UNK_001020f4;
uVar16 = _DAT_001020f0;
iVar6 = _UNK_001020ec;
iVar5 = _UNK_001020e8;
iVar4 = _UNK_001020e4;
iVar3 = _DAT_001020e0;
if (0 < (int)param_3) {
if (param_3 - 1 < 3) {
*puVar9 = 1;
puVar8 = puVar9 + 1;
lVar14 = 4;
uVar16 = 0;
if (param_3 == 1) {
return;
}
}
else {
puVar8 = puVar9;
uVar7 = _DAT_001020d0;
uVar32 = _UNK_001020d4;
uVar33 = _UNK_001020d8;
uVar31 = _UNK_001020dc;
do {
puVar11 = puVar8 + 4;
uVar17 = -(uint)((uVar7 & uVar16) == 0);
uVar19 = -(uint)((uVar32 & uVar13) == 0);
uVar21 = -(uint)((uVar33 & uVar34) == 0);
uVar23 = -(uint)((uVar31 & uVar35) == 0);
*puVar8 = ~uVar17 & uVar12 | uVar16 & uVar17;
puVar8[1] = ~uVar19 & uVar12 | uVar13 & uVar19;
puVar8[2] = ~uVar21 & uVar12 | uVar34 & uVar21;
puVar8[3] = ~uVar23 & uVar12 | uVar35 & uVar23;
puVar8 = puVar11;
uVar7 = uVar7 + iVar3;
uVar32 = uVar32 + iVar4;
uVar33 = uVar33 + iVar5;
uVar31 = uVar31 + iVar6;
} while (puVar9 + (ulong)(param_3 >> 2) * 4 != puVar11);
uVar16 = param_3 & 0xfffffffc;
if ((param_3 & 3) == 0) {
return;
}
uVar10 = (ulong)uVar16;
puVar9[uVar10] = 1;
lVar14 = uVar10 * 4 + 4;
puVar8 = puVar9 + uVar10 + 1;
if ((int)param_3 <= (int)(uVar16 + 1)) {
return;
}
}
*puVar8 = uVar12;
if ((int)(uVar16 + 2) < (int)param_3) {
*(int4 *)((long)puVar9 + lVar14 + 4) = 1;
}
return;
}
return;
}
|
1,176 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, tri_3, size));
free(out3);
int tri_4[] = {1, 3, 2, 8, 3};
size = 5;
int* out4 = func0(4);
assert(issame(out4, tri_4, size));
free(out4);
int tri_5[] = {1, 3, 2, 8, 3, 15};
size = 6;
int* out5 = func0(5);
assert(issame(out5, tri_5, size));
free(out5);
int tri_6[] = {1, 3, 2, 8, 3, 15, 4};
size = 7;
int* out6 = func0(6);
assert(issame(out6, tri_6, size));
free(out6);
int tri_7[] = {1, 3, 2, 8, 3, 15, 4, 24};
size = 8;
int* out7 = func0(7);
assert(issame(out7, tri_7, size));
free(out7);
int tri_8[] = {1, 3, 2, 8, 3, 15, 4, 24, 5};
size = 9;
int* out8 = func0(8);
assert(issame(out8, tri_8, size));
free(out8);
int tri_9[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35};
size = 10;
int* out9 = func0(9);
assert(issame(out9, tri_9, size));
free(out9);
int tri_20[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11};
size = 21;
int* out20 = func0(20);
assert(issame(out20, tri_20, size));
free(out20);
int tri_0[] = {1};
size = 1;
int* out0 = func0(0);
assert(issame(out0, tri_0, size));
free(out0);
int tri_1[] = {1, 3};
size = 2;
int* out1 = func0(1);
assert(issame(out1, tri_1, size));
free(out1);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add $0x1,%eax
cltq
shl $0x2,%rax
mov %rax,%rdi
callq 10b0 <malloc@plt>
mov %rax,-0x8(%rbp)
mov -0x8(%rbp),%rax
movl $0x1,(%rax)
cmpl $0x0,-0x14(%rbp)
jne 11e9 <func0+0x40>
mov -0x8(%rbp),%rax
jmpq 12a4 <func0+0xfb>
mov -0x8(%rbp),%rax
add $0x4,%rax
movl $0x3,(%rax)
movl $0x2,-0xc(%rbp)
jmpq 1294 <func0+0xeb>
mov -0xc(%rbp),%eax
and $0x1,%eax
test %eax,%eax
jne 1236 <func0+0x8d>
mov -0xc(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%ecx
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
lea 0x1(%rcx),%edx
mov %edx,(%rax)
jmp 1290 <func0+0xe7>
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x4(%rax),%rdx
mov -0x8(%rbp),%rax
add %rdx,%rax
mov (%rax),%edx
mov -0xc(%rbp),%eax
cltq
shl $0x2,%rax
lea -0x8(%rax),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
mov (%rax),%eax
add %edx,%eax
lea 0x1(%rax),%edx
mov -0xc(%rbp),%eax
add $0x1,%eax
mov %eax,%ecx
shr $0x1f,%ecx
add %ecx,%eax
sar %eax
mov %eax,%esi
mov -0xc(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rcx
mov -0x8(%rbp),%rax
add %rcx,%rax
add %esi,%edx
mov %edx,(%rax)
addl $0x1,-0xc(%rbp)
mov -0xc(%rbp),%eax
cmp -0x14(%rbp),%eax
jle 1203 <func0+0x5a>
mov -0x8(%rbp),%rax
leaveq
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov eax, [rbp+var_14]
add eax, 1
cdqe
shl rax, 2
mov rdi, rax; size
call _malloc
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
mov dword ptr [rax], 1
cmp [rbp+var_14], 0
jnz short loc_11E9
mov rax, [rbp+var_8]
jmp locret_12A4
loc_11E9:
mov rax, [rbp+var_8]
add rax, 4
mov dword ptr [rax], 3
mov [rbp+var_C], 2
jmp loc_1294
loc_1203:
mov eax, [rbp+var_C]
and eax, 1
test eax, eax
jnz short loc_1236
mov eax, [rbp+var_C]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov ecx, eax
mov eax, [rbp+var_C]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rdx
lea edx, [rcx+1]
mov [rax], edx
jmp short loc_1290
loc_1236:
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rdx, [rax-4]
mov rax, [rbp+var_8]
add rax, rdx
mov edx, [rax]
mov eax, [rbp+var_C]
cdqe
shl rax, 2
lea rcx, [rax-8]
mov rax, [rbp+var_8]
add rax, rcx
mov eax, [rax]
add eax, edx
lea edx, [rax+1]
mov eax, [rbp+var_C]
add eax, 1
mov ecx, eax
shr ecx, 1Fh
add eax, ecx
sar eax, 1
mov esi, eax
mov eax, [rbp+var_C]
cdqe
lea rcx, ds:0[rax*4]
mov rax, [rbp+var_8]
add rax, rcx
add edx, esi
mov [rax], edx
loc_1290:
add [rbp+var_C], 1
loc_1294:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_14]
jle loc_1203
mov rax, [rbp+var_8]
locret_12A4:
leave
retn
|
_DWORD * func0(int a1)
{
int i; // [rsp+14h] [rbp-Ch]
_DWORD *v3; // [rsp+18h] [rbp-8h]
v3 = malloc(4LL * (a1 + 1));
*v3 = 1;
if ( !a1 )
return v3;
v3[1] = 3;
for ( i = 2; i <= a1; ++i )
{
if ( (i & 1) != 0 )
v3[i] = (i + 1) / 2 + v3[i - 1] + v3[i - 2] + 1;
else
v3[i] = i / 2 + 1;
}
return v3;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
CDQE
SHL RAX,0x2
MOV RDI,RAX
CALL 0x001010b0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX],0x1
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x001011e9
MOV RAX,qword ptr [RBP + -0x8]
JMP 0x001012a4
LAB_001011e9:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x4
MOV dword ptr [RAX],0x3
MOV dword ptr [RBP + -0xc],0x2
JMP 0x00101294
LAB_00101203:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
TEST EAX,EAX
JNZ 0x00101236
MOV EAX,dword ptr [RBP + -0xc]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
LEA EDX,[RCX + 0x1]
MOV dword ptr [RAX],EDX
JMP 0x00101290
LAB_00101236:
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RDX,[RAX + -0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RDX
MOV EDX,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0xc]
CDQE
SHL RAX,0x2
LEA RCX,[RAX + -0x8]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
ADD EAX,EDX
LEA EDX,[RAX + 0x1]
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,0x1
MOV ECX,EAX
SHR ECX,0x1f
ADD EAX,ECX
SAR EAX,0x1
MOV ESI,EAX
MOV EAX,dword ptr [RBP + -0xc]
CDQE
LEA RCX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,RCX
ADD EDX,ESI
MOV dword ptr [RAX],EDX
LAB_00101290:
ADD dword ptr [RBP + -0xc],0x1
LAB_00101294:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x14]
JLE 0x00101203
MOV RAX,qword ptr [RBP + -0x8]
LAB_001012a4:
LEAVE
RET
|
int4 * func0(int param_1)
{
int4 *puVar1;
uint local_14;
puVar1 = (int4 *)malloc((long)(param_1 + 1) << 2);
*puVar1 = 1;
if (param_1 != 0) {
puVar1[1] = 3;
for (local_14 = 2; (int)local_14 <= param_1; local_14 = local_14 + 1) {
if ((local_14 & 1) == 0) {
puVar1[(int)local_14] = (int)local_14 / 2 + 1;
}
else {
puVar1[(int)local_14] =
puVar1[(long)(int)local_14 + -2] + puVar1[(long)(int)local_14 + -1] + 1 +
(int)(local_14 + 1) / 2;
}
}
}
return puVar1;
}
|
1,177 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, tri_3, size));
free(out3);
int tri_4[] = {1, 3, 2, 8, 3};
size = 5;
int* out4 = func0(4);
assert(issame(out4, tri_4, size));
free(out4);
int tri_5[] = {1, 3, 2, 8, 3, 15};
size = 6;
int* out5 = func0(5);
assert(issame(out5, tri_5, size));
free(out5);
int tri_6[] = {1, 3, 2, 8, 3, 15, 4};
size = 7;
int* out6 = func0(6);
assert(issame(out6, tri_6, size));
free(out6);
int tri_7[] = {1, 3, 2, 8, 3, 15, 4, 24};
size = 8;
int* out7 = func0(7);
assert(issame(out7, tri_7, size));
free(out7);
int tri_8[] = {1, 3, 2, 8, 3, 15, 4, 24, 5};
size = 9;
int* out8 = func0(8);
assert(issame(out8, tri_8, size));
free(out8);
int tri_9[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35};
size = 10;
int* out9 = func0(9);
assert(issame(out9, tri_9, size));
free(out9);
int tri_20[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11};
size = 21;
int* out20 = func0(20);
assert(issame(out20, tri_20, size));
free(out20);
int tri_0[] = {1};
size = 1;
int* out0 = func0(0);
assert(issame(out0, tri_0, size));
free(out0);
int tri_1[] = {1, 3};
size = 2;
int* out1 = func0(1);
assert(issame(out1, tri_1, size));
free(out1);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
lea 0x1(%rdi),%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 121e <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 121e <func0+0x75>
lea -0x2(%rbx),%r8d
add $0x3,%r8
mov $0x2,%edx
jmp 1208 <func0+0x5f>
mov -0x8(%rax,%rdx,4),%esi
add -0x4(%rax,%rdx,4),%esi
lea 0x1(%rdx),%edi
mov %edi,%ecx
shr $0x1f,%ecx
add %edi,%ecx
sar %ecx
lea 0x1(%rsi,%rcx,1),%ecx
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %r8,%rdx
je 121e <func0+0x75>
test $0x1,%dl
jne 11e4 <func0+0x3b>
mov %edx,%ecx
shr $0x1f,%ecx
add %edx,%ecx
sar %ecx
add $0x1,%ecx
mov %ecx,(%rax,%rdx,4)
jmp 11ff <func0+0x56>
pop %rbx
retq
|
func0:
endbr64
push rbx
mov ebx, edi
lea edi, [rdi+1]
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_121A
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_121A
lea r8d, [rbx+1]
mov edx, 2
jmp short loc_1204
loc_11E0:
mov esi, [rax+rdx*4-8]
add esi, [rax+rdx*4-4]
lea edi, [rdx+1]
mov ecx, edi
shr ecx, 1Fh
add ecx, edi
sar ecx, 1
lea ecx, [rsi+rcx+1]
mov [rax+rdx*4], ecx
loc_11FB:
add rdx, 1
cmp rdx, r8
jz short loc_121A
loc_1204:
test dl, 1
jnz short loc_11E0
mov ecx, edx
shr ecx, 1Fh
add ecx, edx
sar ecx, 1
add ecx, 1
mov [rax+rdx*4], ecx
jmp short loc_11FB
loc_121A:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
long long v2; // rdx
int v3; // ecx
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v2 = 2LL;
do
{
if ( (v2 & 1) != 0 )
v3 = result[v2 - 1] + result[v2 - 2] + ((int)v2 + 1) / 2 + 1;
else
v3 = (int)v2 / 2 + 1;
result[v2++] = v3;
}
while ( v2 != a1 + 1 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
LEA EDI,[RDI + 0x1]
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010121a
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010121a
LEA R8D,[RBX + 0x1]
MOV EDX,0x2
JMP 0x00101204
LAB_001011e0:
MOV ESI,dword ptr [RAX + RDX*0x4 + -0x8]
ADD ESI,dword ptr [RAX + RDX*0x4 + -0x4]
LEA EDI,[RDX + 0x1]
MOV ECX,EDI
SHR ECX,0x1f
ADD ECX,EDI
SAR ECX,0x1
LEA ECX,[RSI + RCX*0x1 + 0x1]
MOV dword ptr [RAX + RDX*0x4],ECX
LAB_001011fb:
ADD RDX,0x1
CMP RDX,R8
JZ 0x0010121a
LAB_00101204:
TEST DL,0x1
JNZ 0x001011e0
MOV ECX,EDX
SHR ECX,0x1f
ADD ECX,EDX
SAR ECX,0x1
ADD ECX,0x1
MOV dword ptr [RAX + RDX*0x4],ECX
JMP 0x001011fb
LAB_0010121a:
POP RBX
RET
|
void func0(int param_1)
{
int4 *puVar1;
ulong uVar2;
puVar1 = (int4 *)malloc((long)(param_1 + 1) << 2);
*puVar1 = 1;
if ((param_1 != 0) && (puVar1[1] = 3, 1 < param_1)) {
uVar2 = 2;
do {
if ((uVar2 & 1) == 0) {
puVar1[uVar2] = ((int)(((uint)(uVar2 >> 0x1f) & 1) + (int)uVar2) >> 1) + 1;
}
else {
puVar1[uVar2] = puVar1[uVar2 - 2] + puVar1[uVar2 - 1] + 1 + ((int)uVar2 + 1) / 2;
}
uVar2 = uVar2 + 1;
} while (uVar2 != param_1 + 1);
}
return;
}
|
1,178 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, tri_3, size));
free(out3);
int tri_4[] = {1, 3, 2, 8, 3};
size = 5;
int* out4 = func0(4);
assert(issame(out4, tri_4, size));
free(out4);
int tri_5[] = {1, 3, 2, 8, 3, 15};
size = 6;
int* out5 = func0(5);
assert(issame(out5, tri_5, size));
free(out5);
int tri_6[] = {1, 3, 2, 8, 3, 15, 4};
size = 7;
int* out6 = func0(6);
assert(issame(out6, tri_6, size));
free(out6);
int tri_7[] = {1, 3, 2, 8, 3, 15, 4, 24};
size = 8;
int* out7 = func0(7);
assert(issame(out7, tri_7, size));
free(out7);
int tri_8[] = {1, 3, 2, 8, 3, 15, 4, 24, 5};
size = 9;
int* out8 = func0(8);
assert(issame(out8, tri_8, size));
free(out8);
int tri_9[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35};
size = 10;
int* out9 = func0(9);
assert(issame(out9, tri_9, size));
free(out9);
int tri_20[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11};
size = 21;
int* out20 = func0(20);
assert(issame(out20, tri_20, size));
free(out20);
int tri_0[] = {1};
size = 1;
int* out0 = func0(0);
assert(issame(out0, tri_0, size));
free(out0);
int tri_1[] = {1, 3};
size = 2;
int* out1 = func0(1);
assert(issame(out1, tri_1, size));
free(out1);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 17a5 <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 17a5 <func0+0x75>
lea -0x2(%rbx),%edi
mov $0x2,%edx
add $0x3,%rdi
jmp 1783 <func0+0x53>
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
sar %ecx
add $0x1,%ecx
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %rdi,%rdx
je 17a5 <func0+0x75>
lea 0x1(%rdx),%ecx
test $0x1,%dl
je 1770 <func0+0x40>
mov -0x8(%rax,%rdx,4),%esi
sar %ecx
add -0x4(%rax,%rdx,4),%esi
lea 0x1(%rsi,%rcx,1),%ecx
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %rdi,%rdx
jne 1783 <func0+0x53>
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
mov ebx, edi
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_169B
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_169B
mov rcx, rax
mov edx, 2
jmp short loc_1672
loc_1660:
mov edi, esi
add rcx, 4
sar edi, 1
add edi, 1
mov [rcx+4], edi
cmp ebx, esi
jz short loc_169B
loc_1672:
mov edi, edx
mov esi, edx
add edx, 1
and edi, 1
test edi, edi
jz short loc_1660
mov r8d, edx
mov edi, [rcx]
add edi, [rcx+4]
add rcx, 4
sar r8d, 1
lea edi, [rdi+r8+1]
mov [rcx+4], edi
cmp ebx, esi
jnz short loc_1672
loc_169B:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v3; // rcx
int v4; // edx
char v5; // di
int v6; // esi
int v7; // edi
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v3 = result;
v4 = 2;
do
{
while ( 1 )
{
v5 = v4;
v6 = v4++;
if ( (v5 & 1) != 0 )
break;
++v3;
v3[1] = (v6 >> 1) + 1;
if ( a1 == v6 )
return result;
}
v7 = v3[1] + *v3;
++v3;
v3[1] = v7 + (v4 >> 1) + 1;
}
while ( a1 != v6 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010169b
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010169b
MOV RCX,RAX
MOV EDX,0x2
JMP 0x00101672
LAB_00101660:
MOV EDI,ESI
ADD RCX,0x4
SAR EDI,0x1
ADD EDI,0x1
MOV dword ptr [RCX + 0x4],EDI
CMP EBX,ESI
JZ 0x0010169b
LAB_00101672:
MOV EDI,EDX
MOV ESI,EDX
ADD EDX,0x1
AND EDI,0x1
TEST EDI,EDI
JZ 0x00101660
MOV R8D,EDX
MOV EDI,dword ptr [RCX]
ADD EDI,dword ptr [RCX + 0x4]
ADD RCX,0x4
SAR R8D,0x1
LEA EDI,[RDI + R8*0x1 + 0x1]
MOV dword ptr [RCX + 0x4],EDI
CMP EBX,ESI
JNZ 0x00101672
LAB_0010169b:
POP RBX
RET
|
void func0(uint param_1)
{
int *piVar1;
uint uVar2;
uint uVar3;
bool bVar4;
piVar1 = (int *)malloc((long)(int)(param_1 + 1) << 2);
*piVar1 = 1;
if ((param_1 != 0) && (piVar1[1] = 3, 1 < (int)param_1)) {
uVar2 = 2;
do {
while (uVar3 = uVar2 + 1, (uVar2 & 1) != 0) {
piVar1[2] = *piVar1 + piVar1[1] + 1 + ((int)uVar3 >> 1);
bVar4 = param_1 == uVar2;
piVar1 = piVar1 + 1;
uVar2 = uVar3;
if (bVar4) {
return;
}
}
piVar1[2] = ((int)uVar2 >> 1) + 1;
bVar4 = param_1 != uVar2;
piVar1 = piVar1 + 1;
uVar2 = uVar3;
} while (bVar4);
}
return;
}
|
1,179 |
func0
|
#include <stdio.h>
#include <stdlib.h>
|
int* func0(int n) {
int* out = (int*)malloc((n + 1) * sizeof(int));
out[0] = 1;
if (n == 0) return out;
out[1] = 3;
for (int i = 2; i <= n; i++) {
if (i % 2 == 0) out[i] = 1 + i / 2;
else out[i] = out[i - 1] + out[i - 2] + 1 + (i + 1) / 2;
}
return out;
}
|
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
int issame(int* a, int* b, int size) {
for (int i = 0; i < size; i++) {
if (a[i] != b[i]) return 0;
}
return 1;
}
int main() {
int size;
int tri_3[] = {1, 3, 2, 8};
size = 4;
int* out3 = func0(3);
assert(issame(out3, tri_3, size));
free(out3);
int tri_4[] = {1, 3, 2, 8, 3};
size = 5;
int* out4 = func0(4);
assert(issame(out4, tri_4, size));
free(out4);
int tri_5[] = {1, 3, 2, 8, 3, 15};
size = 6;
int* out5 = func0(5);
assert(issame(out5, tri_5, size));
free(out5);
int tri_6[] = {1, 3, 2, 8, 3, 15, 4};
size = 7;
int* out6 = func0(6);
assert(issame(out6, tri_6, size));
free(out6);
int tri_7[] = {1, 3, 2, 8, 3, 15, 4, 24};
size = 8;
int* out7 = func0(7);
assert(issame(out7, tri_7, size));
free(out7);
int tri_8[] = {1, 3, 2, 8, 3, 15, 4, 24, 5};
size = 9;
int* out8 = func0(8);
assert(issame(out8, tri_8, size));
free(out8);
int tri_9[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35};
size = 10;
int* out9 = func0(9);
assert(issame(out9, tri_9, size));
free(out9);
int tri_20[] = {1, 3, 2, 8, 3, 15, 4, 24, 5, 35, 6, 48, 7, 63, 8, 80, 9, 99, 10, 120, 11};
size = 21;
int* out20 = func0(20);
assert(issame(out20, tri_20, size));
free(out20);
int tri_0[] = {1};
size = 1;
int* out0 = func0(0);
assert(issame(out0, tri_0, size));
free(out0);
int tri_1[] = {1, 3};
size = 2;
int* out1 = func0(1);
assert(issame(out1, tri_1, size));
free(out1);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %edi,%ebx
add $0x1,%edi
movslq %edi,%rdi
shl $0x2,%rdi
callq 10b0 <malloc@plt>
movl $0x1,(%rax)
test %ebx,%ebx
je 1825 <func0+0x75>
movl $0x3,0x4(%rax)
cmp $0x1,%ebx
jle 1825 <func0+0x75>
lea -0x2(%rbx),%edi
mov $0x2,%edx
add $0x3,%rdi
jmp 1803 <func0+0x53>
nopw 0x0(%rax,%rax,1)
mov %edx,%ecx
sar %ecx
add $0x1,%ecx
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %rdx,%rdi
je 1825 <func0+0x75>
lea 0x1(%rdx),%ecx
test $0x1,%dl
je 17f0 <func0+0x40>
mov -0x8(%rax,%rdx,4),%esi
sar %ecx
add -0x4(%rax,%rdx,4),%esi
lea 0x1(%rsi,%rcx,1),%ecx
mov %ecx,(%rax,%rdx,4)
add $0x1,%rdx
cmp %rdx,%rdi
jne 1803 <func0+0x53>
pop %rbx
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
push rbx
mov ebx, edi
add edi, 1
movsxd rdi, edi
shl rdi, 2; size
call _malloc
mov dword ptr [rax], 1
test ebx, ebx
jz short loc_168B
mov dword ptr [rax+4], 3
cmp ebx, 1
jle short loc_168B
mov rcx, rax
mov edx, 2
jmp short loc_1662
loc_1650:
mov edi, esi
add rcx, 4
sar edi, 1
add edi, 1
mov [rcx+4], edi
cmp ebx, esi
jz short loc_168B
loc_1662:
mov edi, edx
mov esi, edx
add edx, 1
and edi, 1
test edi, edi
jz short loc_1650
mov r8d, edx
mov edi, [rcx]
add edi, [rcx+4]
add rcx, 4
sar r8d, 1
lea edi, [rdi+r8+1]
mov [rcx+4], edi
cmp ebx, esi
jnz short loc_1662
loc_168B:
pop rbx
retn
|
_DWORD * func0(int a1)
{
_DWORD *result; // rax
_DWORD *v3; // rcx
int v4; // edx
char v5; // di
int v6; // esi
int v7; // edi
result = malloc(4LL * (a1 + 1));
*result = 1;
if ( a1 )
{
result[1] = 3;
if ( a1 > 1 )
{
v3 = result;
v4 = 2;
do
{
while ( 1 )
{
v5 = v4;
v6 = v4++;
if ( (v5 & 1) != 0 )
break;
++v3;
v3[1] = (v6 >> 1) + 1;
if ( a1 == v6 )
return result;
}
v7 = v3[1] + *v3;
++v3;
v3[1] = v7 + (v4 >> 1) + 1;
}
while ( a1 != v6 );
}
}
return result;
}
|
func0:
ENDBR64
PUSH RBX
MOV EBX,EDI
ADD EDI,0x1
MOVSXD RDI,EDI
SHL RDI,0x2
CALL 0x001010b0
MOV dword ptr [RAX],0x1
TEST EBX,EBX
JZ 0x0010168b
MOV dword ptr [RAX + 0x4],0x3
CMP EBX,0x1
JLE 0x0010168b
MOV RCX,RAX
MOV EDX,0x2
JMP 0x00101662
LAB_00101650:
MOV EDI,ESI
ADD RCX,0x4
SAR EDI,0x1
ADD EDI,0x1
MOV dword ptr [RCX + 0x4],EDI
CMP EBX,ESI
JZ 0x0010168b
LAB_00101662:
MOV EDI,EDX
MOV ESI,EDX
ADD EDX,0x1
AND EDI,0x1
TEST EDI,EDI
JZ 0x00101650
MOV R8D,EDX
MOV EDI,dword ptr [RCX]
ADD EDI,dword ptr [RCX + 0x4]
ADD RCX,0x4
SAR R8D,0x1
LEA EDI,[RDI + R8*0x1 + 0x1]
MOV dword ptr [RCX + 0x4],EDI
CMP EBX,ESI
JNZ 0x00101662
LAB_0010168b:
POP RBX
RET
|
void func0(uint param_1)
{
int *piVar1;
uint uVar2;
uint uVar3;
bool bVar4;
piVar1 = (int *)malloc((long)(int)(param_1 + 1) << 2);
*piVar1 = 1;
if ((param_1 != 0) && (piVar1[1] = 3, 1 < (int)param_1)) {
uVar2 = 2;
do {
while (uVar3 = uVar2 + 1, (uVar2 & 1) != 0) {
piVar1[2] = *piVar1 + piVar1[1] + 1 + ((int)uVar3 >> 1);
bVar4 = param_1 == uVar2;
piVar1 = piVar1 + 1;
uVar2 = uVar3;
if (bVar4) {
return;
}
}
piVar1[2] = ((int)uVar2 >> 1) + 1;
bVar4 = param_1 != uVar2;
piVar1 = piVar1 + 1;
uVar2 = uVar3;
} while (bVar4);
}
return;
}
|
1,180 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
}
|
#include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x1,-0xc(%rbp)
movl $0x0,-0x8(%rbp)
jmp 11d3 <func0+0x8a>
mov -0x14(%rbp),%edx
movslq %edx,%rax
imul $0x66666667,%rax,%rax
shr $0x20,%rax
mov %eax,%ecx
sar $0x2,%ecx
mov %edx,%eax
sar $0x1f,%eax
sub %eax,%ecx
mov %ecx,%eax
shl $0x2,%eax
add %ecx,%eax
add %eax,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
cltd
shr $0x1f,%edx
add %edx,%eax
and $0x1,%eax
sub %edx,%eax
cmp $0x1,%eax
jne 11b5 <func0+0x6c>
movl $0x1,-0x8(%rbp)
mov -0xc(%rbp),%eax
imul -0x4(%rbp),%eax
mov %eax,-0xc(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
imul $0x66666667,%rdx,%rdx
shr $0x20,%rdx
sar $0x2,%edx
sar $0x1f,%eax
sub %eax,%edx
mov %edx,%eax
mov %eax,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jg 1164 <func0+0x1b>
cmpl $0x0,-0x8(%rbp)
je 11e4 <func0+0x9b>
mov -0xc(%rbp),%eax
jmp 11e9 <func0+0xa0>
mov $0x0,%eax
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_C], 1
mov [rbp+var_8], 0
jmp short loc_11D7
loc_1164:
mov edx, [rbp+var_14]
movsxd rax, edx
imul rax, 66666667h
shr rax, 20h
mov ecx, eax
sar ecx, 2
mov eax, edx
sar eax, 1Fh
sub ecx, eax
mov eax, ecx
shl eax, 2
add eax, ecx
add eax, eax
sub edx, eax
mov [rbp+var_4], edx
mov edx, [rbp+var_4]
mov eax, edx
sar eax, 1Fh
shr eax, 1Fh
add edx, eax
and edx, 1
sub edx, eax
mov eax, edx
cmp eax, 1
jnz short loc_11B9
mov [rbp+var_8], 1
mov eax, [rbp+var_C]
imul eax, [rbp+var_4]
mov [rbp+var_C], eax
loc_11B9:
mov eax, [rbp+var_14]
movsxd rdx, eax
imul rdx, 66666667h
shr rdx, 20h
mov ecx, edx
sar ecx, 2
cdq
mov eax, ecx
sub eax, edx
mov [rbp+var_14], eax
loc_11D7:
cmp [rbp+var_14], 0
jg short loc_1164
cmp [rbp+var_8], 0
jz short loc_11E8
mov eax, [rbp+var_C]
jmp short loc_11ED
loc_11E8:
mov eax, 0
loc_11ED:
pop rbp
retn
|
long long func0(int a1)
{
unsigned int v3; // [rsp+8h] [rbp-Ch]
int v4; // [rsp+Ch] [rbp-8h]
v3 = 1;
v4 = 0;
while ( a1 > 0 )
{
if ( a1 % 10 % 2 == 1 )
{
v4 = 1;
v3 *= a1 % 10;
}
a1 /= 10;
}
if ( v4 )
return v3;
else
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0xc],0x1
MOV dword ptr [RBP + -0x8],0x0
JMP 0x001011d7
LAB_00101164:
MOV EDX,dword ptr [RBP + -0x14]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SHR RAX,0x20
MOV ECX,EAX
SAR ECX,0x2
MOV EAX,EDX
SAR EAX,0x1f
SUB ECX,EAX
MOV EAX,ECX
SHL EAX,0x2
ADD EAX,ECX
ADD EAX,EAX
SUB EDX,EAX
MOV dword ptr [RBP + -0x4],EDX
MOV EDX,dword ptr [RBP + -0x4]
MOV EAX,EDX
SAR EAX,0x1f
SHR EAX,0x1f
ADD EDX,EAX
AND EDX,0x1
SUB EDX,EAX
MOV EAX,EDX
CMP EAX,0x1
JNZ 0x001011b9
MOV dword ptr [RBP + -0x8],0x1
MOV EAX,dword ptr [RBP + -0xc]
IMUL EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0xc],EAX
LAB_001011b9:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
IMUL RDX,RDX,0x66666667
SHR RDX,0x20
MOV ECX,EDX
SAR ECX,0x2
CDQ
MOV EAX,ECX
SUB EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
LAB_001011d7:
CMP dword ptr [RBP + -0x14],0x0
JG 0x00101164
CMP dword ptr [RBP + -0x8],0x0
JZ 0x001011e8
MOV EAX,dword ptr [RBP + -0xc]
JMP 0x001011ed
LAB_001011e8:
MOV EAX,0x0
LAB_001011ed:
POP RBP
RET
|
int func0(int param_1)
{
bool bVar1;
int4 local_1c;
int4 local_14;
local_14 = 1;
bVar1 = false;
for (local_1c = param_1; 0 < local_1c; local_1c = local_1c / 10) {
if ((local_1c % 10) % 2 == 1) {
bVar1 = true;
local_14 = local_14 * (local_1c % 10);
}
}
if (!bVar1) {
local_14 = 0;
}
return local_14;
}
|
1,181 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
}
|
#include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %edi,%edi
jle 11be <func0+0x75>
mov $0x0,%esi
mov $0x1,%ecx
jmp 1179 <func0+0x30>
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
cmp $0x9,%edi
jle 11b6 <func0+0x6d>
mov %eax,%edi
movslq %edi,%rax
imul $0x66666667,%rax,%rax
sar $0x22,%rax
mov %edi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%rax,4),%eax
add %eax,%eax
mov %edi,%edx
sub %eax,%edx
mov %edx,%eax
mov %edx,%r8d
shr $0x1f,%r8d
lea (%rdx,%r8,1),%edx
and $0x1,%edx
sub %r8d,%edx
cmp $0x1,%edx
jne 115d <func0+0x14>
imul %eax,%ecx
mov %edx,%esi
jmp 115d <func0+0x14>
test %esi,%esi
cmove %esi,%ecx
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 11bb <func0+0x72>
|
func0:
endbr64
mov edx, edi
test edi, edi
jle short loc_11BE
mov esi, 0
mov edi, 1
jmp short loc_117B
loc_115F:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
cmp edx, 9
jle short loc_11B6
mov edx, eax
loc_117B:
movsxd rax, edx
imul rax, 66666667h
sar rax, 22h
mov ecx, edx
sar ecx, 1Fh
sub eax, ecx
lea ecx, [rax+rax*4]
add ecx, ecx
mov eax, edx
sub eax, ecx
mov r8d, eax
shr r8d, 1Fh
lea ecx, [rax+r8]
and ecx, 1
sub ecx, r8d
cmp ecx, 1
jnz short loc_115F
imul edi, eax
mov esi, ecx
jmp short loc_115F
loc_11B6:
test esi, esi
cmovnz esi, edi
loc_11BB:
mov eax, esi
retn
loc_11BE:
mov esi, 0
jmp short loc_11BB
|
long long func0(int a1)
{
int v1; // edx
unsigned int v2; // esi
unsigned int v3; // edi
v1 = a1;
if ( a1 <= 0 )
{
return 0;
}
else
{
v2 = 0;
v3 = 1;
while ( 1 )
{
if ( v1 % 10 % 2 == 1 )
{
v3 *= v1 % 10;
v2 = 1;
}
if ( v1 <= 9 )
break;
v1 /= 10;
}
if ( v2 )
return v3;
}
return v2;
}
|
func0:
ENDBR64
MOV EDX,EDI
TEST EDI,EDI
JLE 0x001011be
MOV ESI,0x0
MOV EDI,0x1
JMP 0x0010117b
LAB_0010115f:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
CMP EDX,0x9
JLE 0x001011b6
MOV EDX,EAX
LAB_0010117b:
MOVSXD RAX,EDX
IMUL RAX,RAX,0x66666667
SAR RAX,0x22
MOV ECX,EDX
SAR ECX,0x1f
SUB EAX,ECX
LEA ECX,[RAX + RAX*0x4]
ADD ECX,ECX
MOV EAX,EDX
SUB EAX,ECX
MOV R8D,EAX
SHR R8D,0x1f
LEA ECX,[RAX + R8*0x1]
AND ECX,0x1
SUB ECX,R8D
CMP ECX,0x1
JNZ 0x0010115f
IMUL EDI,EAX
MOV ESI,ECX
JMP 0x0010115f
LAB_001011b6:
TEST ESI,ESI
CMOVNZ ESI,EDI
LAB_001011bb:
MOV EAX,ESI
RET
LAB_001011be:
MOV ESI,0x0
JMP 0x001011bb
|
int func0(int param_1)
{
bool bVar1;
int iVar2;
int iVar3;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar2 = 0;
iVar3 = 1;
do {
if ((param_1 % 10) % 2 == 1) {
iVar3 = iVar3 * (param_1 % 10);
iVar2 = 1;
}
bVar1 = 9 < param_1;
param_1 = param_1 / 10;
} while (bVar1);
if (iVar2 != 0) {
iVar2 = iVar3;
}
}
return iVar2;
}
|
1,182 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
}
|
#include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
xor %r9d,%r9d
test %edi,%edi
jle 136c <func0+0x5c>
mov $0x1,%r8d
mov $0xcccccccd,%ecx
jmp 1332 <func0+0x22>
nopl 0x0(%rax,%rax,1)
mov %eax,%edi
mov %edi,%eax
mov %edi,%esi
mov %rax,%rdx
imul %rcx,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%esi
mov %esi,%edx
mov %edi,%esi
and $0x1,%esi
je 1358 <func0+0x48>
imul %edx,%r8d
mov %esi,%r9d
imul %rcx,%rax
shr $0x23,%rax
cmp $0x9,%edi
jg 1330 <func0+0x20>
test %r9d,%r9d
cmovne %r8d,%r9d
mov %r9d,%eax
retq
|
func0:
endbr64
test edi, edi
jle short loc_1320
xor r9d, r9d
mov r8d, 1
mov esi, 0CCCCCCCDh
jmp short loc_12E2
loc_12E0:
mov edi, eax
loc_12E2:
mov eax, edi
mov rdx, rax
imul rdx, rsi
shr rdx, 23h
lea ecx, [rdx+rdx*4]
mov edx, edi
add ecx, ecx
sub edx, ecx
mov ecx, edi
and ecx, 1
jz short loc_1306
imul r8d, edx
mov r9d, ecx
loc_1306:
imul rax, rsi
shr rax, 23h
cmp edi, 9
jg short loc_12E0
xor eax, eax
test r9d, r9d
cmovz r8d, eax
mov eax, r8d
retn
loc_1320:
xor r8d, r8d
mov eax, r8d
retn
|
long long func0(int a1)
{
int v1; // r9d
unsigned int v2; // r8d
if ( a1 <= 0 )
return 0LL;
v1 = 0;
v2 = 1;
while ( 1 )
{
if ( (a1 & 1) != 0 )
{
v2 *= a1 % 0xAu;
v1 = a1 & 1;
}
if ( a1 <= 9 )
break;
a1 /= 0xAu;
}
if ( !v1 )
return 0;
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101320
XOR R9D,R9D
MOV R8D,0x1
MOV ESI,0xcccccccd
JMP 0x001012e2
LAB_001012e0:
MOV EDI,EAX
LAB_001012e2:
MOV EAX,EDI
MOV RDX,RAX
IMUL RDX,RSI
SHR RDX,0x23
LEA ECX,[RDX + RDX*0x4]
MOV EDX,EDI
ADD ECX,ECX
SUB EDX,ECX
MOV ECX,EDI
AND ECX,0x1
JZ 0x00101306
IMUL R8D,EDX
MOV R9D,ECX
LAB_00101306:
IMUL RAX,RSI
SHR RAX,0x23
CMP EDI,0x9
JG 0x001012e0
XOR EAX,EAX
TEST R9D,R9D
CMOVZ R8D,EAX
MOV EAX,R8D
RET
LAB_00101320:
XOR R8D,R8D
MOV EAX,R8D
RET
|
int func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
if ((int)param_1 < 1) {
return 0;
}
uVar3 = 0;
iVar2 = 1;
do {
if ((param_1 & 1) != 0) {
iVar2 = iVar2 * (param_1 % 10);
uVar3 = param_1 & 1;
}
bVar1 = 9 < (int)param_1;
param_1 = param_1 / 10;
} while (bVar1);
if (uVar3 == 0) {
iVar2 = 0;
}
return iVar2;
}
|
1,183 |
func0
|
#include <stdio.h>
|
int func0(int n) {
int prod = 1, has_odd = 0, digit;
while (n > 0) {
digit = n % 10;
if (digit % 2 == 1) {
has_odd = 1;
prod *= digit;
}
n /= 10;
}
return has_odd ? prod : 0;
}
|
#include <assert.h>
int main(){
assert(func0(5) == 5);
assert(func0(54) == 5);
assert(func0(120) == 1);
assert(func0(5014) == 5);
assert(func0(98765) == 315);
assert(func0(5576543) == 2625);
assert(func0(2468) == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
xor %r9d,%r9d
test %edi,%edi
jle 12dc <func0+0x5c>
mov $0x1,%r8d
mov $0xcccccccd,%ecx
jmp 12a2 <func0+0x22>
nopl 0x0(%rax,%rax,1)
mov %eax,%edi
mov %edi,%eax
mov %edi,%esi
mov %rax,%rdx
imul %rcx,%rdx
shr $0x23,%rdx
lea (%rdx,%rdx,4),%edx
add %edx,%edx
sub %edx,%esi
mov %esi,%edx
mov %edi,%esi
and $0x1,%esi
je 12c8 <func0+0x48>
imul %edx,%r8d
mov %esi,%r9d
imul %rcx,%rax
shr $0x23,%rax
cmp $0x9,%edi
jg 12a0 <func0+0x20>
test %r9d,%r9d
cmovne %r8d,%r9d
mov %r9d,%eax
retq
|
func0:
endbr64
test edi, edi
jle short loc_12F0
xor r9d, r9d
mov r8d, 1
mov esi, 0CCCCCCCDh
jmp short loc_12B2
loc_12B0:
mov edi, eax
loc_12B2:
mov eax, edi
mov rdx, rax
imul rdx, rsi
shr rdx, 23h
lea ecx, [rdx+rdx*4]
mov edx, edi
add ecx, ecx
sub edx, ecx
mov ecx, edi
and ecx, 1
jz short loc_12D6
imul r8d, edx
mov r9d, ecx
loc_12D6:
imul rax, rsi
shr rax, 23h
cmp edi, 9
jg short loc_12B0
xor eax, eax
test r9d, r9d
cmovz r8d, eax
mov eax, r8d
retn
loc_12F0:
xor r8d, r8d
mov eax, r8d
retn
|
long long func0(int a1)
{
int v1; // r9d
unsigned int v2; // r8d
if ( a1 <= 0 )
return 0LL;
v1 = 0;
v2 = 1;
while ( 1 )
{
if ( (a1 & 1) != 0 )
{
v2 *= a1 % 0xAu;
v1 = a1 & 1;
}
if ( a1 <= 9 )
break;
a1 /= 0xAu;
}
if ( !v1 )
return 0;
return v2;
}
|
func0:
ENDBR64
TEST EDI,EDI
JLE 0x001012f0
XOR R9D,R9D
MOV R8D,0x1
MOV ESI,0xcccccccd
JMP 0x001012b2
LAB_001012b0:
MOV EDI,EAX
LAB_001012b2:
MOV EAX,EDI
MOV RDX,RAX
IMUL RDX,RSI
SHR RDX,0x23
LEA ECX,[RDX + RDX*0x4]
MOV EDX,EDI
ADD ECX,ECX
SUB EDX,ECX
MOV ECX,EDI
AND ECX,0x1
JZ 0x001012d6
IMUL R8D,EDX
MOV R9D,ECX
LAB_001012d6:
IMUL RAX,RSI
SHR RAX,0x23
CMP EDI,0x9
JG 0x001012b0
XOR EAX,EAX
TEST R9D,R9D
CMOVZ R8D,EAX
MOV EAX,R8D
RET
LAB_001012f0:
XOR R8D,R8D
MOV EAX,R8D
RET
|
int func0(uint param_1)
{
bool bVar1;
int iVar2;
uint uVar3;
if ((int)param_1 < 1) {
return 0;
}
uVar3 = 0;
iVar2 = 1;
do {
if ((param_1 & 1) != 0) {
iVar2 = iVar2 * (param_1 % 10);
uVar3 = param_1 & 1;
}
bVar1 = 9 < (int)param_1;
param_1 = param_1 / 10;
} while (bVar1);
if (uVar3 == 0) {
iVar2 = 0;
}
return iVar2;
}
|
1,184 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
return 0;
}
|
#include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert(func0("[[]") == 0);
assert(func0("[]]") == 0);
assert(func0("[[]][[") == 1);
assert(func0("[[][]]") == 1);
assert(func0("") == 0);
assert(func0("[[[[[[[[") == 0);
assert(func0("]]]]]]]]") == 0);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
movl $0x0,-0x1c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 11f2 <func0+0x89>
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5b,%al
jne 11a9 <func0+0x40>
addl $0x1,-0x1c(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
cmp $0x5d,%al
jne 11c1 <func0+0x58>
subl $0x1,-0x1c(%rbp)
cmpl $0x0,-0x1c(%rbp)
jns 11ce <func0+0x65>
movl $0x0,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 11dc <func0+0x73>
mov -0x1c(%rbp),%eax
mov %eax,-0x18(%rbp)
mov -0x18(%rbp),%eax
sub $0x1,%eax
cmp %eax,-0x1c(%rbp)
jge 11ee <func0+0x85>
mov $0x1,%eax
jmp 120e <func0+0xa5>
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
movslq %eax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1060 <strlen@plt>
cmp %rax,%rbx
jb 1191 <func0+0x28>
mov $0x0,%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+s], rdi
mov [rbp+var_1C], 0
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_11F2
loc_1191:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 5Bh ; '['
jnz short loc_11A9
add [rbp+var_1C], 1
loc_11A9:
mov eax, [rbp+var_14]
movsxd rdx, eax
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
cmp al, 5Dh ; ']'
jnz short loc_11C1
sub [rbp+var_1C], 1
loc_11C1:
cmp [rbp+var_1C], 0
jns short loc_11CE
mov [rbp+var_1C], 0
loc_11CE:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_18]
jle short loc_11DC
mov eax, [rbp+var_1C]
mov [rbp+var_18], eax
loc_11DC:
mov eax, [rbp+var_18]
sub eax, 1
cmp [rbp+var_1C], eax
jge short loc_11EE
mov eax, 1
jmp short loc_120E
loc_11EE:
add [rbp+var_14], 1
loc_11F2:
mov eax, [rbp+var_14]
movsxd rbx, eax
mov rax, [rbp+s]
mov rdi, rax; s
call _strlen
cmp rbx, rax
jb short loc_1191
mov eax, 0
loc_120E:
mov rbx, [rbp+var_8]
leave
retn
|
long long func0(const char *a1)
{
int v2; // [rsp+14h] [rbp-1Ch]
int v3; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v2 = 0;
v3 = 0;
for ( i = 0; i < strlen(a1); ++i )
{
if ( a1[i] == 91 )
++v2;
if ( a1[i] == 93 )
--v2;
if ( v2 < 0 )
v2 = 0;
if ( v2 > v3 )
v3 = v2;
if ( v2 < v3 - 1 )
return 1LL;
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x1c],0x0
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x001011f2
LAB_00101191:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x5b
JNZ 0x001011a9
ADD dword ptr [RBP + -0x1c],0x1
LAB_001011a9:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
CMP AL,0x5d
JNZ 0x001011c1
SUB dword ptr [RBP + -0x1c],0x1
LAB_001011c1:
CMP dword ptr [RBP + -0x1c],0x0
JNS 0x001011ce
MOV dword ptr [RBP + -0x1c],0x0
LAB_001011ce:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x001011dc
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x18],EAX
LAB_001011dc:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
CMP dword ptr [RBP + -0x1c],EAX
JGE 0x001011ee
MOV EAX,0x1
JMP 0x0010120e
LAB_001011ee:
ADD dword ptr [RBP + -0x14],0x1
LAB_001011f2:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RBX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101060
CMP RBX,RAX
JC 0x00101191
MOV EAX,0x0
LAB_0010120e:
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int8 func0(char *param_1)
{
size_t sVar1;
int local_24;
int local_20;
int local_1c;
local_24 = 0;
local_20 = 0;
local_1c = 0;
while( true ) {
sVar1 = strlen(param_1);
if (sVar1 <= (ulong)(long)local_1c) {
return 0;
}
if (param_1[local_1c] == '[') {
local_24 = local_24 + 1;
}
if (param_1[local_1c] == ']') {
local_24 = local_24 + -1;
}
if (local_24 < 0) {
local_24 = 0;
}
if (local_20 < local_24) {
local_20 = local_24;
}
if (local_24 < local_20 + -1) break;
local_1c = local_1c + 1;
}
return 1;
}
|
1,185 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
return 0;
}
|
#include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert(func0("[[]") == 0);
assert(func0("[]]") == 0);
assert(func0("[[]][[") == 1);
assert(func0("[[][]]") == 1);
assert(func0("") == 0);
assert(func0("[[[[[[[[") == 0);
assert(func0("]]]]]]]]") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
mov %rdi,%rsi
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
mov %rsi,%rdx
lea -0x1(%rsi,%rcx,1),%rdi
mov $0x0,%ecx
mov $0x0,%eax
mov $0x0,%r8d
jmp 119f <func0+0x56>
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%eax
test %eax,%eax
cmovs %r8d,%eax
cmp %eax,%ecx
cmovl %eax,%ecx
add $0x1,%rdx
lea -0x1(%rcx),%esi
cmp %esi,%eax
jl 11b8 <func0+0x6f>
cmp %rdi,%rdx
je 11b2 <func0+0x69>
movzbl (%rdx),%esi
cmp $0x5b,%sil
jne 117b <func0+0x32>
add $0x1,%eax
jmp 1189 <func0+0x40>
mov $0x0,%eax
retq
mov $0x1,%eax
retq
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdx, rbx
lea rdi, [rbx+rax]
mov ecx, 0
mov eax, 0
jmp short loc_11A6
loc_1189:
add eax, 1
loc_118C:
test eax, eax
mov esi, 0
cmovs eax, esi
cmp ecx, eax
cmovl ecx, eax
add rdx, 1
lea esi, [rcx-1]
cmp eax, esi
jl short loc_11CB
loc_11A6:
cmp rdx, rdi
jz short loc_11C4
movzx esi, byte ptr [rdx]
cmp sil, 5Bh ; '['
jz short loc_1189
cmp sil, 5Dh ; ']'
setz sil
movzx esi, sil
sub eax, esi
jmp short loc_118C
loc_11C4:
mov eax, 0
loc_11C9:
pop rbx
retn
loc_11CB:
mov eax, 1
jmp short loc_11C9
|
long long func0(const char *a1)
{
size_t v1; // rax
const char *v2; // rdx
const char *v3; // rdi
int v4; // ecx
int v5; // eax
v1 = strlen(a1);
v2 = a1;
v3 = &a1[v1];
v4 = 0;
v5 = 0;
do
{
if ( v2 == v3 )
return 0LL;
if ( *v2 == 91 )
++v5;
else
v5 -= *v2 == 93;
if ( v5 < 0 )
v5 = 0;
if ( v4 < v5 )
v4 = v5;
++v2;
}
while ( v5 >= v4 - 1 );
return 1LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDX,RBX
LEA RDI,[RBX + RAX*0x1]
MOV ECX,0x0
MOV EAX,0x0
JMP 0x001011a6
LAB_00101189:
ADD EAX,0x1
LAB_0010118c:
TEST EAX,EAX
MOV ESI,0x0
CMOVS EAX,ESI
CMP ECX,EAX
CMOVL ECX,EAX
ADD RDX,0x1
LEA ESI,[RCX + -0x1]
CMP EAX,ESI
JL 0x001011cb
LAB_001011a6:
CMP RDX,RDI
JZ 0x001011c4
MOVZX ESI,byte ptr [RDX]
CMP SIL,0x5b
JZ 0x00101189
CMP SIL,0x5d
SETZ SIL
MOVZX ESI,SIL
SUB EAX,ESI
JMP 0x0010118c
LAB_001011c4:
MOV EAX,0x0
LAB_001011c9:
POP RBX
RET
LAB_001011cb:
MOV EAX,0x1
JMP 0x001011c9
|
int8 func0(char *param_1)
{
char *pcVar1;
int iVar2;
size_t sVar3;
int iVar4;
sVar3 = strlen(param_1);
pcVar1 = param_1 + sVar3;
iVar4 = 0;
iVar2 = 0;
do {
if (param_1 == pcVar1) {
return 0;
}
if (*param_1 == '[') {
iVar2 = iVar2 + 1;
}
else {
iVar2 = iVar2 - (uint)(*param_1 == ']');
}
if (iVar2 < 0) {
iVar2 = 0;
}
if (iVar4 < iVar2) {
iVar4 = iVar2;
}
param_1 = param_1 + 1;
} while (iVar4 + -1 <= iVar2);
return 1;
}
|
1,186 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
return 0;
}
|
#include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert(func0("[[]") == 0);
assert(func0("[]]") == 0);
assert(func0("[[]][[") == 1);
assert(func0("[[][]]") == 1);
assert(func0("") == 0);
assert(func0("[[[[[[[[") == 0);
assert(func0("]]]]]]]]") == 0);
return 0;
}
|
O2
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %edx,%edx
add %rbx,%rax
xor %r8d,%r8d
jmp 1494 <func0+0x44>
nopl 0x0(%rax)
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%edx
test %edx,%edx
cmovs %r8d,%edx
cmp %edx,%ecx
cmovl %edx,%ecx
add $0x1,%rdi
lea -0x1(%rcx),%esi
cmp %esi,%edx
jl 14b8 <func0+0x68>
cmp %rdi,%rax
je 14b0 <func0+0x60>
movzbl (%rdi),%esi
cmp $0x5b,%sil
jne 1470 <func0+0x20>
add $0x1,%edx
jmp 147e <func0+0x2e>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor edx, edx
add rax, rbx
xor r8d, r8d
jmp short loc_1490
loc_1470:
cmp sil, 5Dh ; ']'
jnz short loc_1480
sub edx, 1
cmp edx, 0FFFFFFFFh
cmovz edx, r8d
loc_1480:
cmp ecx, edx
cmovl ecx, edx
add rdi, 1
lea esi, [rcx-1]
cmp esi, edx
jg short loc_14B1
loc_1490:
cmp rdi, rax
jz short loc_14C0
movzx esi, byte ptr [rdi]
cmp sil, 5Bh ; '['
jnz short loc_1470
add edx, 1
cmp ecx, edx
cmovl ecx, edx
add rdi, 1
lea esi, [rcx-1]
cmp esi, edx
jle short loc_1490
loc_14B1:
mov eax, 1
pop rbx
retn
loc_14C0:
xor eax, eax
pop rbx
retn
|
long long func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
int v3; // edx
const char *v4; // rax
v1 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( a1 != v4 )
{
if ( *a1 == 91 )
{
if ( v2 < ++v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
}
else
{
if ( *a1 == 93 && --v3 == -1 )
v3 = 0;
if ( v2 < v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
XOR EDX,EDX
ADD RAX,RBX
XOR R8D,R8D
JMP 0x00101490
LAB_00101470:
CMP SIL,0x5d
JNZ 0x00101480
SUB EDX,0x1
CMP EDX,-0x1
CMOVZ EDX,R8D
LAB_00101480:
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JG 0x001014b1
LAB_00101490:
CMP RDI,RAX
JZ 0x001014c0
MOVZX ESI,byte ptr [RDI]
CMP SIL,0x5b
JNZ 0x00101470
ADD EDX,0x1
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JLE 0x00101490
LAB_001014b1:
MOV EAX,0x1
POP RBX
RET
LAB_001014c0:
XOR EAX,EAX
POP RBX
RET
|
int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
int iVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
iVar4 = 0;
pcVar2 = param_1 + sVar1;
do {
while( true ) {
if (param_1 == pcVar2) {
return 0;
}
if (*param_1 == '[') break;
if ((*param_1 == ']') && (iVar4 = iVar4 + -1, iVar4 == -1)) {
iVar4 = 0;
}
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
param_1 = param_1 + 1;
if (iVar4 < iVar3 + -1) {
return 1;
}
}
iVar4 = iVar4 + 1;
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
param_1 = param_1 + 1;
} while (iVar3 + -1 <= iVar4);
return 1;
}
|
1,187 |
func0
|
#include <stdio.h>
#include <string.h>
|
int func0(const char *str) {
int count = 0, maxcount = 0;
for (int i = 0; i < strlen(str); i++) {
if (str[i] == '[') count += 1;
if (str[i] == ']') count -= 1;
if (count < 0) count = 0;
if (count > maxcount) maxcount = count;
if (count <= maxcount - 2) return 1;
}
return 0;
}
|
#include <assert.h>
int func0(const char *str);
int main() {
assert(func0("[[]]") == 1);
assert(func0("[]]]]]]][[[[[]") == 0);
assert(func0("[][]") == 0);
assert(func0("[]") == 0);
assert(func0("[[[[]]]]") == 1);
assert(func0("[]]]]]]]]]]") == 0);
assert(func0("[][][[]]") == 1);
assert(func0("[[]") == 0);
assert(func0("[]]") == 0);
assert(func0("[[]][[") == 1);
assert(func0("[[][]]") == 1);
assert(func0("") == 0);
assert(func0("[[[[[[[[") == 0);
assert(func0("]]]]]]]]") == 0);
return 0;
}
|
O3
|
c
|
func0:
endbr64
push %rbx
mov %rdi,%rbx
callq 1060 <strlen@plt>
mov %rbx,%rdi
xor %ecx,%ecx
xor %edx,%edx
add %rbx,%rax
xor %r8d,%r8d
jmp 1494 <func0+0x44>
nopl 0x0(%rax)
cmp $0x5d,%sil
sete %sil
movzbl %sil,%esi
sub %esi,%edx
test %edx,%edx
cmovs %r8d,%edx
cmp %edx,%ecx
cmovl %edx,%ecx
add $0x1,%rdi
lea -0x1(%rcx),%esi
cmp %esi,%edx
jl 14b8 <func0+0x68>
cmp %rdi,%rax
je 14b0 <func0+0x60>
movzbl (%rdi),%esi
cmp $0x5b,%sil
jne 1470 <func0+0x20>
add $0x1,%edx
jmp 147e <func0+0x2e>
nopw 0x0(%rax,%rax,1)
xor %eax,%eax
pop %rbx
retq
nopl 0x0(%rax)
mov $0x1,%eax
pop %rbx
retq
|
func0:
endbr64
push rbx
mov rbx, rdi
call _strlen
mov rdi, rbx
xor ecx, ecx
xor edx, edx
add rax, rbx
xor r8d, r8d
jmp short loc_1490
loc_1470:
cmp sil, 5Dh ; ']'
jnz short loc_1480
sub edx, 1
cmp edx, 0FFFFFFFFh
cmovz edx, r8d
loc_1480:
cmp ecx, edx
cmovl ecx, edx
add rdi, 1
lea esi, [rcx-1]
cmp esi, edx
jg short loc_14B1
loc_1490:
cmp rax, rdi
jz short loc_14C0
movzx esi, byte ptr [rdi]
cmp sil, 5Bh ; '['
jnz short loc_1470
add edx, 1
cmp ecx, edx
cmovl ecx, edx
add rdi, 1
lea esi, [rcx-1]
cmp esi, edx
jle short loc_1490
loc_14B1:
mov eax, 1
pop rbx
retn
loc_14C0:
xor eax, eax
pop rbx
retn
|
long long func0(const char *a1)
{
size_t v1; // rax
int v2; // ecx
int v3; // edx
const char *v4; // rax
v1 = strlen(a1);
v2 = 0;
v3 = 0;
v4 = &a1[v1];
while ( v4 != a1 )
{
if ( *a1 == 91 )
{
if ( v2 < ++v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
}
else
{
if ( *a1 == 93 && --v3 == -1 )
v3 = 0;
if ( v2 < v3 )
v2 = v3;
++a1;
if ( v2 - 1 > v3 )
return 1LL;
}
}
return 0LL;
}
|
func0:
ENDBR64
PUSH RBX
MOV RBX,RDI
CALL 0x00101060
MOV RDI,RBX
XOR ECX,ECX
XOR EDX,EDX
ADD RAX,RBX
XOR R8D,R8D
JMP 0x00101490
LAB_00101470:
CMP SIL,0x5d
JNZ 0x00101480
SUB EDX,0x1
CMP EDX,-0x1
CMOVZ EDX,R8D
LAB_00101480:
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JG 0x001014b1
LAB_00101490:
CMP RAX,RDI
JZ 0x001014c0
MOVZX ESI,byte ptr [RDI]
CMP SIL,0x5b
JNZ 0x00101470
ADD EDX,0x1
CMP ECX,EDX
CMOVL ECX,EDX
ADD RDI,0x1
LEA ESI,[RCX + -0x1]
CMP ESI,EDX
JLE 0x00101490
LAB_001014b1:
MOV EAX,0x1
POP RBX
RET
LAB_001014c0:
XOR EAX,EAX
POP RBX
RET
|
int8 func0(char *param_1)
{
size_t sVar1;
char *pcVar2;
int iVar3;
int iVar4;
sVar1 = strlen(param_1);
iVar3 = 0;
iVar4 = 0;
pcVar2 = param_1 + sVar1;
do {
while( true ) {
if (pcVar2 == param_1) {
return 0;
}
if (*param_1 == '[') break;
if ((*param_1 == ']') && (iVar4 = iVar4 + -1, iVar4 == -1)) {
iVar4 = 0;
}
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
param_1 = param_1 + 1;
if (iVar4 < iVar3 + -1) {
return 1;
}
}
iVar4 = iVar4 + 1;
if (iVar3 < iVar4) {
iVar3 = iVar4;
}
param_1 = param_1 + 1;
} while (iVar3 + -1 <= iVar4);
return 1;
}
|
1,188 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
}
|
#include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[] = {-2.4, 1, 1};
assert(func0(lst5, 3) == 6);
float lst6[] = {100, 1, 15, 2};
assert(func0(lst6, 4) == 10230);
float lst7[] = {10000, 10000};
assert(func0(lst7, 2) == 200000000);
float lst8[] = {-1.4, 4.6, 6.3};
assert(func0(lst8, 3) == 75);
float lst9[] = {-1.4, 17.9, 18.9, 19.9};
assert(func0(lst9, 4) == 1086);
float lst10[] = {0};
assert(func0(lst10, 1) == 0);
float lst11[] = {-1};
assert(func0(lst11, 1) == 1);
float lst12[] = {-1, 1, 0};
assert(func0(lst12, 3) == 2);
return 0;
}
|
O0
|
c
|
func0:
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
movl $0x0,-0x18(%rbp)
movl $0x0,-0x14(%rbp)
jmp 1201 <func0+0x78>
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1090 <ceil@plt>
cvttsd2si %xmm0,%ebx
mov -0x14(%rbp),%eax
cltq
lea 0x0(,%rax,4),%rdx
mov -0x28(%rbp),%rax
add %rdx,%rax
movss (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
callq 1090 <ceil@plt>
cvttsd2si %xmm0,%eax
imul %ebx,%eax
add %eax,-0x18(%rbp)
addl $0x1,-0x14(%rbp)
mov -0x14(%rbp),%eax
cmp -0x2c(%rbp),%eax
jl 11ad <func0+0x24>
mov -0x18(%rbp),%eax
add $0x28,%rsp
pop %rbx
pop %rbp
retq
|
func0:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_18], 0
mov [rbp+var_14], 0
jmp short loc_121D
loc_11AD:
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm1, xmm1
cvtss2sd xmm1, xmm0
movq rax, xmm1
movq xmm0, rax; x
call _ceil
cvttsd2si ebx, xmm0
mov eax, [rbp+var_14]
cdqe
lea rdx, ds:0[rax*4]
mov rax, [rbp+var_28]
add rax, rdx
movss xmm0, dword ptr [rax]
pxor xmm2, xmm2
cvtss2sd xmm2, xmm0
movq rax, xmm2
movq xmm0, rax; x
call _ceil
cvttsd2si eax, xmm0
imul eax, ebx
add [rbp+var_18], eax
add [rbp+var_14], 1
loc_121D:
mov eax, [rbp+var_14]
cmp eax, [rbp+var_2C]
jl short loc_11AD
mov eax, [rbp+var_18]
mov rbx, [rbp+var_8]
leave
retn
|
long long func0(long long a1, int a2)
{
int v2; // ebx
unsigned int v4; // [rsp+18h] [rbp-18h]
int i; // [rsp+1Ch] [rbp-14h]
v4 = 0;
for ( i = 0; i < a2; ++i )
{
v2 = (int)ceil(*(float *)(4LL * i + a1));
v4 += v2 * (int)ceil(*(float *)(4LL * i + a1));
}
return v4;
}
|
func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV dword ptr [RBP + -0x18],0x0
MOV dword ptr [RBP + -0x14],0x0
JMP 0x0010121d
LAB_001011ad:
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM1,XMM1
CVTSS2SD XMM1,XMM0
MOVQ RAX,XMM1
MOVQ XMM0,RAX
CALL 0x00101090
CVTTSD2SI EBX,XMM0
MOV EAX,dword ptr [RBP + -0x14]
CDQE
LEA RDX,[RAX*0x4]
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,RDX
MOVSS XMM0,dword ptr [RAX]
PXOR XMM2,XMM2
CVTSS2SD XMM2,XMM0
MOVQ RAX,XMM2
MOVQ XMM0,RAX
CALL 0x00101090
CVTTSD2SI EAX,XMM0
IMUL EAX,EBX
ADD dword ptr [RBP + -0x18],EAX
ADD dword ptr [RBP + -0x14],0x1
LAB_0010121d:
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x2c]
JL 0x001011ad
MOV EAX,dword ptr [RBP + -0x18]
MOV RBX,qword ptr [RBP + -0x8]
LEAVE
RET
|
int func0(long param_1,int param_2)
{
double dVar1;
double dVar2;
int4 local_20;
int4 local_1c;
local_20 = 0;
for (local_1c = 0; local_1c < param_2; local_1c = local_1c + 1) {
dVar1 = ceil((double)*(float *)(param_1 + (long)local_1c * 4));
dVar2 = ceil((double)*(float *)(param_1 + (long)local_1c * 4));
local_20 = local_20 + (int)dVar2 * (int)dVar1;
}
return local_20;
}
|
1,189 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
}
|
#include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[] = {-2.4, 1, 1};
assert(func0(lst5, 3) == 6);
float lst6[] = {100, 1, 15, 2};
assert(func0(lst6, 4) == 10230);
float lst7[] = {10000, 10000};
assert(func0(lst7, 2) == 200000000);
float lst8[] = {-1.4, 4.6, 6.3};
assert(func0(lst8, 3) == 75);
float lst9[] = {-1.4, 17.9, 18.9, 19.9};
assert(func0(lst9, 4) == 1086);
float lst10[] = {0};
assert(func0(lst10, 1) == 0);
float lst11[] = {-1};
assert(func0(lst11, 1) == 1);
float lst12[] = {-1, 1, 0};
assert(func0(lst12, 3) == 2);
return 0;
}
|
O1
|
c
|
func0:
endbr64
test %esi,%esi
jle 11e2 <func0+0x79>
mov %rdi,%rdx
lea -0x1(%rsi),%eax
lea 0x4(%rdi,%rax,4),%rsi
mov $0x0,%ecx
movss 0xfcf(%rip),%xmm4
movss 0xfdf(%rip),%xmm3
movss 0xfc3(%rip),%xmm5
jmp 11ad <func0+0x44>
cvttss2si %xmm0,%eax
imul %eax,%eax
add %eax,%ecx
add $0x4,%rdx
cmp %rsi,%rdx
je 11e7 <func0+0x7e>
movss (%rdx),%xmm2
movaps %xmm2,%xmm0
movaps %xmm2,%xmm1
andps %xmm3,%xmm1
ucomiss %xmm1,%xmm4
jbe 119b <func0+0x32>
cvttss2si %xmm2,%eax
pxor %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
cmpnless %xmm1,%xmm0
andps %xmm5,%xmm0
addss %xmm0,%xmm1
movaps %xmm3,%xmm0
andnps %xmm2,%xmm0
orps %xmm1,%xmm0
jmp 119b <func0+0x32>
mov $0x0,%ecx
mov %ecx,%eax
retq
|
func0:
endbr64
test esi, esi
jle short loc_11E1
mov rdx, rdi
movsxd rsi, esi
lea rsi, [rdi+rsi*4]
mov ecx, 0
movss xmm4, cs:dword_2004
movss xmm3, cs:dword_200C
movss xmm5, cs:dword_2008
jmp short loc_11AC
loc_119A:
cvttss2si eax, xmm2
imul eax, eax
add ecx, eax
add rdx, 4
cmp rdx, rsi
jz short loc_11E6
loc_11AC:
movss xmm1, dword ptr [rdx]
movaps xmm2, xmm1
movaps xmm0, xmm1
andps xmm0, xmm3
ucomiss xmm4, xmm0
jbe short loc_119A
cvttss2si eax, xmm1
pxor xmm0, xmm0
cvtsi2ss xmm0, eax
cmpnless xmm2, xmm0
andps xmm2, xmm5
addss xmm0, xmm2
movaps xmm2, xmm3
andnps xmm2, xmm1
orps xmm2, xmm0
jmp short loc_119A
loc_11E1:
mov ecx, 0
loc_11E6:
mov eax, ecx
retn
|
long long func0(float *a1, int a2)
{
float *v2; // rdx
float *v3; // rsi
unsigned int v4; // ecx
__m128 v5; // xmm1
float v6; // xmm2_4
__m128 v7; // xmm0
if ( a2 <= 0 )
{
return 0;
}
else
{
v2 = a1;
v3 = &a1[a2];
v4 = 0;
do
{
v5 = (__m128)*(unsigned int *)v2;
v6 = v5.m128_f32[0];
if ( fabs(*v2) < 8388608.0 )
{
v7.m128_f32[0] = (float)(int)v5.m128_f32[0];
LODWORD(v6) = _mm_andnot_ps((__m128)0x7FFFFFFFu, v5).m128_u32[0] | COERCE_UNSIGNED_INT(
v7.m128_f32[0]
+ COERCE_FLOAT(_mm_cmpgt_ss(v5, v7).m128_u32[0] & 0x3F800000));
}
v4 += (int)v6 * (int)v6;
++v2;
}
while ( v2 != v3 );
}
return v4;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x001011e1
MOV RDX,RDI
MOVSXD RSI,ESI
LEA RSI,[RDI + RSI*0x4]
MOV ECX,0x0
MOVSS XMM4,dword ptr [0x00102004]
MOVSS XMM3,dword ptr [0x0010200c]
MOVSS XMM5,dword ptr [0x00102008]
JMP 0x001011ac
LAB_0010119a:
CVTTSS2SI EAX,XMM2
IMUL EAX,EAX
ADD ECX,EAX
ADD RDX,0x4
CMP RDX,RSI
JZ 0x001011e6
LAB_001011ac:
MOVSS XMM1,dword ptr [RDX]
MOVAPS XMM2,XMM1
MOVAPS XMM0,XMM1
ANDPS XMM0,XMM3
UCOMISS XMM4,XMM0
JBE 0x0010119a
CVTTSS2SI EAX,XMM1
PXOR XMM0,XMM0
CVTSI2SS XMM0,EAX
CMPNLESS XMM2,XMM0
ANDPS XMM2,XMM5
ADDSS XMM0,XMM2
MOVAPS XMM2,XMM3
ANDNPS XMM2,XMM1
ORPS XMM2,XMM0
JMP 0x0010119a
LAB_001011e1:
MOV ECX,0x0
LAB_001011e6:
MOV EAX,ECX
RET
|
int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (param_2 < 1) {
iVar2 = 0;
}
else {
pfVar1 = param_1 + param_2;
iVar2 = 0;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_0010200c) < DAT_00102004) {
fVar3 = (float)(~DAT_0010200c & (uint)fVar3 |
(uint)((float)(int)fVar3 +
(float)(-(uint)((float)(int)fVar3 < fVar3) & DAT_00102008)));
}
iVar2 = iVar2 + (int)fVar3 * (int)fVar3;
param_1 = param_1 + 1;
} while (param_1 != pfVar1);
}
return iVar2;
}
|
1,190 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
}
|
#include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[] = {-2.4, 1, 1};
assert(func0(lst5, 3) == 6);
float lst6[] = {100, 1, 15, 2};
assert(func0(lst6, 4) == 10230);
float lst7[] = {10000, 10000};
assert(func0(lst7, 2) == 200000000);
float lst8[] = {-1.4, 4.6, 6.3};
assert(func0(lst8, 3) == 75);
float lst9[] = {-1.4, 17.9, 18.9, 19.9};
assert(func0(lst9, 4) == 1086);
float lst10[] = {0};
assert(func0(lst10, 1) == 0);
float lst11[] = {-1};
assert(func0(lst11, 1) == 1);
float lst12[] = {-1, 1, 0};
assert(func0(lst12, 3) == 2);
return 0;
}
|
O2
|
c
|
func0:
endbr64
test %esi,%esi
jle 15d0 <func0+0x80>
lea -0x1(%rsi),%eax
movss 0xbf5(%rip),%xmm4
xor %r8d,%r8d
movss 0xc02(%rip),%xmm3
movss 0xbe6(%rip),%xmm5
lea 0x4(%rdi,%rax,4),%rdx
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
movaps %xmm0,%xmm1
andps %xmm3,%xmm1
ucomiss %xmm1,%xmm4
jbe 15b6 <func0+0x66>
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
movaps %xmm0,%xmm2
movaps %xmm3,%xmm6
andnps %xmm0,%xmm6
movaps %xmm6,%xmm0
cvtsi2ss %eax,%xmm1
cmpnless %xmm1,%xmm2
andps %xmm5,%xmm2
addss %xmm2,%xmm1
orps %xmm1,%xmm0
cvttss2si %xmm0,%eax
add $0x4,%rdi
imul %eax,%eax
add %eax,%r8d
cmp %rdx,%rdi
jne 1580 <func0+0x30>
mov %r8d,%eax
retq
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
movss xmm4, cs:dword_2004
xor edx, edx
movss xmm3, cs:dword_2008
movss xmm5, dword ptr cs:xmmword_2170
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1540:
movss xmm0, dword ptr [rdi]
movaps xmm1, xmm0
andps xmm1, xmm3
ucomiss xmm4, xmm1
jbe short loc_1576
cvttss2si eax, xmm0
pxor xmm1, xmm1
movaps xmm2, xmm0
cvtsi2ss xmm1, eax
cmpnless xmm2, xmm1
andps xmm2, xmm5
addss xmm1, xmm2
movaps xmm2, xmm3
andnps xmm2, xmm0
movaps xmm0, xmm1
orps xmm0, xmm2
loc_1576:
cvttss2si eax, xmm0
add rdi, 4
imul eax, eax
add edx, eax
cmp rcx, rdi
jnz short loc_1540
mov eax, edx
retn
loc_1590:
xor edx, edx
mov eax, edx
retn
|
long long func0(float *a1, int a2)
{
unsigned int v2; // edx
float *v3; // rcx
__m128 v4; // xmm0
__m128 v5; // xmm1
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
v4 = (__m128)*(unsigned int *)a1;
if ( fabs(*a1) < 8388608.0 )
{
v5.m128_f32[0] = (float)(int)v4.m128_f32[0];
v4.m128_i32[0] = COERCE_UNSIGNED_INT(v5.m128_f32[0] + COERCE_FLOAT(_mm_cmpgt_ss(v4, v5).m128_u32[0] & 0x3F800000)) | _mm_andnot_ps((__m128)0x7FFFFFFFu, v4).m128_u32[0];
}
++a1;
v2 += (int)v4.m128_f32[0] * (int)v4.m128_f32[0];
}
while ( v3 != a1 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
MOVSS XMM4,dword ptr [0x00102004]
XOR EDX,EDX
MOVSS XMM3,dword ptr [0x00102008]
MOVSS XMM5,dword ptr [0x00102170]
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101540:
MOVSS XMM0,dword ptr [RDI]
MOVAPS XMM1,XMM0
ANDPS XMM1,XMM3
UCOMISS XMM4,XMM1
JBE 0x00101576
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
MOVAPS XMM2,XMM0
CVTSI2SS XMM1,EAX
CMPNLESS XMM2,XMM1
ANDPS XMM2,XMM5
ADDSS XMM1,XMM2
MOVAPS XMM2,XMM3
ANDNPS XMM2,XMM0
MOVAPS XMM0,XMM1
ORPS XMM0,XMM2
LAB_00101576:
CVTTSS2SI EAX,XMM0
ADD RDI,0x4
IMUL EAX,EAX
ADD EDX,EAX
CMP RCX,RDI
JNZ 0x00101540
MOV EAX,EDX
RET
LAB_00101590:
XOR EDX,EDX
MOV EAX,EDX
RET
|
int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (0 < param_2) {
iVar2 = 0;
pfVar1 = param_1 + param_2;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_00102008) < DAT_00102004) {
fVar3 = (float)((uint)((float)(int)fVar3 +
(float)(-(uint)((float)(int)fVar3 < fVar3) & DAT_00102170)) |
~DAT_00102008 & (uint)fVar3);
}
param_1 = param_1 + 1;
iVar2 = iVar2 + (int)fVar3 * (int)fVar3;
} while (pfVar1 != param_1);
return iVar2;
}
return 0;
}
|
1,191 |
func0
|
#include <stdio.h>
#include <math.h>
|
int func0(float *lst, int size) {
int sum = 0;
for (int i = 0; i < size; i++) {
sum += (int)ceil(lst[i]) * (int)ceil(lst[i]);
}
return sum;
}
|
#include <assert.h>
int main() {
float lst1[] = {1, 2, 3};
assert(func0(lst1, 3) == 14);
float lst2[] = {1.0, 2, 3};
assert(func0(lst2, 3) == 14);
float lst3[] = {1, 3, 5, 7};
assert(func0(lst3, 4) == 84);
float lst4[] = {1.4, 4.2, 0};
assert(func0(lst4, 3) == 29);
float lst5[] = {-2.4, 1, 1};
assert(func0(lst5, 3) == 6);
float lst6[] = {100, 1, 15, 2};
assert(func0(lst6, 4) == 10230);
float lst7[] = {10000, 10000};
assert(func0(lst7, 2) == 200000000);
float lst8[] = {-1.4, 4.6, 6.3};
assert(func0(lst8, 3) == 75);
float lst9[] = {-1.4, 17.9, 18.9, 19.9};
assert(func0(lst9, 4) == 1086);
float lst10[] = {0};
assert(func0(lst10, 1) == 0);
float lst11[] = {-1};
assert(func0(lst11, 1) == 1);
float lst12[] = {-1, 1, 0};
assert(func0(lst12, 3) == 2);
return 0;
}
|
O3
|
c
|
func0:
endbr64
test %esi,%esi
jle 15a0 <func0+0x80>
lea -0x1(%rsi),%eax
movss 0xc25(%rip),%xmm4
xor %r8d,%r8d
movss 0xc32(%rip),%xmm3
movss 0xc16(%rip),%xmm5
lea 0x4(%rdi,%rax,4),%rdx
nopl 0x0(%rax,%rax,1)
movss (%rdi),%xmm0
movaps %xmm0,%xmm1
andps %xmm3,%xmm1
ucomiss %xmm1,%xmm4
jbe 1586 <func0+0x66>
cvttss2si %xmm0,%eax
pxor %xmm1,%xmm1
movaps %xmm0,%xmm2
movaps %xmm3,%xmm6
andnps %xmm0,%xmm6
movaps %xmm6,%xmm0
cvtsi2ss %eax,%xmm1
cmpnless %xmm1,%xmm2
andps %xmm5,%xmm2
addss %xmm2,%xmm1
orps %xmm1,%xmm0
cvttss2si %xmm0,%eax
add $0x4,%rdi
imul %eax,%eax
add %eax,%r8d
cmp %rdi,%rdx
jne 1550 <func0+0x30>
mov %r8d,%eax
retq
nopl (%rax)
xor %r8d,%r8d
mov %r8d,%eax
retq
nopw 0x0(%rax,%rax,1)
|
func0:
endbr64
test esi, esi
jle short loc_1590
movsxd rsi, esi
movss xmm4, cs:dword_2004
xor edx, edx
movss xmm3, cs:dword_2008
movss xmm5, dword ptr cs:xmmword_2170
lea rcx, [rdi+rsi*4]
nop dword ptr [rax+00000000h]
loc_1540:
movss xmm0, dword ptr [rdi]
movaps xmm1, xmm0
andps xmm1, xmm3
ucomiss xmm4, xmm1
jbe short loc_1576
cvttss2si eax, xmm0
pxor xmm1, xmm1
movaps xmm2, xmm0
cvtsi2ss xmm1, eax
cmpnless xmm2, xmm1
andps xmm2, xmm5
addss xmm1, xmm2
movaps xmm2, xmm3
andnps xmm2, xmm0
movaps xmm0, xmm1
orps xmm0, xmm2
loc_1576:
cvttss2si eax, xmm0
add rdi, 4
imul eax, eax
add edx, eax
cmp rcx, rdi
jnz short loc_1540
mov eax, edx
retn
loc_1590:
xor edx, edx
mov eax, edx
retn
|
long long func0(float *a1, int a2)
{
unsigned int v2; // edx
float *v3; // rcx
__m128 v4; // xmm0
__m128 v5; // xmm1
if ( a2 <= 0 )
return 0LL;
v2 = 0;
v3 = &a1[a2];
do
{
v4 = (__m128)*(unsigned int *)a1;
if ( fabs(*a1) < 8388608.0 )
{
v5.m128_f32[0] = (float)(int)v4.m128_f32[0];
v4.m128_i32[0] = COERCE_UNSIGNED_INT(v5.m128_f32[0] + COERCE_FLOAT(_mm_cmpgt_ss(v4, v5).m128_u32[0] & 0x3F800000)) | _mm_andnot_ps((__m128)0x7FFFFFFFu, v4).m128_u32[0];
}
++a1;
v2 += (int)v4.m128_f32[0] * (int)v4.m128_f32[0];
}
while ( v3 != a1 );
return v2;
}
|
func0:
ENDBR64
TEST ESI,ESI
JLE 0x00101590
MOVSXD RSI,ESI
MOVSS XMM4,dword ptr [0x00102004]
XOR EDX,EDX
MOVSS XMM3,dword ptr [0x00102008]
MOVSS XMM5,dword ptr [0x00102170]
LEA RCX,[RDI + RSI*0x4]
NOP dword ptr [RAX]
LAB_00101540:
MOVSS XMM0,dword ptr [RDI]
MOVAPS XMM1,XMM0
ANDPS XMM1,XMM3
UCOMISS XMM4,XMM1
JBE 0x00101576
CVTTSS2SI EAX,XMM0
PXOR XMM1,XMM1
MOVAPS XMM2,XMM0
CVTSI2SS XMM1,EAX
CMPNLESS XMM2,XMM1
ANDPS XMM2,XMM5
ADDSS XMM1,XMM2
MOVAPS XMM2,XMM3
ANDNPS XMM2,XMM0
MOVAPS XMM0,XMM1
ORPS XMM0,XMM2
LAB_00101576:
CVTTSS2SI EAX,XMM0
ADD RDI,0x4
IMUL EAX,EAX
ADD EDX,EAX
CMP RCX,RDI
JNZ 0x00101540
MOV EAX,EDX
RET
LAB_00101590:
XOR EDX,EDX
MOV EAX,EDX
RET
|
int func0(float *param_1,int param_2)
{
float *pfVar1;
int iVar2;
float fVar3;
if (0 < param_2) {
iVar2 = 0;
pfVar1 = param_1 + param_2;
do {
fVar3 = *param_1;
if ((float)((uint)fVar3 & DAT_00102008) < DAT_00102004) {
fVar3 = (float)((uint)((float)(int)fVar3 +
(float)(-(uint)((float)(int)fVar3 < fVar3) & DAT_00102170)) |
~DAT_00102008 & (uint)fVar3);
}
param_1 = param_1 + 1;
iVar2 = iVar2 + (int)fVar3 * (int)fVar3;
} while (pfVar1 != param_1);
return iVar2;
}
return 0;
}
|
1,192 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
assert(func0("apple pie") == 0);
assert(func0("apple pi e ") == 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 1070 <strlen@plt>
mov %eax,-0x4(%rbp)
cmpl $0x0,-0x4(%rbp)
jne 11b8 <func0+0x2f>
mov $0x0,%eax
jmpq 124c <func0+0xc3>
mov -0x4(%rbp),%eax
cltq
lea -0x1(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x6(%rbp)
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
movzbl -0x6(%rbp),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
jne 11f9 <func0+0x70>
mov $0x0,%eax
jmp 124c <func0+0xc3>
cmpl $0x1,-0x4(%rbp)
jne 1206 <func0+0x7d>
mov $0x1,%eax
jmp 124c <func0+0xc3>
mov -0x4(%rbp),%eax
cltq
lea -0x2(%rax),%rdx
mov -0x18(%rbp),%rax
add %rdx,%rax
movzbl (%rax),%eax
mov %al,-0x5(%rbp)
callq 1090 <__ctype_b_loc@plt>
mov (%rax),%rax
movzbl -0x5(%rbp),%edx
movzbl %dl,%edx
add %rdx,%rdx
add %rdx,%rax
movzwl (%rax),%eax
movzwl %ax,%eax
and $0x400,%eax
test %eax,%eax
je 1247 <func0+0xbe>
mov $0x0,%eax
jmp 124c <func0+0xc3>
mov $0x1,%eax
leaveq
retq
|
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
cmp [rbp+var_4], 0
jnz short loc_11B8
mov eax, 0
jmp locret_124C
loc_11B8:
mov eax, [rbp+var_4]
cdqe
lea rdx, [rax-1]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_6], al
call ___ctype_b_loc
mov rax, [rax]
movzx edx, [rbp+var_6]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jnz short loc_11F9
mov eax, 0
jmp short locret_124C
loc_11F9:
cmp [rbp+var_4], 1
jnz short loc_1206
mov eax, 1
jmp short locret_124C
loc_1206:
mov eax, [rbp+var_4]
cdqe
lea rdx, [rax-2]
mov rax, [rbp+s]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp+var_5], al
call ___ctype_b_loc
mov rax, [rax]
movzx edx, [rbp+var_5]
movzx edx, dl
add rdx, rdx
add rax, rdx
movzx eax, word ptr [rax]
movzx eax, ax
and eax, 400h
test eax, eax
jz short loc_1247
mov eax, 0
jmp short locret_124C
loc_1247:
mov eax, 1
locret_124C:
leave
retn
|
_BOOL8 func0(const char *a1)
{
unsigned __int8 v2; // [rsp+1Ah] [rbp-6h]
unsigned __int8 v3; // [rsp+1Bh] [rbp-5h]
int v4; // [rsp+1Ch] [rbp-4h]
v4 = strlen(a1);
if ( !v4 )
return 0LL;
v2 = a1[v4 - 1];
if ( ((*__ctype_b_loc())[v2] & 0x400) == 0 )
return 0LL;
if ( v4 == 1 )
return 1LL;
v3 = a1[v4 - 2];
return ((*__ctype_b_loc())[v3] & 0x400) == 0;
}
|
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 0x00101070
MOV dword ptr [RBP + -0x4],EAX
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x001011b8
MOV EAX,0x0
JMP 0x0010124c
LAB_001011b8:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX + -0x1]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x6],AL
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX EDX,byte ptr [RBP + -0x6]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JNZ 0x001011f9
MOV EAX,0x0
JMP 0x0010124c
LAB_001011f9:
CMP dword ptr [RBP + -0x4],0x1
JNZ 0x00101206
MOV EAX,0x1
JMP 0x0010124c
LAB_00101206:
MOV EAX,dword ptr [RBP + -0x4]
CDQE
LEA RDX,[RAX + -0x2]
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,RDX
MOVZX EAX,byte ptr [RAX]
MOV byte ptr [RBP + -0x5],AL
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX EDX,byte ptr [RBP + -0x5]
MOVZX EDX,DL
ADD RDX,RDX
ADD RAX,RDX
MOVZX EAX,word ptr [RAX]
MOVZX EAX,AX
AND EAX,0x400
TEST EAX,EAX
JZ 0x00101247
MOV EAX,0x0
JMP 0x0010124c
LAB_00101247:
MOV EAX,0x1
LAB_0010124c:
LEAVE
RET
|
int8 func0(char *param_1)
{
byte bVar1;
int iVar2;
size_t sVar3;
int8 uVar4;
ushort **ppuVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
if (iVar2 == 0) {
uVar4 = 0;
}
else {
bVar1 = param_1[(long)iVar2 + -1];
ppuVar5 = __ctype_b_loc();
if (((*ppuVar5)[bVar1] & 0x400) == 0) {
uVar4 = 0;
}
else if (iVar2 == 1) {
uVar4 = 1;
}
else {
bVar1 = param_1[(long)iVar2 + -2];
ppuVar5 = __ctype_b_loc();
if (((*ppuVar5)[bVar1] & 0x400) == 0) {
uVar4 = 1;
}
else {
uVar4 = 0;
}
}
}
return uVar4;
}
|
1,193 |
func0
|
#include <stdio.h>
#include <string.h>
#include <ctype.h>
|
int func0(const char *txt) {
int len = strlen(txt);
if (len == 0) return 0;
char last_char = txt[len - 1];
if (!isalpha((unsigned char)last_char)) return 0;
if (len == 1) return 1;
char second_last_char = txt[len - 2];
if (isalpha((unsigned char)second_last_char)) return 0;
return 1;
}
|
#include <assert.h>
int main() {
assert(func0("apple") == 0);
assert(func0("apple pi e") == 1);
assert(func0("eeeee") == 0);
assert(func0("A") == 1);
assert(func0("Pumpkin pie ") == 0);
assert(func0("Pumpkin pie 1") == 0);
assert(func0("") == 0);
assert(func0("eeeee e ") == 0);
assert(func0("apple pie") == 0);
assert(func0("apple pi e ") == 0);
return 0;
}
|
O1
|
c
|
func0:
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
mov $0xffffffffffffffff,%rcx
mov $0x0,%eax
repnz scas %es:(%rdi),%al
not %rcx
lea -0x1(%rcx),%rbx
mov %ebx,%r12d
test %ebx,%ebx
je 11cb <func0+0x62>
movslq %ebx,%r13
callq 1070 <__ctype_b_loc@plt>
mov (%rax),%rax
movzbl -0x1(%rbp,%r13,1),%edx
testb $0x4,0x1(%rax,%rdx,2)
je 11d9 <func0+0x70>
cmp $0x1,%ebx
je 11cb <func0+0x62>
movzbl -0x2(%rbp,%r13,1),%edx
movzwl (%rax,%rdx,2),%r12d
shr $0xa,%r12w
xor $0x1,%r12d
and $0x1,%r12d
mov %r12d,%eax
add $0x8,%rsp
pop %rbx
pop %rbp
pop %r12
pop %r13
retq
mov $0x0,%r12d
jmp 11cb <func0+0x62>
|
func0:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov r13, rdi
call _strlen
mov ebp, eax
test eax, eax
jz short loc_11D9
movsxd r14, eax
movzx r12d, byte ptr [r13+r14-1]
call ___ctype_b_loc
mov rax, [rax]
movzx r12d, r12b
test byte ptr [rax+r12*2+1], 4
jz short loc_11E4
cmp ebp, 1
jz short loc_11D9
movzx edx, byte ptr [r13+r14-2]
movzx ebp, word ptr [rax+rdx*2]
shr bp, 0Ah
xor ebp, 1
and ebp, 1
loc_11D9:
mov eax, ebp
pop rbx
pop rbp
pop r12
pop r13
pop r14
retn
loc_11E4:
mov ebp, 0
jmp short loc_11D9
|
long long func0(const char *a1)
{
unsigned int v1; // eax
unsigned int v2; // ebp
long long v3; // r14
unsigned __int8 v4; // r12
const unsigned __int16 *v5; // rax
v1 = strlen(a1);
v2 = v1;
if ( v1 )
{
v3 = (int)v1;
v4 = a1[v1 - 1];
v5 = *__ctype_b_loc();
if ( (v5[v4] & 0x400) != 0 )
{
if ( v2 != 1 )
return ((v5[(unsigned __int8)a1[v3 - 2]] >> 10) ^ 1) & 1;
}
else
{
return 0;
}
}
return v2;
}
|
func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV R13,RDI
CALL 0x00101070
MOV EBP,EAX
TEST EAX,EAX
JZ 0x001011d9
MOVSXD R14,EAX
MOVZX R12D,byte ptr [R13 + R14*0x1 + -0x1]
CALL 0x00101090
MOV RAX,qword ptr [RAX]
MOVZX R12D,R12B
TEST byte ptr [RAX + R12*0x2 + 0x1],0x4
JZ 0x001011e4
CMP EBP,0x1
JZ 0x001011d9
MOVZX EDX,byte ptr [R13 + R14*0x1 + -0x2]
MOVZX EBP,word ptr [RAX + RDX*0x2]
SHR BP,0xa
XOR EBP,0x1
AND EBP,0x1
LAB_001011d9:
MOV EAX,EBP
POP RBX
POP RBP
POP R12
POP R13
POP R14
RET
LAB_001011e4:
MOV EBP,0x0
JMP 0x001011d9
|
ulong func0(char *param_1)
{
byte bVar1;
int iVar2;
size_t sVar3;
ushort **ppuVar4;
ulong uVar5;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3;
uVar5 = sVar3 & 0xffffffff;
if (iVar2 != 0) {
bVar1 = param_1[(long)iVar2 + -1];
ppuVar4 = __ctype_b_loc();
if ((*(byte *)((long)*ppuVar4 + (ulong)bVar1 * 2 + 1) & 4) == 0) {
uVar5 = 0;
}
else if (iVar2 != 1) {
uVar5 = (ulong)(((*ppuVar4)[(byte)param_1[(long)iVar2 + -2]] >> 10 ^ 1) & 1);
}
}
return uVar5;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.