joyce8/EMBER2024-capa huggingface dataset:
Function at 0xe1cfb7
Capabilities:
Write file on windows

Disassembly:
mov eax, 0xe9deac
call fcn.00e9cd48
sub esp, 0x20
push ebx
xor ebx, ebx
cmp dword [edi + 0x44], ebx
je 0xe1d09b
cmp byte [edi + 0x49], bl
je 0xe1d09b
mov eax, dword [edi]
push 0xffffffffffffffff
mov ecx, edi
call dword [eax + 0xc]
cmp eax, 0xffffffff
jne 0xe1cfee
xor al, al
jmp 0xe1d09d
push esi
lea esi, [ebp - 0x2c]
call fcn.00e1c95c
mov dword [ebp - 4], ebx
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xe1d03e
lea eax, [ebp - 0x2c]
mov edx, eax
mov ecx, dword [edi + 0x44]
mov esi, dword [ecx]
lea ebx, [ebp - 0x10]
push ebx
mov ebx, dword [ebp - 0x1c]
add eax, ebx
push eax
push edx
lea eax, [edi + 0x4c]
push eax
call dword [esi + 0x18]
sub eax, 0
je 0xe1d043
dec eax
je 0xe1d047
dec eax
dec eax
je 0xe1d097
xor bl, bl
push 0
push 1
lea ecx, [ebp - 0x2c]
call fcn.00e14cae
mov al, bl
pop esi
jmp 0xe1d09d
mov edx, dword [ebp - 0x2c]
jmp 0xe1d008
mov byte [edi + 0x49], 0
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xe1d053
lea eax, [ebp - 0x2c]
mov esi, dword [ebp - 0x10]
sub esi, eax
je 0xe1d079
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xe1d066
lea eax, [ebp - 0x2c]
push dword [edi + 0x54]
push esi
push 1
push eax
call fcn.00e78990
add esp, 0x10
cmp esi, eax
jne 0xe1d02b
cmp byte [edi + 0x49], 0
je 0xe1d097
test esi, esi
jne 0xe1cffa
push esi
push 8
lea esi, [ebp - 0x2c]
call fcn.00e1ca35
jmp 0xe1cffa
mov bl, 1
jmp 0xe1d02d
mov al, 1
mov ecx, dword [ebp - 0xc]
pop ebx
mov dword fs:[0], ecx
leave
ret

Function at 0xe228f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8254], 1
jne 0xe22965
or dword [0xed8254], 1
mov dword [0xed3a54], 0xa9b0aa86
mov dword [0xed3a58], 0xaaabe5a1
mov dword [0xed3a5c], 0xa0a2e5b1
mov dword [0xed3a60], 0xaca1e5b1
mov dword [0xed3a64], 0xa1acb5b6
mov dword [0xed3a68], 0xe5a3aae5
mov dword [0xed3a6c], 0xadb1a0a8
mov dword [0xed3a70], 0xe2e5a1aa
mov dword [0xed3a74], 0xa9a9a4a6
mov dword [0xed3a78], 0xc5e5ffe2
xor eax, eax
mov cl, byte [eax + 0xed3a54]
xor cl, 0xc5
mov byte [eax + 0xed3b98], cl
inc eax
cmp eax, 0x28
jb 0xe22967
mov eax, 0xed3b98
ret

Function at 0xe22982
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8250], 1
jne 0xe229e9
or dword [0xed8250], 1
mov dword [0xed3a7c], 0xa9aca483
mov dword [0xed3a80], 0xb1e5a1a0
mov dword [0xed3a84], 0xabace5aa
mov dword [0xed3a88], 0xa0aeaab3
mov dword [0xed3a8c], 0xb1a0a8e5
mov dword [0xed3a90], 0xe5a1aaad
mov dword [0xed3a94], 0xa9a4a6e2
mov dword [0xed3a98], 0xe5ffe2a9
mov byte [0xed3a9c], 0xc5
xor eax, eax
mov cl, byte [eax + 0xed3a7c]
xor cl, 0xc5
mov byte [eax + 0xed3bc0], cl
inc eax
cmp eax, 0x21
jb 0xe229eb
mov eax, 0xed3bc0
ret
Function at 0xe22a06
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed824c], 1
jne 0xe22a66
or dword [0xed824c], 1
mov dword [0xed3aa0], 0xaab795cf
mov dword [0xed3aa4], 0xa9a7a4a7
mov dword [0xed3aa8], 0xb0a1e5bc
mov dword [0xed3aac], 0xaab1e5a0
mov dword [0xed3ab0], 0xb7a6b6e5
mov dword [0xed3ab4], 0xe5b1b5ac
mov dword [0xed3ab8], 0xaab7b7a0
mov dword [0xed3abc], 0xc5e5ffb7
xor eax, eax
mov cl, byte [eax + 0xed3aa0]
xor cl, 0xc5
mov byte [eax + 0xed3be4], cl
inc eax
cmp eax, 0x20
jb 0xe22a68
mov eax, 0xed3be4
ret

Function at 0xe2302e
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push ecx
and dword [ebp - 4], 0
cmp dword [ebp + 0xc], 0
push ebx
push esi
push edi
mov edi, eax
jbe 0xe23173
mov ebx, dword [ebp + 8]
push 4
sub ebx, edi
pop esi
test byte [0xed8248], 1
jne 0xe23090
or dword [0xed8248], 1
mov eax, 0xb1b6
mov word [0xed3ac0], ax
add eax, 0xffffffea
mov word [0xed3ac2], ax
mov eax, 0xb1ab
mov word [0xed3ac4], ax
add eax, 0xfffffff6
mov word [0xed3ac6], ax
mov eax, 0xb1c5
mov word [0xed3ac8], ax
xor eax, eax
mov ecx, 0xb1c5
xor cx, word [eax + 0xed3ac0]
add eax, 2
mov word [eax + 0xed3c02], cx
cmp eax, 0xa
jb 0xe23092
mov eax, dword [ebx + edi]
mov ecx, 0xed3c04
mov dx, word [eax]
cmp dx, word [ecx]
jne 0xe230d9
test dx, dx
je 0xe230d5
mov dx, word [eax + 2]
cmp dx, word [ecx + 2]
jne 0xe230d9
add eax, esi
add ecx, esi
test dx, dx
jne 0xe230b5
xor eax, eax
jmp 0xe230de
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xe230ea
mov dword [edi], 0x385
jmp 0xe23162
call fcn.00e23183
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xe23116
test dx, dx
je 0xe23112
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xe23116
add ecx, esi
add eax, esi
test dx, dx
jne 0xe230f2
xor eax, eax
jmp 0xe2311b
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xe23127
mov dword [edi], 0x386
jmp 0xe23162
call fcn.00e23256
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xe23153
test dx, dx
je 0xe2314f
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xe23153
add ecx, esi
add eax, esi
test dx, dx
jne 0xe2312f
xor eax, eax
jmp 0xe23158
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xe2317c
mov dword [edi], 0x387
inc dword [ebp - 4]
mov eax, dword [ebp - 4]
add edi, esi
cmp eax, dword [ebp + 0xc]
jb 0xe2304d
xor eax, eax
pop edi
pop esi
pop ebx
leave
ret 8
mov eax, 0x80020006
jmp 0xe23175
Function at 0xe23183
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8244], 1
jne 0xe23233
or dword [0xed8244], 1
mov eax, 0xb1a4
mov word [0xed3acc], ax
add eax, 0xfffffffd
mov ecx, eax
mov word [0xed3ad0], ax
mov eax, 0xb180
mov word [0xed3ad2], ax
add eax, 0x33
mov word [0xed3ad4], ax
mov eax, 0xb1a0
mov word [0xed3ace], cx
mov ecx, eax
lea edx, [eax + 0xb]
mov word [0xed3ad6], cx
mov ecx, edx
push edi
mov word [0xed3ad8], cx
add ecx, 6
mov edi, ecx
mov word [0xed3ada], di
lea edi, [eax - 0x17]
mov word [0xed3adc], di
add edi, 0x23
mov ecx, eax
add eax, 0x17
mov word [0xed3aea], ax
lea eax, [ecx + 0x25]
mov word [0xed3ade], di
mov dword [0xed3ae0], 0xb1b1b1b6
mov word [0xed3ae4], cx
mov dword [0xed3ae6], 0xb1a0b1ab
mov word [0xed3aec], ax
pop edi
xor eax, eax
mov ecx, 0xb1c5
xor cx, word [eax + 0xed3acc]
add eax, 2
mov word [eax + 0xed3c0e], cx
cmp eax, 0x22
jb 0xe23235
mov eax, 0xed3c10
ret

Function at 0xe23256
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8240], 1
mov ecx, 0xb1c5
jne 0xe232b0
or dword [0xed8240], 1
lea eax, [ecx - 0x12]
mov word [0xed3af0], ax
add eax, 0xffffffed
mov word [0xed3af2], ax
lea eax, [ecx - 0xe]
mov word [0xed3af4], ax
dec eax
mov word [0xed3af6], ax
lea eax, [ecx - 0x19]
mov word [0xed3af8], ax
add eax, 0xfffffffe
mov word [0xed3afa], ax
lea eax, [ecx - 0x1a]
mov word [0xed3afc], ax
mov eax, ecx
mov word [0xed3afe], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed3af0]
add eax, 2
mov word [eax + 0xed3c32], dx
cmp eax, 0x10
jb 0xe232b2
mov eax, 0xed3c34
ret

Function at 0xe23c23
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed823c], 1
mov edx, 0xb1c5
jne 0xe23c86
or dword [0xed823c], 1
lea ecx, [edx - 0x25]
mov eax, ecx
mov word [0xed3b00], ax
add eax, 0x17
push esi
mov esi, eax
lea eax, [edx - 0x3c]
mov word [0xed3b0a], ax
add eax, 0x23
mov word [0xed3b0c], ax
mov eax, edx
mov word [0xed3b02], si
mov word [0xed3b04], si
mov dword [0xed3b06], 0xb1b7b1aa
mov dword [0xed3b0e], 0xb1a0b1ab
mov word [0xed3b12], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xed3b00]
add eax, 2
mov word [eax + 0xed3c42], cx
cmp eax, 0x14
jb 0xe23c88
mov eax, 0xed3c44
ret

Function at 0xe23ca6
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8238], 1
jne 0xe23d42
or dword [0xed8238], 1
mov edx, 0xb1a0
mov eax, edx
mov word [0xed3b14], ax
add eax, 0x17
mov ecx, eax
mov word [0xed3b16], cx
mov word [0xed3b18], cx
lea ecx, [edx + 0xa]
mov word [0xed3b1a], cx
mov ecx, eax
mov word [0xed3b1c], cx
lea ecx, [edx - 0x1a]
mov word [0xed3b1e], cx
add ecx, 0x27
mov word [0xed3b20], cx
lea ecx, [edx + 4]
push edi
mov edi, ecx
mov word [0xed3b22], di
mov edi, eax
mov word [0xed3b26], cx
mov word [0xed3b2e], ax
add ecx, 2
lea eax, [edx + 0x25]
mov word [0xed3b24], di
mov word [0xed3b28], cx
mov dword [0xed3b2a], 0xb1a0b1b1
mov word [0xed3b30], ax
pop edi
xor eax, eax
mov ecx, 0xb1c5
xor cx, word [eax + 0xed3b14]
add eax, 2
mov word [eax + 0xed3c56], cx
cmp eax, 0x1e
jb 0xe23d44
mov eax, 0xed3c58
ret
Function at 0xe23d65
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8234], 1
jne 0xe23dc6
or dword [0xed8234], 1
mov edx, 0xb1a0
mov eax, edx
mov word [0xed3b34], ax
add eax, 0x17
mov ecx, eax
mov word [0xed3b36], cx
mov word [0xed3b38], cx
push edi
lea ecx, [edx + 0xa]
mov edi, ecx
mov word [0xed3b3c], ax
lea eax, [edx + 0x25]
mov word [0xed3b3a], di
mov dword [0xed3b3e], 0xb1aab186
mov dword [0xed3b42], 0xb1a0b1a1
mov word [0xed3b46], ax
pop edi
xor eax, eax
mov ecx, 0xb1c5
xor cx, word [eax + 0xed3b34]
add eax, 2
mov word [eax + 0xed3c76], cx
cmp eax, 0x14
jb 0xe23dc8
mov eax, 0xed3c78
ret

Function at 0xe23de9
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8230], 1
mov edx, 0xb1c5
jne 0xe23e66
or dword [0xed8230], 1
lea ecx, [edx - 0x25]
mov eax, ecx
mov word [0xed3b48], ax
add eax, 0x17
push esi
mov esi, eax
lea eax, [edx - 0x3d]
mov word [0xed3b52], ax
mov eax, ecx
mov word [0xed3b54], ax
add eax, 0x16
mov word [0xed3b4a], si
mov word [0xed3b4c], si
mov esi, eax
mov word [0xed3b58], ax
lea eax, [edx - 0x21]
mov word [0xed3b5a], ax
mov eax, edx
mov word [0xed3b56], si
mov dword [0xed3b4e], 0xb1b7b1aa
mov dword [0xed3b5c], 0xb1a0b1a2
mov word [0xed3b60], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xed3b48]
add eax, 2
mov word [eax + 0xed3c8a], cx
cmp eax, 0x1a
jb 0xe23e68
mov eax, 0xed3c8c
ret

Function at 0xe23e86
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed822c], 1
mov ecx, 0xb1c5
jne 0xe23ee5
or dword [0xed822c], 1
lea eax, [ecx - 0x25]
mov word [0xed3b64], ax
add eax, 0x17
mov edx, eax
mov word [0xed3b66], dx
mov word [0xed3b68], dx
lea edx, [ecx - 0x1b]
mov word [0xed3b6a], dx
mov edx, eax
lea eax, [ecx - 0x1c]
mov word [0xed3b72], ax
mov eax, ecx
mov word [0xed3b6c], dx
mov dword [0xed3b6e], 0xb1b7b190
mov word [0xed3b74], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed3b64]
add eax, 2
mov word [eax + 0xed3ca6], dx
cmp eax, 0x12
jb 0xe23ee7
mov eax, 0xed3ca8
ret

Function at 0xe2458a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8228], 1
jne 0xe245b4
or dword [0xed8228], 1
mov dword [0xed3b78], 0xa9b0abf9
mov word [0xed3b7c], 0xfba9
mov byte [0xed3b7e], 0xc5
xor eax, eax
mov cl, byte [eax + 0xed3b78]
xor cl, 0xc5
mov byte [eax + 0xed3cbc], cl
inc eax
cmp eax, 7
jb 0xe245b6
mov eax, 0xed3cbc
ret

Function at 0xe245d1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8224], 1
jne 0xe245fb
or dword [0xed8224], 1
mov dword [0xed3b80], 0xa9b0abf9
mov word [0xed3b84], 0xfba9
mov byte [0xed3b86], 0xc5
xor eax, eax
mov cl, byte [eax + 0xed3b80]
xor cl, 0xc5
mov byte [eax + 0xed3cc4], cl
inc eax
cmp eax, 7
jb 0xe245fd
mov eax, 0xed3cc4
ret

Function at 0xe24618
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed821c], 1
jne 0xe2463c
or dword [0xed821c], 1
mov dword [0xed3b8c], 0xaaa69ee5
mov dword [0xed3b90], 0xc5f8a0a1
xor eax, eax
mov cl, byte [eax + 0xed3b8c]
xor cl, 0xc5
mov byte [eax + 0xed3cd0], cl
inc eax
cmp eax, 8
jb 0xe2463e
mov eax, 0xed3cd0
ret
Function at 0xe25387
Capabilities:
Encode data using xor

Disassembly:
push esi
push edi
push 0x31
pop ecx
mov esi, 0xea6d38
mov edi, 0xed8620
push 0xea6dfc
rep movsd dword es:[edi], dword [esi]
call fcn.00e5f4e0
pop ecx
pop edi
pop esi
cmp eax, 0xffffffff
jne 0xe253ad
xor al, al
ret
push 0xea6bc0
call fcn.00e5f430
pop ecx
cmp eax, 0xffffffff
je 0xe253aa
push 0xea6e90
call fcn.00e5e680
pop ecx
cmp eax, 0xffffffff
je 0xe253aa
test byte [0xed8210], 1
jne 0xe253ee
or dword [0xed8210], 1
mov dword [0xed3cf0], 0xf6a6afb4
mov byte [0xed3cf4], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3cf0]
xor cl, 0xc7
mov byte [eax + 0xed3dbc], cl
inc eax
cmp eax, 5
jb 0xe253f0
push 0xed3dbc
call fcn.00e5f550
pop ecx
mov dword [0xecd928], eax
test eax, eax
js 0xe253aa
call fcn.00e25479
push eax
call fcn.00e5e6f0
pop ecx
mov dword [0xecd92c], eax
test eax, eax
js 0xe253aa
test byte [0xed8208], 1
jne 0xe2544c
or dword [0xed8208], 1
mov dword [0xed3d00], 0xc7b4a2a6
xor eax, eax
mov cl, byte [eax + 0xed3d00]
xor cl, 0xc7
mov byte [eax + 0xed3dcc], cl
inc eax
cmp eax, 4
jb 0xe2544e
push 0xed3dcc
call fcn.00e5f4a0
test eax, eax
mov dword [0xecd930], eax
pop ecx
setns al
ret

Function at 0xe25479
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed820c], 1
jne 0xe2549d
or dword [0xed820c], 1
mov dword [0xed3cf8], 0xb3b5a8a1
mov dword [0xed3cfc], 0xc7a6a9b2
xor eax, eax
mov cl, byte [eax + 0xed3cf8]
xor cl, 0xc7
mov byte [eax + 0xed3dc4], cl
inc eax
cmp eax, 8
jb 0xe2549f
mov eax, 0xed3dc4
ret

Function at 0xe2571d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8204], 1
jne 0xe2575b
or dword [0xed8204], 1
mov dword [0xed3d04], 0xaee7b7aa
mov dword [0xed3d08], 0xe7b3aea9
mov dword [0xed3d0c], 0xabaea6a1
mov word [0xed3d10], 0xa3a2
mov byte [0xed3d12], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d04]
xor cl, 0xc7
mov byte [eax + 0xed3dd0], cl
inc eax
cmp eax, 0xf
jb 0xe2575d
mov eax, 0xed3dd0
ret

Function at 0xe25778
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8200], 1
jne 0xe257b6
or dword [0xed8200], 1
mov dword [0xed3d14], 0xaee7b7aa
mov dword [0xed3d18], 0xe7b3aea9
mov dword [0xed3d1c], 0xabaea6a1
mov word [0xed3d20], 0xa3a2
mov byte [0xed3d22], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d14]
xor cl, 0xc7
mov byte [eax + 0xed3de0], cl
inc eax
cmp eax, 0xf
jb 0xe257b8
mov eax, 0xed3de0
ret

Function at 0xe257d3
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81fc], 1
jne 0xe25811
or dword [0xed81fc], 1
mov dword [0xed3d24], 0x98b3a2b4
mov dword [0xed3d28], 0xe7b3a9ae
mov dword [0xed3d2c], 0xabaea6a1
mov word [0xed3d30], 0xa3a2
mov byte [0xed3d32], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d24]
xor cl, 0xc7
mov byte [eax + 0xed3df0], cl
inc eax
cmp eax, 0xf
jb 0xe25813
mov eax, 0xed3df0
ret
Function at 0xe2582e
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81f8], 1
jne 0xe25877
or dword [0xed81f8], 1
mov dword [0xed3d34], 0xaeb4a9b2
mov dword [0xed3d38], 0xa3a2a9a0
mov dword [0xed3d3c], 0xa6a2b598
mov dword [0xed3d40], 0xa6a1e7a3
mov dword [0xed3d44], 0xa3a2abae
mov byte [0xed3d48], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d34]
xor cl, 0xc7
mov byte [eax + 0xed3e00], cl
inc eax
cmp eax, 0x15
jb 0xe25879
mov eax, 0xed3e00
ret

Function at 0xe25894
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81f4], 1
jne 0xe258d3
or dword [0xed81f4], 1
mov dword [0xed3d4c], 0xa0a9b5b7
mov dword [0xed3d50], 0xaca6aae7
mov dword [0xed3d54], 0xa6a1e7a2
mov dword [0xed3d58], 0xa3a2abae
mov byte [0xed3d5c], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d4c]
xor cl, 0xc7
mov byte [eax + 0xed3e18], cl
inc eax
cmp eax, 0x11
jb 0xe258d5
mov eax, 0xed3e18
ret

Function at 0xe258f0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81f0], 1
jne 0xe25932
or dword [0xed81f0], 1
mov dword [0xed3d60], 0xb3b5a8a1
mov dword [0xed3d64], 0x98a6a9b2
mov dword [0xed3d68], 0xa3a6a2b5
mov dword [0xed3d6c], 0xaea6a1e7
mov dword [0xed3d70], 0xc7a3a2ab
xor eax, eax
mov cl, byte [eax + 0xed3d60]
xor cl, 0xc7
mov byte [eax + 0xed3e2c], cl
inc eax
cmp eax, 0x14
jb 0xe25934
mov eax, 0xed3e2c
ret

Function at 0xe2594f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81ec], 1
jne 0xe25997
or dword [0xed81ec], 1
mov dword [0xed3d74], 0xb7beb5a4
mov dword [0xed3d78], 0xaee7a8b3
mov dword [0xed3d7c], 0xe7b3aea9
mov dword [0xed3d80], 0xabaea6a1
mov word [0xed3d84], 0xa3a2
mov byte [0xed3d86], 0xc7
xor eax, eax
mov cl, byte [eax + 0xed3d74]
xor cl, 0xc7
mov byte [eax + 0xed3e40], cl
inc eax
cmp eax, 0x13
jb 0xe25999
mov eax, 0xed3e40
ret

Function at 0xe25bac
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81e8], 1
jne 0xe25bcf
or dword [0xed81e8], 1
mov dword [0xed3d88], 0xa3b4b4ae
mov word [0xed3d8c], 0xc7ac
xor eax, eax
mov cl, byte [eax + 0xed3d88]
xor cl, 0xc7
mov byte [eax + 0xed3e54], cl
inc eax
cmp eax, 6
jb 0xe25bd1
mov eax, 0xed3e54
ret

Function at 0xe25bec
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81e4], 1
jne 0xe25c19
or dword [0xed81e4], 1
mov dword [0xed3d90], 0xa5b5b2af
mov dword [0xed3d94], 0xb5b2a3a6
mov word [0xed3d98], 0xc7b5
xor eax, eax
mov cl, byte [eax + 0xed3d90]
xor cl, 0xc7
mov byte [eax + 0xed3e5c], cl
inc eax
cmp eax, 0xa
jb 0xe25c1b
mov eax, 0xed3e5c
ret

Function at 0xe25cf9
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81e0], 1
jne 0xe25d26
or dword [0xed81e0], 1
mov dword [0xed3d9c], 0xa5b5b2af
mov dword [0xed3da0], 0xb5b2a3a6
mov word [0xed3da4], 0xc7b5
xor eax, eax
mov cl, byte [eax + 0xed3d9c]
xor cl, 0xc7
mov byte [eax + 0xed3e68], cl
inc eax
cmp eax, 0xa
jb 0xe25d28
mov eax, 0xed3e68
ret
Function at 0xe2640a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81dc], 1
jne 0xe26452
or dword [0xed81dc], 1
mov dword [0xed3e74], 0xb9b0bbaa
mov dword [0xed3e78], 0xa0e9a6bd
mov dword [0xed3e7c], 0xe9bda0a7
mov dword [0xed3e80], 0xa5a0a8af
mov word [0xed3e84], 0xadac
mov byte [0xed3e86], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3e74]
xor cl, 0xc9
mov byte [eax + 0xed3f88], cl
inc eax
cmp eax, 0x13
jb 0xe26454
mov eax, 0xed3f88
ret

Function at 0xe2646f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81d8], 1
jne 0xe264b7
or dword [0xed81d8], 1
mov dword [0xed3e88], 0xb9b0bbaa
mov dword [0xed3e8c], 0xa0e9a6bd
mov dword [0xed3e90], 0xe9bda0a7
mov dword [0xed3e94], 0xa5a0a8af
mov word [0xed3e98], 0xadac
mov byte [0xed3e9a], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3e88]
xor cl, 0xc9
mov byte [eax + 0xed3f9c], cl
inc eax
cmp eax, 0x13
jb 0xe264b9
mov eax, 0xed3f9c
ret

Function at 0xe264d4
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81d0], 1
jne 0xe2651c
or dword [0xed81d0], 1
mov dword [0xed3ea4], 0xb9b0bbaa
mov dword [0xed3ea8], 0xa0e9a6bd
mov dword [0xed3eac], 0xe9bda0a7
mov dword [0xed3eb0], 0xa5a0a8af
mov word [0xed3eb4], 0xadac
mov byte [0xed3eb6], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3ea4]
xor cl, 0xc9
mov byte [eax + 0xed3fb8], cl
inc eax
cmp eax, 0x13
jb 0xe2651e
mov eax, 0xed3fb8
ret

Function at 0xe26539
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81c8], 1
jne 0xe26581
or dword [0xed81c8], 1
mov dword [0xed3ebc], 0xb9b0bbaa
mov dword [0xed3ec0], 0xa0e9a6bd
mov dword [0xed3ec4], 0xe9bda0a7
mov dword [0xed3ec8], 0xa5a0a8af
mov word [0xed3ecc], 0xadac
mov byte [0xed3ece], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3ebc]
xor cl, 0xc9
mov byte [eax + 0xed3fd0], cl
inc eax
cmp eax, 0x13
jb 0xe26583
mov eax, 0xed3fd0
ret

Function at 0xe2659e
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81c4], 1
jne 0xe265d5
or dword [0xed81c4], 1
mov dword [0xed3ed0], 0xb9b0bbaa
mov dword [0xed3ed4], 0xafe9a6bd
mov dword [0xed3ed8], 0xaca5a0a8
mov word [0xed3edc], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3ed0]
xor cl, 0xc9
mov byte [eax + 0xed3fe4], cl
inc eax
cmp eax, 0xe
jb 0xe265d7
mov eax, 0xed3fe4
ret

Function at 0xe265f2
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81c0], 1
jne 0xe26629
or dword [0xed81c0], 1
mov dword [0xed3ee0], 0xb9b0bbaa
mov dword [0xed3ee4], 0xafe9a6bd
mov dword [0xed3ee8], 0xaca5a0a8
mov word [0xed3eec], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3ee0]
xor cl, 0xc9
mov byte [eax + 0xed3ff4], cl
inc eax
cmp eax, 0xe
jb 0xe2662b
mov eax, 0xed3ff4
ret

Function at 0xe26646
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81bc], 1
jne 0xe26673
or dword [0xed81bc], 1
mov dword [0xed3ef0], 0xb9bbaca1
mov dword [0xed3ef4], 0xbbacade2
mov word [0xed3ef8], 0xc9b9
xor eax, eax
mov cl, byte [eax + 0xed3ef0]
xor cl, 0xc9
mov byte [eax + 0xed4004], cl
inc eax
cmp eax, 0xa
jb 0xe26675
mov eax, 0xed4004
ret
Function at 0xe26690
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81b8], 1
jne 0xe266c7
or dword [0xed81b8], 1
mov dword [0xed3efc], 0xb9b0bbaa
mov dword [0xed3f00], 0xafe9a6bd
mov dword [0xed3f04], 0xaca5a0a8
mov word [0xed3f08], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3efc]
xor cl, 0xc9
mov byte [eax + 0xed4010], cl
inc eax
cmp eax, 0xe
jb 0xe266c9
mov eax, 0xed4010
ret

Function at 0xe266e4
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81b4], 1
jne 0xe2671b
or dword [0xed81b4], 1
mov dword [0xed3f0c], 0xb9b0bbaa
mov dword [0xed3f10], 0xafe9a6bd
mov dword [0xed3f14], 0xaca5a0a8
mov word [0xed3f18], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3f0c]
xor cl, 0xc9
mov byte [eax + 0xed4020], cl
inc eax
cmp eax, 0xe
jb 0xe2671d
mov eax, 0xed4020
ret

Function at 0xe267e9
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81b0], 1
jne 0xe26820
or dword [0xed81b0], 1
mov dword [0xed3f1c], 0xb9b0bbaa
mov dword [0xed3f20], 0xafe9a6bd
mov dword [0xed3f24], 0xaca5a0a8
mov word [0xed3f28], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3f1c]
xor cl, 0xc9
mov byte [eax + 0xed4030], cl
inc eax
cmp eax, 0xe
jb 0xe26822
mov eax, 0xed4030
ret

Function at 0xe269cf
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81ac], 1
jne 0xe26a06
or dword [0xed81ac], 1
mov dword [0xed3f2c], 0xb9b0bbaa
mov dword [0xed3f30], 0xafe9a6bd
mov dword [0xed3f34], 0xaca5a0a8
mov word [0xed3f38], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3f2c]
xor cl, 0xc9
mov byte [eax + 0xed4040], cl
inc eax
cmp eax, 0xe
jb 0xe26a08
mov eax, 0xed4040
ret

Function at 0xe26a23
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81a8], 1
jne 0xe26a5a
or dword [0xed81a8], 1
mov dword [0xed3f3c], 0xb9b0bbaa
mov dword [0xed3f40], 0xafe9a6bd
mov dword [0xed3f44], 0xaca5a0a8
mov word [0xed3f48], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3f3c]
xor cl, 0xc9
mov byte [eax + 0xed4050], cl
inc eax
cmp eax, 0xe
jb 0xe26a5c
mov eax, 0xed4050
ret