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

Disassembly:
test byte [0x937d70], 1
jne 0x89cd0b
or dword [0x937d70], 1
mov dword [0x936b0c], 0xaaafa780
mov dword [0x936b10], 0xb2e6a2a3
mov dword [0x936b14], 0xb4a5e6a9
mov dword [0x936b18], 0xa3b2a7a3
mov dword [0x936b1c], 0xa7b3aae6
mov dword [0x936b20], 0xa7b2b5e6
mov dword [0x936b24], 0xeee6a3b2
mov dword [0x936b28], 0xadb4a9b1
mov dword [0x936b2c], 0xb2e6b4a3
mov dword [0x936b30], 0xa7a3b4ae
mov dword [0x936b34], 0xe6fcefa2
mov byte [0x936b38], 0xc6
xor eax, eax
mov cl, byte [eax + 0x936b0c]
xor cl, 0xc6
mov byte [eax + 0x936bd4], cl
inc eax
cmp eax, 0x2d
jb 0x89cd0d
mov eax, 0x936bd4
ret

Function at 0x89cd28
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d60], 1
jne 0x89cd8f
or dword [0x937d60], 1
mov dword [0x936b48], 0xa3e6a988
mov dword [0x936b4c], 0xb4a9b4b4
mov dword [0x936b50], 0xb5a3abe6
mov dword [0x936b54], 0xa3a1a7b5
mov dword [0x936b58], 0xb2a3b4e6
mov dword [0x936b5c], 0xa3a8b4b3
mov dword [0x936b60], 0xbfa4e6a2
mov dword [0x936b64], 0xa4a9ace6
mov byte [0x936b68], 0xc6
xor eax, eax
mov cl, byte [eax + 0x936b48]
xor cl, 0xc6
mov byte [eax + 0x936c10], cl
inc eax
cmp eax, 0x21
jb 0x89cd91
mov eax, 0x936c10
ret

Function at 0x89cdac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d54], 1
jne 0x89ce15
or dword [0x937d54], 1
mov dword [0x936b94], 0xe6a7b38a
mov dword [0x936b98], 0xa9b4b4a3
mov dword [0x936b9c], 0xb3b4e6b4
mov dword [0x936ba0], 0xa8afa8a8
mov dword [0x936ba4], 0xb4a3e6a1
mov dword [0x936ba8], 0xe6b4a9b4
mov dword [0x936bac], 0xa2a8a7ae
mov dword [0x936bb0], 0xfcb4a3aa
mov word [0x936bb4], 0xc6e6
xor eax, eax
mov cl, byte [eax + 0x936b94]
xor cl, 0xc6
mov byte [eax + 0x936c5c], cl
inc eax
cmp eax, 0x22
jb 0x89ce17
mov eax, 0x936c5c
ret

Function at 0x89ce32
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d50], 1
jne 0x89ce84
or dword [0x937d50], 1
mov dword [0x936bb8], 0x8aa7b3aa
mov dword [0x936bbc], 0xa7a9aa99
mov dword [0x936bc0], 0xb4b2b5a2
mov dword [0x936bc4], 0xe6a1a8af
mov dword [0x936bc8], 0xaaafa7a0
mov word [0x936bcc], 0xa2a3
mov byte [0x936bce], 0xc6
xor eax, eax
mov cl, byte [eax + 0x936bb8]
xor cl, 0xc6
mov byte [eax + 0x936c80], cl
inc eax
cmp eax, 0x17
jb 0x89ce86
mov eax, 0x936c80
ret
Function at 0x89dc19
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x8fdbed
call fcn.008fcc58
sub esp, 0xb0
push ebx
push esi
push edi
xor ebx, ebx
push ebx
push ebx
lea eax, [ebp - 0x10]
push eax
push ebx
push dword [ebp + 0xc]
mov dword [ebp - 0x10], ebx
push ebx
push 0x1300
call dword [0x906134]
test eax, eax
jne 0x89dc61
call fcn.0089ddba
mov ecx, dword [ebp + 8]
push eax
call fcn.00876aa2
mov eax, dword [ebp + 8]
jmp 0x89ddab
test byte [0x937d44], 1
jne 0x89dc82
or dword [0x937d44], 1
mov dword [0x936cbc], 0xe8c2c5c1
mov byte [0x936cc0], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936cbc]
xor cl, 0xc8
mov byte [eax + 0x9373fc], cl
inc eax
cmp eax, 5
jb 0x89dc84
push 0xf
mov esi, 0x9373fc
pop edi
mov eax, esi
mov dword [ebp - 0x34], edi
mov dword [ebp - 0x38], ebx
mov byte [ebp - 0x48], bl
lea ecx, [eax + 1]
mov dl, byte [eax]
inc eax
cmp dl, bl
jne 0x89dcaf
sub eax, ecx
push eax
push esi
lea ecx, [ebp - 0x48]
call fcn.00874e34
mov dword [ebp - 4], ebx
push dword [ebp - 0x10]
lea ecx, [ebp - 0x2c]
mov dword [ebp - 0x18], edi
mov dword [ebp - 0x1c], ebx
mov byte [ebp - 0x2c], bl
call fcn.00874c4f
lea eax, [ebp - 0x2c]
push eax
lea edi, [ebp - 0x48]
lea eax, [ebp - 0x64]
mov byte [ebp - 4], 1
call fcn.008a22f7
pop ecx
push ebx
push 1
lea ecx, [ebp - 0x2c]
call fcn.00874c70
push ebx
push 1
mov ecx, edi
mov byte [ebp - 4], 4
call fcn.00874c70
push dword [ebp - 0x10]
call dword [0x9060e8]
push ebx
push dword [ebp + 0xc]
lea esi, [ebp - 0xb8]
call fcn.0089e105
pop ecx
pop ecx
push eax
mov byte [ebp - 4], 5
call fcn.0089de23
push eax
lea eax, [ebp - 0x80]
push eax
call fcn.00876adf
add esp, 0xc
push 0x9213b4
push eax
lea eax, [ebp - 0x9c]
push eax
mov byte [ebp - 4], 6
call fcn.0087ef9c
add esp, 0xc
push 0xffffffffffffffff
push ebx
push eax
lea esi, [ebp - 0x64]
mov byte [ebp - 4], 7
call fcn.0087c92a
push ebx
push 1
lea ecx, [ebp - 0x9c]
call fcn.00874c70
push ebx
push 1
lea ecx, [ebp - 0x80]
call fcn.00874c70
push ebx
push 1
lea ecx, [ebp - 0xb8]
mov byte [ebp - 4], 4
call fcn.00874c70
mov edi, dword [ebp + 8]
mov dword [edi + 0x14], 0xf
mov dword [edi + 0x10], ebx
mov byte [edi], bl
call fcn.00874c05
push ebx
push 1
mov ecx, esi
call fcn.00874c70
mov eax, edi
mov ecx, dword [ebp - 0xc]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
leave
ret

Function at 0x89ddba
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d48], 1
jne 0x89de06
or dword [0x937d48], 1
mov dword [0x936ca4], 0xadbaa69d
mov dword [0x936ca8], 0xa6afa7ab
mov dword [0x936cac], 0xacadb2a1
mov dword [0x936cb0], 0xbabaade8
mov dword [0x936cb4], 0xabe8baa7
mov dword [0x936cb8], 0xc8adaca7
xor eax, eax
mov cl, byte [eax + 0x936ca4]
xor cl, 0xc8
mov byte [eax + 0x9373e4], cl
inc eax
cmp eax, 0x18
jb 0x89de08
mov eax, 0x9373e4
ret

Function at 0x89de23
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d40], 1
jne 0x89de61
or dword [0x937d40], 1
mov dword [0x936cc4], 0xbaade0e8
mov dword [0x936cc8], 0xe8baa7ba
mov dword [0x936ccc], 0xadaca7ab
mov word [0x936cd0], 0xe8f2
mov byte [0x936cd2], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936cc4]
xor cl, 0xc8
mov byte [eax + 0x937404], cl
inc eax
cmp eax, 0xf
jb 0x89de63
mov eax, 0x937404
ret
Function at 0x89e105
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x48
and dword [ebp - 4], 0
test byte [0x937d3c], 1
jne 0x89e130
or dword [0x937d3c], 1
mov dword [0x936cd4], 0xaca4a4ed
mov byte [0x936cd8], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936cd4]
xor cl, 0xc8
mov byte [eax + 0x937414], cl
inc eax
cmp eax, 5
jb 0x89e132
push dword [ebp + 0xc]
lea eax, [ebp - 0x48]
push dword [ebp + 8]
push 0x937414
push eax
call fcn.008a2350
and dword [esi + 0x10], 0
add esp, 0x10
lea eax, [ebp - 0x48]
mov dword [esi + 0x14], 0xf
push eax
mov ecx, esi
mov byte [esi], 0
call fcn.00874c4f
mov eax, esi
leave
ret

Function at 0x89e2d4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d38], 1
jne 0x89e330
or dword [0x937d38], 1
mov dword [0x936cdc], 0x85bcad8f
mov dword [0x936ce0], 0xa4bdaca7
mov dword [0x936ce4], 0xa4a18ead
mov dword [0x936ce8], 0xa5a986ad
mov dword [0x936cec], 0xa9aee8ad
mov dword [0x936cf0], 0xacada4a1
mov word [0x936cf4], 0xe8f2
mov byte [0x936cf6], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936cdc]
xor cl, 0xc8
mov byte [eax + 0x93741c], cl
inc eax
cmp eax, 0x1b
jb 0x89e332
mov eax, 0x93741c
ret

Function at 0x89e34d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d34], 1
jne 0x89e3aa
or dword [0x937d34], 1
mov dword [0x936cf8], 0x8bbcad9b
mov dword [0x936cfc], 0xadbababd
mov dword [0x936d00], 0xa18cbca6
mov dword [0x936d04], 0xbcabadba
mov dword [0x936d08], 0xe8b1baa7
mov dword [0x936d0c], 0xa4a1a9ae
mov dword [0x936d10], 0xe8f2acad
mov byte [0x936d14], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936cf8]
xor cl, 0xc8
mov byte [eax + 0x937438], cl
inc eax
cmp eax, 0x1d
jb 0x89e3ac
mov eax, 0x937438
ret

Function at 0x89e4be
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d30], 1
jne 0x89e51b
or dword [0x937d30], 1
mov dword [0x936d18], 0x8bbcad8f
mov dword [0x936d1c], 0xadbababd
mov dword [0x936d20], 0xa18cbca6
mov dword [0x936d24], 0xbcabadba
mov dword [0x936d28], 0xe8b1baa7
mov dword [0x936d2c], 0xa4a1a9ae
mov dword [0x936d30], 0xe8f2acad
mov byte [0x936d34], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936d18]
xor cl, 0xc8
mov byte [eax + 0x937458], cl
inc eax
cmp eax, 0x1d
jb 0x89e51d
mov eax, 0x937458
ret
Function at 0x89e6d6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d2c], 1
jne 0x89e845
mov eax, 0xdc94
mov ecx, eax
mov word [0x936d38], cx
mov word [0x936d3a], cx
add ecx, 7
mov word [0x936d3c], cx
lea ecx, [eax + 0x28]
mov word [0x936d3e], cx
add ecx, 0xfffffffe
lea edx, [eax + 0xd]
mov word [0x936d40], cx
push ebx
mov ecx, edx
mov word [0x936d42], cx
add ecx, 5
push esi
mov esi, ecx
lea ecx, [eax + 0x1a]
mov word [0x936d44], si
lea esi, [eax + 0x1b]
mov word [0x936d46], si
mov word [0x936d54], cx
add esi, 0xfffffff8
add edx, 3
mov ecx, esi
push edi
lea edi, [eax + 0x19]
mov word [0x936d56], cx
mov ecx, eax
mov word [0x936d4c], dx
mov edx, edi
mov word [0x936d58], cx
mov word [0x936d5a], cx
add ecx, 0x64
mov word [0x936d4e], dx
mov edx, ecx
or dword [0x937d2c], 1
mov word [0x936d5c], dx
lea edx, [eax + 0x68]
mov ebx, edx
mov word [0x936d5e], bx
mov ebx, ecx
mov word [0x936d60], bx
lea ebx, [eax + 0x5d]
mov word [0x936d6e], ax
mov word [0x936d62], bx
mov ebx, ecx
mov ecx, eax
add eax, 4
mov word [0x936d70], ax
lea eax, [ecx + 0x18]
mov word [0x936d76], ax
add eax, 0x11
mov word [0x936d78], ax
lea eax, [ecx + 0x17]
mov word [0x936d7a], ax
add eax, 0x11
mov word [0x936d7c], ax
lea eax, [ecx - 0xe]
mov word [0x936d7e], ax
add eax, 0x23
pop edi
mov word [0x936d80], ax
lea eax, [ecx + 0x34]
pop esi
mov word [0x936d64], bx
mov dword [0x936d48], 0xdca1dc8e
mov dword [0x936d50], 0xdca6dc81
mov word [0x936d66], dx
mov dword [0x936d68], 0xdcf8dc8a
mov word [0x936d6c], cx
mov dword [0x936d72], 0xdca7dcba
mov dword [0x936d82], 0xdcaddca5
mov word [0x936d86], ax
pop ebx
xor eax, eax
mov ecx, 0xdcc8
xor cx, word [eax + 0x936d38]
add eax, 2
mov word [eax + 0x937476], cx
cmp eax, 0x50
jb 0x89e847
mov eax, 0x937478
ret

Function at 0x89e868
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d28], 1
jne 0x89e8bd
or dword [0x937d28], 1
mov dword [0x936d88], 0xbee8a786
mov dword [0x936d8c], 0xa1bbbaad
mov dword [0x936d90], 0xa1e8a6a7
mov dword [0x936d94], 0xe8a7aea6
mov dword [0x936d98], 0xa1a9bea9
mov dword [0x936d9c], 0xa4aaa9a4
mov word [0x936da0], 0xc8ad
xor eax, eax
mov cl, byte [eax + 0x936d88]
xor cl, 0xc8
mov byte [eax + 0x9374c8], cl
inc eax
cmp eax, 0x1a
jb 0x89e8bf
mov eax, 0x9374c8
ret

Function at 0x89eaac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d24], 1
jne 0x89eb01
or dword [0x937d24], 1
mov dword [0x936da4], 0xbee8a786
mov dword [0x936da8], 0xa1bbbaad
mov dword [0x936dac], 0xa1e8a6a7
mov dword [0x936db0], 0xe8a7aea6
mov dword [0x936db4], 0xa1a9bea9
mov dword [0x936db8], 0xa4aaa9a4
mov word [0x936dbc], 0xc8ad
xor eax, eax
mov cl, byte [eax + 0x936da4]
xor cl, 0xc8
mov byte [eax + 0x9374e4], cl
inc eax
cmp eax, 0x1a
jb 0x89eb03
mov eax, 0x9374e4
ret
Function at 0x89eb1e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d20], 1
jne 0x89eb84
or dword [0x937d20], 1
mov dword [0x936dc0], 0xa9bea681
mov dword [0x936dc4], 0xe8aca1a4
mov dword [0x936dc8], 0xbbbaadbe
mov dword [0x936dcc], 0xe8a6a7a1
mov dword [0x936dd0], 0xa7aea6a1
mov dword [0x936dd4], 0xafa1bbe8
mov dword [0x936dd8], 0xbdbca9a6
mov word [0x936ddc], 0xadba
mov byte [0x936dde], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936dc0]
xor cl, 0xc8
mov byte [eax + 0x937500], cl
inc eax
cmp eax, 0x1f
jb 0x89eb86
mov eax, 0x937500
ret

Function at 0x89ee8b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d1c], 1
jne 0x89eef1
or dword [0x937d1c], 1
mov dword [0x936de0], 0xa4a1a98e
mov dword [0x936de4], 0xbce8acad
mov dword [0x936de8], 0xadafe8a7
mov dword [0x936dec], 0xadbce8bc
mov dword [0x936df0], 0xaee8b8a5
mov dword [0x936df4], 0xadaca4a7
mov dword [0x936df8], 0xa9b8e8ba
mov word [0x936dfc], 0xa0bc
mov byte [0x936dfe], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936de0]
xor cl, 0xc8
mov byte [eax + 0x937520], cl
inc eax
cmp eax, 0x1f
jb 0x89eef3
mov eax, 0x937520
ret

Function at 0x89f063
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d18], 1
jne 0x89f0b5
or dword [0x937d18], 1
mov dword [0x936e00], 0x8ebcad8f
mov dword [0x936e04], 0xadaca4a7
mov dword [0x936e08], 0xbca998ba
mov dword [0x936e0c], 0xa9aee8a0
mov dword [0x936e10], 0xacada4a1
mov word [0x936e14], 0xe8f2
mov byte [0x936e16], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936e00]
xor cl, 0xc8
mov byte [eax + 0x937540], cl
inc eax
cmp eax, 0x17
jb 0x89f0b7
mov eax, 0x937540
ret

Function at 0x89f37f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d14], 1
mov edx, 0xdcc8
jne 0x89f416
or dword [0x937d14], 1
lea ecx, [edx + 0x25]
mov eax, ecx
mov word [0x936e18], ax
add eax, 0xffffffab
mov word [0x936e1a], ax
push esi
lea eax, [edx - 0xe]
mov esi, eax
add eax, 0xffffffef
mov word [0x936e24], ax
lea eax, [edx - 0x23]
mov word [0x936e26], ax
add eax, 0xfffffffa
mov word [0x936e28], ax
lea eax, [edx + 0x36]
mov word [0x936e1c], si
add esi, 0xffffffed
mov word [0x936e2a], ax
add eax, 0xfffffffe
mov word [0x936e2c], ax
lea eax, [edx + 0x33]
mov word [0x936e2e], ax
mov eax, edx
mov word [0x936e1e], si
mov dword [0x936e20], 0xdcbadcaf
mov dword [0x936e30], 0xdceddcfa
mov word [0x936e34], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x936e18]
add eax, 2
mov word [eax + 0x937556], cx
cmp eax, 0x1e
jb 0x89f418
mov eax, 0x937558
ret

Function at 0x89f436
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d10], 1
mov ecx, 0xdcc8
jne 0x89f477
or dword [0x937d10], 1
lea eax, [ecx - 0x15]
mov word [0x936e38], ax
add eax, 5
mov word [0x936e3a], ax
lea eax, [ecx - 0x1a]
mov word [0x936e3c], ax
add eax, 7
mov word [0x936e3e], ax
mov eax, ecx
mov word [0x936e40], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e38]
add eax, 2
mov word [eax + 0x937576], dx
cmp eax, 0xa
jb 0x89f479
mov eax, 0x937578
ret
Function at 0x89f497
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d0c], 1
mov ecx, 0xdcc8
jne 0x89f4ea
or dword [0x937d0c], 1
lea eax, [ecx - 0x15]
mov word [0x936e44], ax
add eax, 5
mov word [0x936e46], ax
lea eax, [ecx - 0x1a]
mov word [0x936e48], ax
add eax, 0x4d
mov word [0x936e4a], ax
lea eax, [ecx + 0x32]
mov word [0x936e4c], ax
add eax, 0xffffffbb
mov word [0x936e4e], ax
mov eax, ecx
mov word [0x936e50], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e44]
add eax, 2
mov word [eax + 0x937582], dx
cmp eax, 0xe
jb 0x89f4ec
mov eax, 0x937584
ret

Function at 0x89f50a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d08], 1
mov ecx, 0xdcc8
jne 0x89f55d
or dword [0x937d08], 1
lea eax, [ecx - 0x15]
mov word [0x936e54], ax
add eax, 5
mov word [0x936e56], ax
lea eax, [ecx - 0x1a]
mov word [0x936e58], ax
add eax, 0x50
mov word [0x936e5a], ax
lea eax, [ecx + 0x34]
mov word [0x936e5c], ax
add eax, 0xffffffb9
mov word [0x936e5e], ax
mov eax, ecx
mov word [0x936e60], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e54]
add eax, 2
mov word [eax + 0x937592], dx
cmp eax, 0xe
jb 0x89f55f
mov eax, 0x937594
ret

Function at 0x89f57d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d04], 1
mov ecx, 0xdcc8
jne 0x89f5be
or dword [0x937d04], 1
lea eax, [ecx - 0x15]
mov word [0x936e64], ax
add eax, 5
mov word [0x936e66], ax
lea eax, [ecx - 0x1a]
mov word [0x936e68], ax
add eax, 7
mov word [0x936e6a], ax
mov eax, ecx
mov word [0x936e6c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e64]
add eax, 2
mov word [eax + 0x9375a2], dx
cmp eax, 0xa
jb 0x89f5c0
mov eax, 0x9375a4
ret

Function at 0x89f5de
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937d00], 1
mov ecx, 0xdcc8
jne 0x89f631
or dword [0x937d00], 1
lea eax, [ecx - 0x15]
mov word [0x936e70], ax
add eax, 5
mov word [0x936e72], ax
lea eax, [ecx - 0x1a]
mov word [0x936e74], ax
add eax, 0x4d
mov word [0x936e76], ax
lea eax, [ecx + 0x32]
mov word [0x936e78], ax
add eax, 0xffffffbb
mov word [0x936e7a], ax
mov eax, ecx
mov word [0x936e7c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e70]
add eax, 2
mov word [eax + 0x9375ae], dx
cmp eax, 0xe
jb 0x89f633
mov eax, 0x9375b0
ret
Function at 0x89f72b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cfc], 1
mov ecx, 0xdcc8
jne 0x89f948
or dword [0x937cfc], 1
lea eax, [ecx + 0x30]
mov word [0x936e88], ax
inc eax
mov word [0x936e8a], ax
lea eax, [ecx + 0x32]
mov word [0x936e8c], ax
inc eax
mov word [0x936e8e], ax
lea eax, [ecx + 0x34]
mov word [0x936e90], ax
inc eax
mov word [0x936e92], ax
lea eax, [ecx + 0x36]
mov word [0x936e94], ax
inc eax
mov word [0x936e96], ax
lea eax, [ecx + 0x28]
mov word [0x936e98], ax
inc eax
mov word [0x936e9a], ax
lea eax, [ecx - 0x3f]
mov word [0x936e9c], ax
inc eax
mov word [0x936e9e], ax
lea eax, [ecx - 0x3d]
mov word [0x936ea0], ax
inc eax
mov word [0x936ea2], ax
lea eax, [ecx - 0x3b]
mov word [0x936ea4], ax
inc eax
mov word [0x936ea6], ax
lea eax, [ecx - 0x39]
mov word [0x936ea8], ax
add eax, 0xfffffff1
mov word [0x936eaa], ax
lea eax, [ecx - 0x47]
mov word [0x936eac], ax
inc eax
mov word [0x936eae], ax
lea eax, [ecx - 0x45]
mov word [0x936eb0], ax
inc eax
mov word [0x936eb2], ax
lea eax, [ecx - 0x43]
mov word [0x936eb4], ax
inc eax
mov word [0x936eb6], ax
lea eax, [ecx - 0x41]
mov word [0x936eb8], ax
add eax, 0x11
mov word [0x936eba], ax
lea eax, [ecx - 0x2f]
mov word [0x936ebc], ax
inc eax
mov word [0x936ebe], ax
lea eax, [ecx - 0x2d]
mov word [0x936ec0], ax
inc eax
mov word [0x936ec2], ax
lea eax, [ecx - 0x2b]
mov word [0x936ec4], ax
inc eax
mov word [0x936ec6], ax
lea eax, [ecx - 0x29]
mov word [0x936ec8], ax
add eax, 0xfffffff1
mov word [0x936eca], ax
lea eax, [ecx - 0x37]
mov word [0x936ecc], ax
inc eax
mov word [0x936ece], ax
lea eax, [ecx - 0x1f]
mov word [0x936ed0], ax
inc eax
mov word [0x936ed2], ax
lea eax, [ecx - 0x1d]
mov word [0x936ed4], ax
inc eax
mov word [0x936ed6], ax
lea eax, [ecx - 0x1b]
mov word [0x936ed8], ax
inc eax
mov word [0x936eda], ax
lea eax, [ecx - 0x19]
mov word [0x936edc], ax
add eax, 0xfffffff1
mov word [0x936ede], ax
lea eax, [ecx - 0x27]
mov word [0x936ee0], ax
inc eax
mov word [0x936ee2], ax
lea eax, [ecx - 0x25]
mov word [0x936ee4], ax
inc eax
mov word [0x936ee6], ax
lea eax, [ecx - 0x23]
mov word [0x936ee8], ax
inc eax
mov word [0x936eea], ax
lea eax, [ecx - 0x21]
mov word [0x936eec], ax
add eax, 0x11
mov word [0x936eee], ax
lea eax, [ecx - 0xf]
mov word [0x936ef0], ax
inc eax
mov word [0x936ef2], ax
lea eax, [ecx - 0xd]
mov word [0x936ef4], ax
inc eax
mov word [0x936ef6], ax
lea eax, [ecx - 0xb]
mov word [0x936ef8], ax
inc eax
mov word [0x936efa], ax
lea eax, [ecx - 9]
mov word [0x936efc], ax
add eax, 0xfffffff1
mov word [0x936efe], ax
lea eax, [ecx - 0x17]
mov word [0x936f00], ax
inc eax
mov word [0x936f02], ax
mov eax, ecx
mov word [0x936f04], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x936e88]
add eax, 2
mov word [eax + 0x9375be], dx
cmp eax, 0x7e
jb 0x89f94a
mov eax, 0x9375c0
ret
Function at 0x89faec
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cf8], 1
jne 0x89fb2a
or dword [0x937cf8], 1
mov dword [0x936f08], 0xa79fbb81
mov dword [0x936f0c], 0x98fcfebf
mov dword [0x936f10], 0xadaba7ba
mov word [0x936f14], 0xbbbb
mov byte [0x936f16], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936f08]
xor cl, 0xc8
mov byte [eax + 0x937640], cl
inc eax
cmp eax, 0xf
jb 0x89fb2c
mov eax, 0x937640
ret

Function at 0x89fc42
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cf4], 1
jne 0x89fcab
or dword [0x937cf4], 1
mov dword [0x936f18], 0xa7a4a489
mov dword [0x936f1c], 0xadbca9ab
mov dword [0x936f20], 0x81aca689
mov dword [0x936f24], 0xa1bca1a6
mov dword [0x936f28], 0xb2a1a4a9
mov dword [0x936f2c], 0xaca19bad
mov dword [0x936f30], 0xa1a9aee8
mov dword [0x936f34], 0xf2acada4
mov word [0x936f38], 0xc8e8
xor eax, eax
mov cl, byte [eax + 0x936f18]
xor cl, 0xc8
mov byte [eax + 0x937650], cl
inc eax
cmp eax, 0x22
jb 0x89fcad
mov eax, 0x937650
ret

Function at 0x89fcc8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cf0], 1
jne 0x89fd27
or dword [0x937cf0], 1
mov dword [0x936f3c], 0xabada08b
mov dword [0x936f40], 0xa3a79ca3
mov dword [0x936f44], 0xad85a6ad
mov dword [0x936f48], 0xbaadaaa5
mov dword [0x936f4c], 0xb8a1a0bb
mov dword [0x936f50], 0xa1a9aee8
mov dword [0x936f54], 0xf2acada4
mov word [0x936f58], 0xc8e8
xor eax, eax
mov cl, byte [eax + 0x936f3c]
xor cl, 0xc8
mov byte [eax + 0x937674], cl
inc eax
cmp eax, 0x1e
jb 0x89fd29
mov eax, 0x937674
ret

Function at 0x89fec1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cec], 1
jne 0x89ff46
or dword [0x937cec], 1
mov dword [0x936f5c], 0xa6a6a98b
mov dword [0x936f60], 0xb9e8bca7
mov dword [0x936f64], 0xb1baadbd
mov dword [0x936f68], 0xfee8a9e8
mov dword [0x936f6c], 0xa1aae8fc
mov dword [0x936f70], 0xa1bee8bc
mov dword [0x936f74], 0xa7e8bfad
mov dword [0x936f78], 0xfafbe8a6
mov dword [0x936f7c], 0xbca1aae8
mov dword [0x936f80], 0xa6a1bfe8
mov dword [0x936f84], 0xbbbfa7ac
mov byte [0x936f88], 0xc8
xor eax, eax
mov cl, byte [eax + 0x936f5c]
xor cl, 0xc8
mov byte [eax + 0x937694], cl
inc eax
cmp eax, 0x2d
jb 0x89ff48
mov eax, 0x937694
ret

Function at 0x89ff65
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ce8], 1
jne 0x8a0019
push ebx
push esi
or dword [0x937ce8], 1
mov eax, 0xdc80
mov word [0x936f8c], ax
add eax, 3
mov word [0x936f8e], ax
push edi
mov edi, 0xdc8d
mov eax, edi
mov word [0x936f90], ax
add eax, 4
mov word [0x936f92], ax
lea esi, [edi + 0xa]
mov eax, esi
mov word [0x936f94], ax
lea edx, [edi - 9]
mov eax, edx
mov word [0x936f96], ax
add eax, 3
mov word [0x936f98], ax
lea ecx, [edi - 2]
mov eax, ecx
mov word [0x936f9a], ax
add eax, 0xfffffffe
mov ebx, eax
lea eax, [edi - 0xc]
pop edi
mov word [0x936faa], ax
add eax, 0x47
pop esi
mov word [0x936f9c], bx
mov dword [0x936f9e], 0xdc97dc84
mov dword [0x936fa2], 0xdc89dc85
mov dword [0x936fa6], 0xdc80dc8b
mov dword [0x936fac], 0xdc8ddc86
mov word [0x936fb0], ax
pop ebx
xor eax, eax
mov ecx, 0xdcc8
xor cx, word [eax + 0x936f8c]
add eax, 2
mov word [eax + 0x9376c2], cx
cmp eax, 0x26
jb 0x8a001b
mov eax, 0x9376c4
ret
Function at 0x8a003c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ce4], 1
jne 0x8a00ed
or dword [0x937ce4], 1
mov eax, 0xdc80
mov word [0x936fb4], ax
add eax, 3
mov word [0x936fb6], ax
mov ecx, 0xdc8d
push ebx
mov eax, ecx
mov word [0x936fb8], ax
add eax, 4
push esi
mov word [0x936fba], ax
lea esi, [ecx + 0xa]
mov eax, esi
mov word [0x936fbc], ax
add eax, 0xfffffff4
mov word [0x936fbe], ax
lea edx, [ecx + 0x10]
mov eax, edx
mov word [0x936fc0], ax
add eax, 0xfffffffd
mov ebx, eax
mov word [0x936fc2], bx
mov word [0x936fc4], bx
mov ebx, ecx
mov word [0x936fc6], bx
add ebx, 0xfffffff9
mov word [0x936fd4], ax
lea eax, [ecx + 0x3b]
pop esi
mov word [0x936fc8], bx
mov dword [0x936fca], 0xdc97dc9c
mov word [0x936fce], dx
mov dword [0x936fd0], 0xdc8ddc9b
mov word [0x936fd6], ax
pop ebx
xor eax, eax
mov ecx, 0xdcc8
xor cx, word [eax + 0x936fb4]
add eax, 2
mov word [eax + 0x9376ea], cx
cmp eax, 0x24
jb 0x8a00ef
mov eax, 0x9376ec
ret

Function at 0x8a0110
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937ce0], 1
mov edx, 0xdcc8
jne 0x8a0184
or dword [0x937ce0], 1
lea eax, [edx - 0x48]
mov word [0x936fd8], ax
add eax, 3
mov word [0x936fda], ax
lea ecx, [edx - 0x3b]
mov eax, ecx
mov word [0x936fdc], ax
add eax, 4
mov word [0x936fde], ax
lea eax, [edx - 0x31]
mov word [0x936fe0], ax
add eax, 6
mov word [0x936fe2], ax
lea eax, [edx - 0x2d]
push esi
mov esi, eax
mov eax, edx
mov word [0x936fe4], si
mov word [0x936fe6], cx
mov dword [0x936fe8], 0xdc9bdc9a
mov word [0x936fec], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x936fd8]
add eax, 2
mov word [eax + 0x93770e], cx
cmp eax, 0x16
jb 0x8a0186
mov eax, 0x937710
ret

Function at 0x8a01a4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x937cdc], 1
jne 0x8a0266
push ebx
mov eax, 0xdc80
mov word [0x936ff0], ax
add eax, 3
mov word [0x936ff2], ax
push esi
mov esi, 0xdc8d
or dword [0x937cdc], 1
mov eax, esi
mov word [0x936ff4], ax
add eax, 4
mov word [0x936ff6], ax
lea edx, [esi + 0xa]
lea ecx, [esi - 2]
mov eax, edx
mov word [0x936ff8], ax
mov eax, ecx
mov word [0x936ffa], ax
add eax, 0x12
mov word [0x936ffc], ax
lea eax, [esi + 0xd]
mov ebx, eax
add eax, 0xffffffec
mov esi, eax
lea eax, [edx - 9]
mov word [0x937010], ax
add eax, 0xfffffff3
mov word [0x937012], ax
lea eax, [edx - 8]
mov word [0x937004], si
mov word [0x937014], ax
add eax, 0x39
pop esi
mov word [0x936ffe], bx
mov dword [0x937000], 0xdc8ddc9a
mov dword [0x937006], 0xdc97dc9c
mov word [0x93700a], cx
mov dword [0x93700c], 0xdc86dc87
mov word [0x937016], ax
pop ebx
xor eax, eax
mov ecx, 0xdcc8
xor cx, word [eax + 0x936ff0]
add eax, 2
mov word [eax + 0x937726], cx
cmp eax, 0x28
jb 0x8a0268
mov eax, 0x937728
ret