joyce8/EMBER2024-capa huggingface dataset:
Function at 0x8e2811
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
sub esp, 0x7c
test byte [0x988dfc], 1
push ebx
mov ebx, dword [ebp + 8]
push esi
push edi
mov ecx, 0xbce0
jne 0x8e284f
or dword [0x988dfc], 1
lea eax, [ecx - 0x49]
mov word [0x982a24], ax
add eax, 0xffffffeb
mov word [0x982a26], ax
mov eax, ecx
mov word [0x982a28], ax
xor esi, esi
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x982a24]
add eax, 2
mov word [eax + 0x9830ce], dx
cmp eax, 6
jb 0x8e2853
lea eax, [ebx + 0xc]
cmp dword [eax + 0x14], 8
jb 0x8e2876
mov eax, dword [eax]
push 0x9830d0
push eax
lea eax, [esp + 0x18]
push eax
call fcn.0092b957
add esp, 0xc
test eax, eax
jne 0x8e2941
push dword [esp + 0x10]
push dword [ebp + 0xc]
push ebx
call fcn.008e35a4
push dword [esp + 0x10]
call fcn.008e294a
push eax
call fcn.0092beb1
push dword [esp + 0x18]
call fcn.0092c43c
add esp, 0xc
push 0x44
pop edi
push edi
lea eax, [esp + 0x44]
push esi
push eax
call fcn.0092f010
add esp, 0xc
mov dword [esp + 0x40], edi
xor eax, eax
lea ecx, [esp + 0x14]
push ecx
lea edi, [esp + 0x18]
stosd dword es:[edi], eax
lea ecx, [esp + 0x44]
push ecx
push esi
push esi
stosd dword es:[edi], eax
push esi
push esi
stosd dword es:[edi], eax
push esi
stosd dword es:[edi], eax
mov eax, dword [ebx + 0x28]
push esi
push eax
push esi
call dword [0x95a08c]
test eax, eax
jne 0x8e292f
call dword [0x95a0a8]
push eax
lea eax, [esp + 0x28]
push eax
call fcn.0090a8be
cmp dword [eax + 0x14], 0x10
pop ecx
pop ecx
jb 0x8e2913
mov eax, dword [eax]
push eax
call fcn.008e298a
push eax
call fcn.0092c180
pop ecx
pop ecx
push esi
push 1
lea ecx, [esp + 0x2c]
call fcn.008e4ce6
jmp 0x8e2941
push dword [esp + 0x18]
mov esi, dword [0x95a0bc]
call esi
push dword [esp + 0x14]
call esi
pop edi
pop esi
pop ebx
mov esp, ebp
pop ebp
ret 8

Function at 0x8e294a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988df8], 1
jne 0x8e296d
or dword [0x988df8], 1
mov dword [0x982a2c], 0xaea5eaed
mov word [0x982a30], 0xe0a4
xor eax, eax
mov cl, byte [eax + 0x982a2c]
xor cl, 0xe0
mov byte [eax + 0x9830d8], cl
inc eax
cmp eax, 6
jb 0x8e296f
mov eax, 0x9830d8
ret

Function at 0x8e298a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988df4], 1
jne 0x8e2a0f
or dword [0x988df4], 1
mov dword [0x982a34], 0x8c8981a6
mov dword [0x982a38], 0x94c08485
mov dword [0x982a3c], 0x9283c08f
mov dword [0x982a40], 0x85948185
mov dword [0x982a44], 0x819283c0
mov dword [0x982a48], 0x92c08893
mov dword [0x982a4c], 0x928f9085
mov dword [0x982a50], 0xc0928594
mov dword [0x982a54], 0x838f9290
mov dword [0x982a58], 0xda939385
mov dword [0x982a5c], 0xea93c5c0
mov byte [0x982a60], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982a34]
xor cl, 0xe0
mov byte [eax + 0x9830e0], cl
inc eax
cmp eax, 0x2d
jb 0x8e2a11
mov eax, 0x9830e0
ret
Function at 0x8e3ad9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d94], 1
jne 0x8e3b0e
or dword [0x988d94], 1
mov dword [0x982ce0], 0x95848fad
mov dword [0x982ce4], 0xc0da858c
mov dword [0x982ce8], 0xeaed93c5
mov byte [0x982cec], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982ce0]
xor cl, 0xe0
mov byte [eax + 0x98338c], cl
inc eax
cmp eax, 0xd
jb 0x8e3b10
mov eax, 0x98338c
ret

Function at 0x8e3b2b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d90], 1
jne 0x8e3b6a
or dword [0x988d90], 1
mov dword [0x982cf0], 0x859288b4
mov dword [0x982cf4], 0xc0da8481
mov dword [0x982cf8], 0x98c598d0
mov dword [0x982cfc], 0xeaedeaed
mov byte [0x982d00], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982cf0]
xor cl, 0xe0
mov byte [eax + 0x98339c], cl
inc eax
cmp eax, 0x11
jb 0x8e3b6c
mov eax, 0x98339c
ret

Function at 0x8e3b87
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d8c], 1
jne 0x8e3bc5
or dword [0x988d8c], 1
mov dword [0x982d04], 0x858398a5
mov dword [0x982d08], 0x8f899490
mov dword [0x982d0c], 0x84c5c08e
mov word [0x982d10], 0xeaed
mov byte [0x982d12], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982d04]
xor cl, 0xe0
mov byte [eax + 0x9833b0], cl
inc eax
cmp eax, 0xf
jb 0x8e3bc7
mov eax, 0x9833b0
ret

Function at 0x8e3be2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d88], 1
jne 0x8e3c20
or dword [0x988d88], 1
mov dword [0x982d14], 0x81838fac
mov dword [0x982d18], 0x8e8f8994
mov dword [0x982d1c], 0x90c5c0da
mov word [0x982d20], 0xeaed
mov byte [0x982d22], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982d14]
xor cl, 0xe0
mov byte [eax + 0x9833c0], cl
inc eax
cmp eax, 0xf
jb 0x8e3c22
mov eax, 0x9833c0
ret

Function at 0x8e3c3d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d84], 1
jne 0x8e3c7e
or dword [0x988d84], 1
mov dword [0x982d24], 0x859099b4
mov dword [0x982d28], 0x93c5c0da
mov dword [0x982d2c], 0x98d0c8c0
mov dword [0x982d30], 0xedc998c5
mov word [0x982d34], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982d24]
xor cl, 0xe0
mov byte [eax + 0x9833d0], cl
inc eax
cmp eax, 0x12
jb 0x8e3c80
mov eax, 0x9833d0
ret

Function at 0x8e3c9b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d80], 1
jne 0x8e3d23
or dword [0x988d80], 1
mov dword [0x982d38], 0x819485a4
mov dword [0x982d3c], 0xda938c89
mov dword [0x982d40], 0x8992b4c0
mov dword [0x982d44], 0x94c08485
mov dword [0x982d48], 0x8592c08f
mov dword [0x982d4c], 0x86c08481
mov dword [0x982d50], 0xc08d8f92
mov dword [0x982d54], 0x8f8d858d
mov dword [0x982d58], 0x81c09992
mov dword [0x982d5c], 0x85928484
mov dword [0x982d60], 0xc5c09393
mov dword [0x982d64], 0xe0eaed90
xor eax, eax
mov cl, byte [eax + 0x982d38]
xor cl, 0xe0
mov byte [eax + 0x9833e4], cl
inc eax
cmp eax, 0x30
jb 0x8e3d25
mov eax, 0x9833e4
ret
Function at 0x8e3d40
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d7c], 1
jne 0x8e3dd2
or dword [0x988d7c], 1
mov dword [0x982d68], 0x819485a4
mov dword [0x982d6c], 0xda938c89
mov dword [0x982d70], 0x8992b4c0
mov dword [0x982d74], 0x94c08485
mov dword [0x982d78], 0x9297c08f
mov dword [0x982d7c], 0xc0859489
mov dword [0x982d80], 0x8dc08f94
mov dword [0x982d84], 0x928f8d85
mov dword [0x982d88], 0x8481c099
mov dword [0x982d8c], 0x93859284
mov dword [0x982d90], 0x90c5c093
mov word [0x982d94], 0xeaed
mov byte [0x982d96], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982d68]
xor cl, 0xe0
mov byte [eax + 0x983414], cl
inc eax
cmp eax, 0x2f
jb 0x8e3dd4
mov eax, 0x983414
ret

Function at 0x8e3def
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d78], 1
jne 0x8e3e82
or dword [0x988d78], 1
mov dword [0x982d98], 0x819485a4
mov dword [0x982d9c], 0xda938c89
mov dword [0x982da0], 0x8992b4c0
mov dword [0x982da4], 0x94c08485
mov dword [0x982da8], 0x9885c08f
mov dword [0x982dac], 0x94958385
mov dword [0x982db0], 0x858dc085
mov dword [0x982db4], 0x99928f8d
mov dword [0x982db8], 0xc09481c0
mov dword [0x982dbc], 0x92848481
mov dword [0x982dc0], 0xc0939385
mov dword [0x982dc4], 0xeaed90c5
mov byte [0x982dc8], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982d98]
xor cl, 0xe0
mov byte [eax + 0x983444], cl
inc eax
cmp eax, 0x31
jb 0x8e3e84
mov eax, 0x983444
ret

Function at 0x8e3e9f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d74], 1
jne 0x8e3ed6
or dword [0x988d74], 1
mov dword [0x982dcc], 0x87818ca6
mov dword [0x982dd0], 0xd0c0da93
mov dword [0x982dd4], 0xed98c598
mov word [0x982dd8], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982dcc]
xor cl, 0xe0
mov byte [eax + 0x983478], cl
inc eax
cmp eax, 0xe
jb 0x8e3ed8
mov eax, 0x983478
ret

Function at 0x8e3ef3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d70], 1
jne 0x8e3f2a
or dword [0x988d70], 1
mov dword [0x982ddc], 0x819281b0
mov dword [0x982de0], 0x8594858d
mov dword [0x982de4], 0xedda9392
mov word [0x982de8], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982ddc]
xor cl, 0xe0
mov byte [eax + 0x983488], cl
inc eax
cmp eax, 0xe
jb 0x8e3f2c
mov eax, 0x983488
ret

Function at 0x8e3f47
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d6c], 1
jne 0x8e3f90
or dword [0x988d6c], 1
mov dword [0x982dec], 0x9281b0e9
mov dword [0x982df0], 0x94858d81
mov dword [0x982df4], 0xc5bb9285
mov dword [0x982df8], 0xc0dabd84
mov dword [0x982dfc], 0xeaed90c5
mov byte [0x982e00], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982dec]
xor cl, 0xe0
mov byte [eax + 0x983498], cl
inc eax
cmp eax, 0x15
jb 0x8e3f92
mov eax, 0x983498
ret

Function at 0x8e3fb0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d68], 1
jne 0x8e3fe8
or dword [0x988d68], 1
mov dword [0x982e04], 0xc0a8a5b3
mov dword [0x982e08], 0x8c818ea1
mov dword [0x982e0c], 0x93899399
mov dword [0x982e10], 0xe0eaedda
xor eax, eax
mov cl, byte [eax + 0x982e04]
xor cl, 0xe0
mov byte [eax + 0x9834b0], cl
inc eax
cmp eax, 0x10
jb 0x8e3fea
mov eax, 0x9834b0
ret
Function at 0x8e4005
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d64], 1
jne 0x8e404d
or dword [0x988d64], 1
mov dword [0x982e14], 0x8a82afe9
mov dword [0x982e18], 0xc0948385
mov dword [0x982e1c], 0x85909994
mov dword [0x982e20], 0x93c5c0da
mov word [0x982e24], 0xeaed
mov byte [0x982e26], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982e14]
xor cl, 0xe0
mov byte [eax + 0x9834c0], cl
inc eax
cmp eax, 0x13
jb 0x8e404f
mov eax, 0x9834c0
ret

Function at 0x8e406a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d60], 1
jne 0x8e40d3
or dword [0x988d60], 1
mov dword [0x982e28], 0x8981a6e9
mov dword [0x982e2c], 0xc084858c
mov dword [0x982e30], 0x86c08f94
mov dword [0x982e34], 0x8f8c8c8f
mov dword [0x982e38], 0x8f90c097
mov dword [0x982e3c], 0x85948e89
mov dword [0x982e40], 0x8883c092
mov dword [0x982e44], 0xed8e8981
mov word [0x982e48], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982e28]
xor cl, 0xe0
mov byte [eax + 0x9834d4], cl
inc eax
cmp eax, 0x22
jb 0x8e40d5
mov eax, 0x9834d4
ret

Function at 0x8e40f0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d5c], 1
jne 0x8e4113
or dword [0x988d5c], 1
mov dword [0x982e4c], 0x849493a0
mov word [0x982e50], 0xe0a0
xor eax, eax
mov cl, byte [eax + 0x982e4c]
xor cl, 0xe0
mov byte [eax + 0x9834f8], cl
inc eax
cmp eax, 6
jb 0x8e4115
mov eax, 0x9834f8
ret

Function at 0x8e4130
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d58], 1
jne 0x8e4167
or dword [0x988d58], 1
mov dword [0x982e54], 0x948e9592
mov dword [0x982e58], 0xbf858d89
mov dword [0x982e5c], 0x8f929285
mov word [0x982e60], 0xe092
xor eax, eax
mov cl, byte [eax + 0x982e54]
xor cl, 0xe0
mov byte [eax + 0x983500], cl
inc eax
cmp eax, 0xe
jb 0x8e4169
mov eax, 0x983500
ret

Function at 0x8e4184
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d54], 1
jne 0x8e41b2
or dword [0x988d54], 1
mov dword [0x982e64], 0x878e8192
mov dword [0x982e68], 0x9285bf85
mov dword [0x982e6c], 0xe0928f92
xor eax, eax
mov cl, byte [eax + 0x982e64]
xor cl, 0xe0
mov byte [eax + 0x983510], cl
inc eax
cmp eax, 0xc
jb 0x8e41b4
mov eax, 0x983510
ret

Function at 0x8e41cf
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d50], 1
jne 0x8e420d
or dword [0x988d50], 1
mov dword [0x982e70], 0x9285968f
mov dword [0x982e74], 0x978f8c86
mov dword [0x982e78], 0x929285bf
mov word [0x982e7c], 0x928f
mov byte [0x982e7e], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982e70]
xor cl, 0xe0
mov byte [eax + 0x98351c], cl
inc eax
cmp eax, 0xf
jb 0x8e420f
mov eax, 0x98351c
ret

Function at 0x8e422a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d4c], 1
jne 0x8e4262
or dword [0x988d4c], 1
mov dword [0x982e80], 0x85848e95
mov dword [0x982e84], 0x8f8c8692
mov dword [0x982e88], 0x9285bf97
mov dword [0x982e8c], 0xe0928f92
xor eax, eax
mov cl, byte [eax + 0x982e80]
xor cl, 0xe0
mov byte [eax + 0x98352c], cl
inc eax
cmp eax, 0x10
jb 0x8e4264
mov eax, 0x98352c
ret
Function at 0x8e427f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d48], 1
jne 0x8e42ad
or dword [0x988d48], 1
mov dword [0x982e90], 0x89878f8c
mov dword [0x982e94], 0x9285bf83
mov dword [0x982e98], 0xe0928f92
xor eax, eax
mov cl, byte [eax + 0x982e90]
xor cl, 0xe0
mov byte [eax + 0x98353c], cl
inc eax
cmp eax, 0xc
jb 0x8e42af
mov eax, 0x98353c
ret

Function at 0x8e42ca
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d44], 1
jne 0x8e42ff
or dword [0x988d44], 1
mov dword [0x982e9c], 0x818d8f84
mov dword [0x982ea0], 0x85bf8e89
mov dword [0x982ea4], 0x928f9292
mov byte [0x982ea8], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982e9c]
xor cl, 0xe0
mov byte [eax + 0x983548], cl
inc eax
cmp eax, 0xd
jb 0x8e4301
mov eax, 0x983548
ret

Function at 0x8e431c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d40], 1
jne 0x8e435b
or dword [0x988d40], 1
mov dword [0x982eac], 0x81968e89
mov dword [0x982eb0], 0xbf84898c
mov dword [0x982eb4], 0x95879281
mov dword [0x982eb8], 0x948e858d
mov byte [0x982ebc], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982eac]
xor cl, 0xe0
mov byte [eax + 0x983558], cl
inc eax
cmp eax, 0x11
jb 0x8e435d
mov eax, 0x983558
ret

Function at 0x8e4378
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d3c], 1
jne 0x8e43ad
or dword [0x988d3c], 1
mov dword [0x982ec0], 0x878e858c
mov dword [0x982ec4], 0x85bf8894
mov dword [0x982ec8], 0x928f9292
mov byte [0x982ecc], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982ec0]
xor cl, 0xe0
mov byte [eax + 0x98356c], cl
inc eax
cmp eax, 0xd
jb 0x8e43af
mov eax, 0x98356c
ret

Function at 0x8e43ca
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d38], 1
jne 0x8e43ff
or dword [0x988d38], 1
mov dword [0x982ed0], 0xbf94958f
mov dword [0x982ed4], 0x92bf868f
mov dword [0x982ed8], 0x85878e81
mov byte [0x982edc], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982ed0]
xor cl, 0xe0
mov byte [eax + 0x98357c], cl
inc eax
cmp eax, 0xd
jb 0x8e4401
mov eax, 0x98357c
ret

Function at 0x8e441c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d34], 1
jne 0x8e4449
or dword [0x988d34], 1
mov dword [0x982ee0], 0x85839885
mov dword [0x982ee4], 0x8f899490
mov word [0x982ee8], 0xe08e
xor eax, eax
mov cl, byte [eax + 0x982ee0]
xor cl, 0xe0
mov byte [eax + 0x98358c], cl
inc eax
cmp eax, 0xa
jb 0x8e444b
mov eax, 0x98358c
ret

Function at 0x8e4466
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d30], 1
jne 0x8e44c5
or dword [0x988d30], 1
mov dword [0x982eec], 0x849493e9
mov dword [0x982ef0], 0x9885dada
mov dword [0x982ef4], 0x94908583
mov dword [0x982ef8], 0xda8e8f89
mov dword [0x982efc], 0x818897da
mov dword [0x982f00], 0xdac9c894
mov dword [0x982f04], 0xed93c5c0
mov word [0x982f08], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982eec]
xor cl, 0xe0
mov byte [eax + 0x983598], cl
inc eax
cmp eax, 0x1e
jb 0x8e44c7
mov eax, 0x983598
ret
Function at 0x8e44e2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d2c], 1
jne 0x8e4556
or dword [0x988d2c], 1
mov dword [0x982f0c], 0x8981a6e9
mov dword [0x982f10], 0xc084858c
mov dword [0x982f14], 0x87c08f94
mov dword [0x982f18], 0x93c09485
mov dword [0x982f1c], 0xdada8494
mov dword [0x982f20], 0x85839885
mov dword [0x982f24], 0x8f899490
mov dword [0x982f28], 0x97dada8e
mov dword [0x982f2c], 0xc8948188
mov dword [0x982f30], 0xe0eaedc9
xor eax, eax
mov cl, byte [eax + 0x982f0c]
xor cl, 0xe0
mov byte [eax + 0x9835b8], cl
inc eax
cmp eax, 0x28
jb 0x8e4558
mov eax, 0x9835b8
ret

Function at 0x8e4573
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d28], 1
jne 0x8e45a7
or dword [0x988d28], 1
mov dword [0x982f34], 0x8d8f83bf
mov dword [0x982f38], 0x929285bf
mov word [0x982f3c], 0x928f
mov byte [0x982f3e], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982f34]
xor cl, 0xe0
mov byte [eax + 0x9835e0], cl
inc eax
cmp eax, 0xb
jb 0x8e45a9
mov eax, 0x9835e0
ret

Function at 0x8e45c4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d24], 1
jne 0x8e462d
or dword [0x988d24], 1
mov dword [0x982f40], 0x8f83bfe9
mov dword [0x982f44], 0x9285bf8d
mov dword [0x982f48], 0xda928f92
mov dword [0x982f4c], 0x9292a5da
mov dword [0x982f50], 0x85ad928f
mov dword [0x982f54], 0x87819393
mov dword [0x982f58], 0xdac9c885
mov dword [0x982f5c], 0xed93c5c0
mov word [0x982f60], 0xe0ea
xor eax, eax
mov cl, byte [eax + 0x982f40]
xor cl, 0xe0
mov byte [eax + 0x9835ec], cl
inc eax
cmp eax, 0x22
jb 0x8e462f
mov eax, 0x9835ec
ret

Function at 0x8e464a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d20], 1
jne 0x8e46c8
or dword [0x988d20], 1
mov dword [0x982f64], 0x8981a6e9
mov dword [0x982f68], 0xc084858c
mov dword [0x982f6c], 0x87c08f94
mov dword [0x982f70], 0xbfc09485
mov dword [0x982f74], 0xbf8d8f83
mov dword [0x982f78], 0x8f929285
mov dword [0x982f7c], 0xa5dada92
mov dword [0x982f80], 0x928f9292
mov dword [0x982f84], 0x939385ad
mov dword [0x982f88], 0xc8858781
mov dword [0x982f8c], 0xe0eaedc9
xor eax, eax
mov cl, byte [eax + 0x982f64]
xor cl, 0xe0
mov byte [eax + 0x983610], cl
inc eax
cmp eax, 0x2c
jb 0x8e46ca
mov eax, 0x983610
ret

Function at 0x8e46e5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d1c], 1
jne 0x8e4760
or dword [0x988d1c], 1
mov dword [0x982f90], 0x838194b3
mov dword [0x982f94], 0x9584c08b
mov dword [0x982f98], 0x85c0908d
mov dword [0x982f9c], 0x928f9292
mov dword [0x982fa0], 0x8fa3c0da
mov dword [0x982fa4], 0x9885948e
mov dword [0x982fa8], 0x8385b294
mov dword [0x982fac], 0xc084928f
mov dword [0x982fb0], 0xc0938197
mov dword [0x982fb4], 0x8c8c958e
mov byte [0x982fb8], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982f90]
xor cl, 0xe0
mov byte [eax + 0x98363c], cl
inc eax
cmp eax, 0x29
jb 0x8e4762
mov eax, 0x98363c
ret
Function at 0x8e477d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d18], 1
jne 0x8e47f7
or dword [0x988d18], 1
mov dword [0x982fbc], 0x838194b3
mov dword [0x982fc0], 0x9584c08b
mov dword [0x982fc4], 0x85c0908d
mov dword [0x982fc8], 0x928f9292
mov dword [0x982fcc], 0x99b3c0da
mov dword [0x982fd0], 0x898ea98d
mov dword [0x982fd4], 0x8c818994
mov dword [0x982fd8], 0xc0859a89
mov dword [0x982fdc], 0x8c898186
mov word [0x982fe0], 0x8485
mov byte [0x982fe2], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982fbc]
xor cl, 0xe0
mov byte [eax + 0x983668], cl
inc eax
cmp eax, 0x27
jb 0x8e47f9
mov eax, 0x983668
ret

Function at 0x8e4814
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d14], 1
jne 0x8e487a
or dword [0x988d14], 1
mov dword [0x982fe4], 0x898b93dc
mov dword [0x982fe8], 0x84859090
mov dword [0x982fec], 0x819286c0
mov dword [0x982ff0], 0xc0cc858d
mov dword [0x982ff4], 0x97c0a3b0
mov dword [0x982ff8], 0x8ec09381
mov dword [0x982ffc], 0xde8c8c95
mov word [0x983000], 0xeaed
mov byte [0x983002], 0xe0
xor eax, eax
mov cl, byte [eax + 0x982fe4]
xor cl, 0xe0
mov byte [eax + 0x983690], cl
inc eax
cmp eax, 0x1f
jb 0x8e487c
mov eax, 0x983690
ret

Function at 0x8e4897
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d10], 1
jne 0x8e492a
or dword [0x988d10], 1
mov dword [0x983004], 0x898b93dc
mov dword [0x983008], 0x84859090
mov dword [0x98300c], 0x819286c0
mov dword [0x983010], 0xc0cc858d
mov dword [0x983014], 0x97c0a3b0
mov dword [0x983018], 0x93c09381
mov dword [0x98301c], 0xc0858d81
mov dword [0x983020], 0x92c09381
mov dword [0x983024], 0x92959485
mov dword [0x983028], 0x8481c08e
mov dword [0x98302c], 0x93859284
mov dword [0x983030], 0xeaedde93
mov byte [0x983034], 0xe0
xor eax, eax
mov cl, byte [eax + 0x983004]
xor cl, 0xe0
mov byte [eax + 0x9836b0], cl
inc eax
cmp eax, 0x31
jb 0x8e492c
mov eax, 0x9836b0
ret
Function at 0x8e4947
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, 0x16c4
call fcn.0093eb50
push ebx
push esi
push edi
call dword [0x95a094]
test byte [0x988d0c], 1
mov dword [ebp - 4], eax
jne 0x8e498e
or dword [0x988d0c], 1
mov dword [0x983038], 0x848f8ddc
mov dword [0x98303c], 0xdf858c95
mov dword [0x983040], 0xe0dedfdf
xor edi, edi
xor eax, eax
mov cl, byte [eax + 0x983038]
xor cl, 0xe0
mov byte [eax + 0x9836e4], cl
inc eax
cmp eax, 0xc
jb 0x8e4992
test byte [0x988d08], 1
mov dword [ebp - 8], 0x9836e4
jne 0x8e49dc
or dword [0x988d08], 1
mov dword [0x983044], 0x8d9993dc
mov dword [0x983048], 0xdf8c8f82
mov dword [0x98304c], 0xe0dedfdf
xor eax, eax
mov cl, byte [eax + 0x983044]
xor cl, 0xe0
mov byte [eax + 0x9836f0], cl
inc eax
cmp eax, 0xc
jb 0x8e49de
mov esi, 0x688
push esi
lea eax, [ebp - 0x6c0]
push edi
push eax
mov dword [ebp - 0x1c], 0x9836f0
mov dword [ebp - 0x18], edi
mov dword [ebp - 0x14], edi
call fcn.0092f010
mov eax, dword [ebp + 8]
cdq
add esp, 0xc
mov dword [ebp - 0x6c0], esi
mov esi, eax
lea eax, [ebp - 0x6c0]
push eax
mov ebx, edx
push ebx
push esi
push dword [ebp - 4]
call dword [0x95a3b0]
test eax, eax
je 0x8e4a43
lea eax, [ebp - 0x69c]
mov dword [ebp - 8], eax
push 0xffa
lea eax, [ebp - 0x16c0]
push edi
push eax
call fcn.0092f010
add esp, 0xc
lea eax, [ebp - 0x16c0]
push eax
lea eax, [ebp - 0x18]
push eax
push ebx
push esi
push dword [ebp - 4]
mov dword [ebp - 0x16c0], 0x58
mov dword [ebp - 0x1670], 0x7d0
call dword [0x95a3bc]
lea ecx, [ebp - 0x166c]
test eax, eax
jne 0x8e4a8f
mov ecx, dword [ebp - 0x1c]
test byte [0x988d04], 1
jne 0x8e4ac6
or dword [0x988d04], 1
mov dword [0x983050], 0xc5c090c5
mov dword [0x983054], 0x93c5c193
mov dword [0x983058], 0xc598d0cb
mov word [0x98305c], 0xe098
xor eax, eax
mov dl, byte [eax + 0x983050]
xor dl, 0xe0
mov byte [eax + 0x9836fc], dl
inc eax
cmp eax, 0xe
jb 0x8e4ac8
push dword [ebp - 0x14]
push dword [ebp - 0x18]
push ecx
push dword [ebp - 8]
push dword [ebp + 8]
push 0x9836fc
push dword [ebp + 0xc]
call fcn.0092c23d
add esp, 0x1c
push 6
pop ecx
mov dword [ebp - 0xc], edi
xor eax, eax
lea edi, [ebp - 0x38]
rep stosd dword es:[edi], eax
lea eax, [ebp - 0x38]
push eax
lea eax, [ebp - 0xc]
push eax
push ebx
push esi
push dword [ebp - 4]
mov dword [ebp - 0x38], 0x18
call dword [0x95a3a4]
test eax, eax
je 0x8e4b3f
push dword [ebp - 0xc]
push dword [ebp - 0x30]
push dword [ebp - 0x2c]
call fcn.008e4b8c
push eax
push dword [ebp + 0xc]
call fcn.0092c23d
add esp, 0x14
test byte [0x988cfc], 1
jne 0x8e4b5f
or dword [0x988cfc], 1
mov word [0x983070], 0xeaed
mov byte [0x983072], 0xe0
xor eax, eax
mov cl, byte [eax + 0x983070]
xor cl, 0xe0
mov byte [eax + 0x98371c], cl
inc eax
cmp eax, 3
jb 0x8e4b61
push dword [ebp + 0xc]
push 0x98371c
call fcn.0092beb1
pop ecx
pop ecx
pop edi
pop esi
pop ebx
leave
ret 8
Function at 0x8e4b8c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988d00], 1
jne 0x8e4bc4
or dword [0x988d00], 1
mov dword [0x983060], 0x93c5c8c0
mov dword [0x983064], 0xc084c5da
mov dword [0x983068], 0x98d0c0cb
mov dword [0x98306c], 0xe0c998c5
xor eax, eax
mov cl, byte [eax + 0x983060]
xor cl, 0xe0
mov byte [eax + 0x98370c], cl
inc eax
cmp eax, 0x10
jb 0x8e4bc6
mov eax, 0x98370c
ret

Function at 0x8e5e6e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988cf0], 1
jne 0x8e5ec3
or dword [0x988cf0], 1
mov dword [0x983740], 0xa5b3a0a9
mov dword [0x983744], 0xa4b3a0b6
mov dword [0x983748], 0xb1a2a0bd
mov dword [0x98374c], 0xb2a5bda8
mov dword [0x983750], 0xb7bdb5a5
mov dword [0x983754], 0xbeb9aea3
mov word [0x983758], 0xe1be
xor eax, eax
mov cl, byte [eax + 0x983740]
xor cl, 0xe1
mov byte [eax + 0x983940], cl
inc eax
cmp eax, 0x1a
jb 0x8e5ec5
mov eax, 0x983940
ret

Function at 0x8e5fd4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988cec], 1
jne 0x8e5ffe
or dword [0x988cec], 1
mov dword [0x98375c], 0x80b6acb7
mov word [0x983760], 0x8493
mov byte [0x983762], 0xe1
xor eax, eax
mov cl, byte [eax + 0x98375c]
xor cl, 0xe1
mov byte [eax + 0x98395c], cl
inc eax
cmp eax, 7
jb 0x8e6000
mov eax, 0x98395c
ret

Function at 0x8e601b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988ce8], 1
jne 0x8e6048
or dword [0x988ce8], 1
mov dword [0x983764], 0x959388b7
mov dword [0x983768], 0xb18d8094
mov word [0x98376c], 0xe1a2
xor eax, eax
mov cl, byte [eax + 0x983764]
xor cl, 0xe1
mov byte [eax + 0x983964], cl
inc eax
cmp eax, 0xa
jb 0x8e604a
mov eax, 0x983964
ret

Function at 0x8e6065
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988ce4], 1
jne 0x8e6099
or dword [0x988ce4], 1
mov dword [0x983770], 0x959388b7
mov dword [0x983774], 0xa38d8094
mov word [0x983778], 0x998e
mov byte [0x98377a], 0xe1
xor eax, eax
mov cl, byte [eax + 0x983770]
xor cl, 0xe1
mov byte [eax + 0x983970], cl
inc eax
cmp eax, 0xb
jb 0x8e609b
mov eax, 0x983970
ret

Function at 0x8e60b6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988ce0], 1
jne 0x8e60da
or dword [0x988ce0], 1
mov dword [0x98377c], 0x848f84a6
mov dword [0x983780], 0xe1828893
xor eax, eax
mov cl, byte [eax + 0x98377c]
xor cl, 0xe1
mov byte [eax + 0x98397c], cl
inc eax
cmp eax, 8
jb 0x8e60dc
mov eax, 0x98397c
ret