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

Disassembly:
test byte [0x9886fc], 1
jne 0x909a7b
or dword [0x9886fc], 1
mov dword [0x987544], 0x95d09fbe
mov dword [0x987548], 0x829f8282
mov dword [0x98754c], 0x83959dd0
mov dword [0x987550], 0x95979183
mov dword [0x987554], 0x849582d0
mov dword [0x987558], 0x959e8285
mov dword [0x98755c], 0x8992d094
mov dword [0x987560], 0x929f9ad0
mov byte [0x987564], 0xf0
xor eax, eax
mov cl, byte [eax + 0x987544]
xor cl, 0xf0
mov byte [eax + 0x98760c], cl
inc eax
cmp eax, 0x21
jb 0x909a7d
mov eax, 0x98760c
ret

Function at 0x909a98
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886f0], 1
jne 0x909b01
or dword [0x9886f0], 1
mov dword [0x987590], 0xd09185bc
mov dword [0x987594], 0x9f828295
mov dword [0x987598], 0x8582d082
mov dword [0x98759c], 0x9e999e9e
mov dword [0x9875a0], 0x8295d097
mov dword [0x9875a4], 0xd0829f82
mov dword [0x9875a8], 0x949e9198
mov dword [0x9875ac], 0xca82959c
mov word [0x9875b0], 0xf0d0
xor eax, eax
mov cl, byte [eax + 0x987590]
xor cl, 0xf0
mov byte [eax + 0x987658], cl
inc eax
cmp eax, 0x22
jb 0x909b03
mov eax, 0x987658
ret

Function at 0x909b1e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886ec], 1
jne 0x909b70
or dword [0x9886ec], 1
mov dword [0x9875b4], 0xbc91859c
mov dword [0x9875b8], 0x919f9caf
mov dword [0x9875bc], 0x82848394
mov dword [0x9875c0], 0xd0979e99
mov dword [0x9875c4], 0x9c999196
mov word [0x9875c8], 0x9495
mov byte [0x9875ca], 0xf0
xor eax, eax
mov cl, byte [eax + 0x9875b4]
xor cl, 0xf0
mov byte [eax + 0x98767c], cl
inc eax
cmp eax, 0x17
jb 0x909b72
mov eax, 0x98767c
ret
Function at 0x90a8be
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x952e6d
call fcn.00951d38
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 [0x95a12c]
test eax, eax
jne 0x90a906
call fcn.0090aa5f
mov ecx, dword [ebp + 8]
push eax
call fcn.008e6b19
mov eax, dword [ebp + 8]
jmp 0x90aa50
test byte [0x9886e0], 1
jne 0x90a927
or dword [0x9886e0], 1
mov dword [0x9876b8], 0xd1fbfcf8
mov byte [0x9876bc], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9876b8]
xor cl, 0xf1
mov byte [eax + 0x987e8c], cl
inc eax
cmp eax, 5
jb 0x90a929
push 0xf
mov esi, 0x987e8c
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 0x90a954
sub eax, ecx
push eax
push esi
lea ecx, [ebp - 0x48]
call fcn.008e4c50
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.008e4cc5
lea eax, [ebp - 0x2c]
push eax
lea edi, [ebp - 0x48]
lea eax, [ebp - 0x64]
mov byte [ebp - 4], 1
call fcn.0090fd8a
pop ecx
push ebx
push 1
lea ecx, [ebp - 0x2c]
call fcn.008e4ce6
push ebx
push 1
mov ecx, edi
mov byte [ebp - 4], 4
call fcn.008e4ce6
push dword [ebp - 0x10]
call dword [0x95a0e0]
push ebx
push dword [ebp + 0xc]
lea esi, [ebp - 0xb8]
call fcn.0090adaa
pop ecx
pop ecx
push eax
mov byte [ebp - 4], 5
call fcn.0090aac8
push eax
lea eax, [ebp - 0x80]
push eax
call fcn.008e6b56
add esp, 0xc
push 0x97338c
push eax
lea eax, [ebp - 0x9c]
push eax
mov byte [ebp - 4], 6
call fcn.008ed6fe
add esp, 0xc
push 0xffffffffffffffff
push ebx
push eax
lea esi, [ebp - 0x64]
mov byte [ebp - 4], 7
call fcn.008eb623
push ebx
push 1
lea ecx, [ebp - 0x9c]
call fcn.008e4ce6
push ebx
push 1
lea ecx, [ebp - 0x80]
call fcn.008e4ce6
push ebx
push 1
lea ecx, [ebp - 0xb8]
mov byte [ebp - 4], 4
call fcn.008e4ce6
mov edi, dword [ebp + 8]
mov dword [edi + 0x14], 0xf
mov dword [edi + 0x10], ebx
mov byte [edi], bl
call fcn.008e4c06
push ebx
push 1
mov ecx, esi
call fcn.008e4ce6
mov eax, edi
mov ecx, dword [ebp - 0xc]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
leave
ret

Function at 0x90aa5f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886e4], 1
jne 0x90aaab
or dword [0x9886e4], 1
mov dword [0x9876a0], 0x94839fa4
mov dword [0x9876a4], 0x9f969e92
mov dword [0x9876a8], 0x95948b98
mov dword [0x9876ac], 0x838394d1
mov dword [0x9876b0], 0x92d1839e
mov dword [0x9876b4], 0xf194959e
xor eax, eax
mov cl, byte [eax + 0x9876a0]
xor cl, 0xf1
mov byte [eax + 0x987e74], cl
inc eax
cmp eax, 0x18
jb 0x90aaad
mov eax, 0x987e74
ret

Function at 0x90aac8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886dc], 1
jne 0x90ab06
or dword [0x9886dc], 1
mov dword [0x9876c0], 0x8394d9d1
mov dword [0x9876c4], 0xd1839e83
mov dword [0x9876c8], 0x94959e92
mov word [0x9876cc], 0xd1cb
mov byte [0x9876ce], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9876c0]
xor cl, 0xf1
mov byte [eax + 0x987e94], cl
inc eax
cmp eax, 0xf
jb 0x90ab08
mov eax, 0x987e94
ret
Function at 0x90adaa
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x48
and dword [ebp - 4], 0
test byte [0x9886d8], 1
jne 0x90add5
or dword [0x9886d8], 1
mov dword [0x9876d0], 0x959d9dd4
mov byte [0x9876d4], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9876d0]
xor cl, 0xf1
mov byte [eax + 0x987ea4], cl
inc eax
cmp eax, 5
jb 0x90add7
push dword [ebp + 0xc]
lea eax, [ebp - 0x48]
push dword [ebp + 8]
push 0x987ea4
push eax
call fcn.0090fde3
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.008e4cc5
mov eax, esi
leave
ret

Function at 0x90af79
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886d4], 1
jne 0x90afd5
or dword [0x9886d4], 1
mov dword [0x9876d8], 0xbc8594b6
mov dword [0x9876dc], 0x9d84959e
mov dword [0x9876e0], 0x9d98b794
mov dword [0x9876e4], 0x9c90bf94
mov dword [0x9876e8], 0x9097d194
mov dword [0x9876ec], 0x95949d98
mov word [0x9876f0], 0xd1cb
mov byte [0x9876f2], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9876d8]
xor cl, 0xf1
mov byte [eax + 0x987eac], cl
inc eax
cmp eax, 0x1b
jb 0x90afd7
mov eax, 0x987eac
ret

Function at 0x90aff5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886d0], 1
jne 0x90b052
or dword [0x9886d0], 1
mov dword [0x9876f4], 0xb28594a2
mov dword [0x9876f8], 0x94838384
mov dword [0x9876fc], 0x98b5859f
mov dword [0x987700], 0x85929483
mov dword [0x987704], 0xd188839e
mov dword [0x987708], 0x9d989097
mov dword [0x98770c], 0xd1cb9594
mov byte [0x987710], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9876f4]
xor cl, 0xf1
mov byte [eax + 0x987ec8], cl
inc eax
cmp eax, 0x1d
jb 0x90b054
mov eax, 0x987ec8
ret

Function at 0x90b166
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886cc], 1
jne 0x90b1c3
or dword [0x9886cc], 1
mov dword [0x987714], 0xb28594b6
mov dword [0x987718], 0x94838384
mov dword [0x98771c], 0x98b5859f
mov dword [0x987720], 0x85929483
mov dword [0x987724], 0xd188839e
mov dword [0x987728], 0x9d989097
mov dword [0x98772c], 0xd1cb9594
mov byte [0x987730], 0xf1
xor eax, eax
mov cl, byte [eax + 0x987714]
xor cl, 0xf1
mov byte [eax + 0x987ee8], cl
inc eax
cmp eax, 0x1d
jb 0x90b1c5
mov eax, 0x987ee8
ret
Function at 0x90b37e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886c8], 1
jne 0x90b4ed
mov eax, 0xbcad
mov ecx, eax
mov word [0x987738], cx
mov word [0x98773a], cx
add ecx, 0xfffffff5
mov word [0x98773c], cx
lea ecx, [eax - 0x28]
mov word [0x98773e], cx
add ecx, 0xfffffffe
lea edx, [eax - 0x15]
mov word [0x987740], cx
push ebx
mov ecx, edx
mov word [0x987742], cx
add ecx, 7
push esi
mov esi, ecx
lea ecx, [eax - 0x16]
mov word [0x987744], si
lea esi, [eax - 0x17]
mov word [0x987746], si
mov word [0x987754], cx
add esi, 8
add edx, 5
mov ecx, esi
push edi
lea edi, [eax - 0x19]
mov word [0x987756], cx
mov ecx, eax
mov word [0x98774c], dx
mov edx, edi
mov word [0x987758], cx
mov word [0x98775a], cx
add ecx, 0x14
mov word [0x98774e], dx
mov edx, ecx
or dword [0x9886c8], 1
mov word [0x98775c], dx
lea edx, [eax + 0x18]
mov ebx, edx
mov word [0x98775e], bx
mov ebx, ecx
mov word [0x987760], bx
lea ebx, [eax + 0x1b]
mov word [0x98776e], ax
mov word [0x987762], bx
mov ebx, ecx
mov ecx, eax
add eax, 0xfffffff4
mov word [0x987770], ax
lea eax, [ecx - 0x18]
mov word [0x987776], ax
add eax, 0xffffffef
mov word [0x987778], ax
lea eax, [ecx - 0x1b]
mov word [0x98777a], ax
add eax, 0xfffffff3
mov word [0x98777c], ax
lea eax, [ecx + 0x12]
mov word [0x98777e], ax
add eax, 0xffffffd1
pop edi
mov word [0x987780], ax
lea eax, [ecx + 0x44]
pop esi
mov word [0x987764], bx
mov dword [0x987748], 0xbc98bcb7
mov dword [0x987750], 0xbc9fbcb8
mov word [0x987766], dx
mov dword [0x987768], 0xbcc1bcb3
mov word [0x98776c], cx
mov dword [0x987772], 0xbc9ebc83
mov dword [0x987782], 0xbc94bc9c
mov word [0x987786], ax
pop ebx
xor eax, eax
mov ecx, 0xbcf1
xor cx, word [eax + 0x987738]
add eax, 2
mov word [eax + 0x987f06], cx
cmp eax, 0x50
jb 0x90b4ef
mov eax, 0x987f08
ret

Function at 0x90b510
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886c4], 1
jne 0x90b565
or dword [0x9886c4], 1
mov dword [0x987788], 0x87d19ebf
mov dword [0x98778c], 0x98828394
mov dword [0x987790], 0x98d19f9e
mov dword [0x987794], 0xd19e979f
mov dword [0x987798], 0x98908790
mov dword [0x98779c], 0x9d93909d
mov word [0x9877a0], 0xf194
xor eax, eax
mov cl, byte [eax + 0x987788]
xor cl, 0xf1
mov byte [eax + 0x987f58], cl
inc eax
cmp eax, 0x1a
jb 0x90b567
mov eax, 0x987f58
ret

Function at 0x90b754
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886c0], 1
jne 0x90b7a9
or dword [0x9886c0], 1
mov dword [0x9877a4], 0x87d19ebf
mov dword [0x9877a8], 0x98828394
mov dword [0x9877ac], 0x98d19f9e
mov dword [0x9877b0], 0xd19e979f
mov dword [0x9877b4], 0x98908790
mov dword [0x9877b8], 0x9d93909d
mov word [0x9877bc], 0xf194
xor eax, eax
mov cl, byte [eax + 0x9877a4]
xor cl, 0xf1
mov byte [eax + 0x987f74], cl
inc eax
cmp eax, 0x1a
jb 0x90b7ab
mov eax, 0x987f74
ret
Function at 0x90b7c6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886bc], 1
jne 0x90b82c
or dword [0x9886bc], 1
mov dword [0x9877c0], 0x90879fb8
mov dword [0x9877c4], 0xd195989d
mov dword [0x9877c8], 0x82839487
mov dword [0x9877cc], 0xd19f9e98
mov dword [0x9877d0], 0x9e979f98
mov dword [0x9877d4], 0x969882d1
mov dword [0x9877d8], 0x8485909f
mov word [0x9877dc], 0x9483
mov byte [0x9877de], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9877c0]
xor cl, 0xf1
mov byte [eax + 0x987f90], cl
inc eax
cmp eax, 0x1f
jb 0x90b82e
mov eax, 0x987f90
ret

Function at 0x90bb33
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886b8], 1
jne 0x90bb99
or dword [0x9886b8], 1
mov dword [0x9877e0], 0x9d9890b7
mov dword [0x9877e4], 0x85d19594
mov dword [0x9877e8], 0x9496d19e
mov dword [0x9877ec], 0x9485d185
mov dword [0x9877f0], 0x97d1819c
mov dword [0x9877f4], 0x94959d9e
mov dword [0x9877f8], 0x9081d183
mov word [0x9877fc], 0x9985
mov byte [0x9877fe], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9877e0]
xor cl, 0xf1
mov byte [eax + 0x987fb0], cl
inc eax
cmp eax, 0x1f
jb 0x90bb9b
mov eax, 0x987fb0
ret

Function at 0x90bd0b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886b4], 1
jne 0x90bd5d
or dword [0x9886b4], 1
mov dword [0x987800], 0xb78594b6
mov dword [0x987804], 0x94959d9e
mov dword [0x987808], 0x8590a183
mov dword [0x98780c], 0x9097d199
mov dword [0x987810], 0x95949d98
mov word [0x987814], 0xd1cb
mov byte [0x987816], 0xf1
xor eax, eax
mov cl, byte [eax + 0x987800]
xor cl, 0xf1
mov byte [eax + 0x987fd0], cl
inc eax
cmp eax, 0x17
jb 0x90bd5f
mov eax, 0x987fd0
ret

Function at 0x90c027
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886b0], 1
mov edx, 0xbcf1
jne 0x90c0be
or dword [0x9886b0], 1
lea ecx, [edx - 0x1d]
mov eax, ecx
mov word [0x987818], ax
add eax, 0xffffffcd
mov word [0x98781a], ax
push esi
lea eax, [edx - 0x6e]
mov esi, eax
add eax, 0xd
mov word [0x987824], ax
lea eax, [edx - 0x55]
mov word [0x987826], ax
add eax, 0xa
mov word [0x987828], ax
lea eax, [edx - 0x2a]
mov word [0x98781c], si
add esi, 0x1b
mov word [0x98782a], ax
add eax, 0xfffffffe
mov word [0x98782c], ax
lea eax, [edx - 0x2f]
mov word [0x98782e], ax
mov eax, edx
mov word [0x98781e], si
mov dword [0x987820], 0xbc83bc96
mov dword [0x987830], 0xbcd4bcc3
mov word [0x987834], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x987818]
add eax, 2
mov word [eax + 0x987fe6], cx
cmp eax, 0x1e
jb 0x90c0c0
mov eax, 0x987fe8
ret

Function at 0x90c0de
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886ac], 1
mov ecx, 0xbcf1
jne 0x90c11f
or dword [0x9886ac], 1
lea eax, [ecx - 0x67]
mov word [0x987838], ax
add eax, 0xfffffff7
mov word [0x98783a], ax
lea eax, [ecx - 0x5a]
mov word [0x98783c], ax
add eax, 0xfffffff5
mov word [0x98783e], ax
mov eax, ecx
mov word [0x987840], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987838]
add eax, 2
mov word [eax + 0x988006], dx
cmp eax, 0xa
jb 0x90c121
mov eax, 0x988008
ret
Function at 0x90c13f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886a8], 1
mov ecx, 0xbcf1
jne 0x90c192
or dword [0x9886a8], 1
lea eax, [ecx - 0x67]
mov word [0x987844], ax
add eax, 0xfffffff7
mov word [0x987846], ax
lea eax, [ecx - 0x5a]
mov word [0x987848], ax
add eax, 0x2b
mov word [0x98784a], ax
lea eax, [ecx - 0x2e]
mov word [0x98784c], ax
add eax, 0xffffffc9
mov word [0x98784e], ax
mov eax, ecx
mov word [0x987850], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987844]
add eax, 2
mov word [eax + 0x988012], dx
cmp eax, 0xe
jb 0x90c194
mov eax, 0x988014
ret

Function at 0x90c1b2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886a4], 1
mov ecx, 0xbcf1
jne 0x90c205
or dword [0x9886a4], 1
lea eax, [ecx - 0x67]
mov word [0x987854], ax
add eax, 0xfffffff7
mov word [0x987856], ax
lea eax, [ecx - 0x5a]
mov word [0x987858], ax
add eax, 0x30
mov word [0x98785a], ax
lea eax, [ecx - 0x2c]
mov word [0x98785c], ax
add eax, 0xffffffc7
mov word [0x98785e], ax
mov eax, ecx
mov word [0x987860], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987854]
add eax, 2
mov word [eax + 0x988022], dx
cmp eax, 0xe
jb 0x90c207
mov eax, 0x988024
ret

Function at 0x90c225
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9886a0], 1
mov ecx, 0xbcf1
jne 0x90c266
or dword [0x9886a0], 1
lea eax, [ecx - 0x67]
mov word [0x987864], ax
add eax, 0xfffffff7
mov word [0x987866], ax
lea eax, [ecx - 0x5a]
mov word [0x987868], ax
add eax, 0xfffffff5
mov word [0x98786a], ax
mov eax, ecx
mov word [0x98786c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987864]
add eax, 2
mov word [eax + 0x988032], dx
cmp eax, 0xa
jb 0x90c268
mov eax, 0x988034
ret

Function at 0x90c286
Capabilities:
Encode data using xor

Disassembly:
test byte [0x98869c], 1
mov ecx, 0xbcf1
jne 0x90c2d9
or dword [0x98869c], 1
lea eax, [ecx - 0x67]
mov word [0x987870], ax
add eax, 0xfffffff7
mov word [0x987872], ax
lea eax, [ecx - 0x5a]
mov word [0x987874], ax
add eax, 0x2b
mov word [0x987876], ax
lea eax, [ecx - 0x2e]
mov word [0x987878], ax
add eax, 0xffffffc9
mov word [0x98787a], ax
mov eax, ecx
mov word [0x98787c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987870]
add eax, 2
mov word [eax + 0x98803e], dx
cmp eax, 0xe
jb 0x90c2db
mov eax, 0x988040
ret
Function at 0x90c3d3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988698], 1
mov ecx, 0xbcf1
jne 0x90c618
or dword [0x988698], 1
lea eax, [ecx - 0x30]
mov word [0x987888], ax
dec eax
mov word [0x98788a], ax
lea eax, [ecx - 0x2e]
mov word [0x98788c], ax
dec eax
mov word [0x98788e], ax
lea eax, [ecx - 0x2c]
mov word [0x987890], ax
dec eax
mov word [0x987892], ax
lea eax, [ecx - 0x2a]
mov word [0x987894], ax
dec eax
mov word [0x987896], ax
lea eax, [ecx - 0x28]
mov word [0x987898], ax
dec eax
mov word [0x98789a], ax
lea eax, [ecx - 0x41]
mov word [0x98789c], ax
add eax, 3
mov word [0x98789e], ax
lea eax, [ecx - 0x3f]
mov word [0x9878a0], ax
add eax, 3
mov word [0x9878a2], ax
lea eax, [ecx - 0x3d]
mov word [0x9878a4], ax
add eax, 3
mov word [0x9878a6], ax
lea eax, [ecx - 0x3b]
mov word [0x9878a8], ax
add eax, 3
mov word [0x9878aa], ax
lea eax, [ecx - 0x39]
mov word [0x9878ac], ax
add eax, 3
mov word [0x9878ae], ax
lea eax, [ecx - 0x37]
mov word [0x9878b0], ax
add eax, 3
mov word [0x9878b2], ax
lea eax, [ecx - 0x35]
mov word [0x9878b4], ax
add eax, 3
mov word [0x9878b6], ax
lea eax, [ecx - 0x33]
mov word [0x9878b8], ax
add eax, 0xffffffe3
mov word [0x9878ba], ax
lea eax, [ecx - 0x51]
mov word [0x9878bc], ax
add eax, 3
mov word [0x9878be], ax
lea eax, [ecx - 0x4f]
mov word [0x9878c0], ax
add eax, 3
mov word [0x9878c2], ax
lea eax, [ecx - 0x4d]
mov word [0x9878c4], ax
add eax, 3
mov word [0x9878c6], ax
lea eax, [ecx - 0x4b]
mov word [0x9878c8], ax
add eax, 3
mov word [0x9878ca], ax
lea eax, [ecx - 0x49]
mov word [0x9878cc], ax
add eax, 3
mov word [0x9878ce], ax
lea eax, [ecx - 0x61]
mov word [0x9878d0], ax
add eax, 3
mov word [0x9878d2], ax
lea eax, [ecx - 0x5f]
mov word [0x9878d4], ax
add eax, 3
mov word [0x9878d6], ax
lea eax, [ecx - 0x5d]
mov word [0x9878d8], ax
add eax, 3
mov word [0x9878da], ax
lea eax, [ecx - 0x5b]
mov word [0x9878dc], ax
add eax, 3
mov word [0x9878de], ax
lea eax, [ecx - 0x59]
mov word [0x9878e0], ax
add eax, 3
mov word [0x9878e2], ax
lea eax, [ecx - 0x57]
mov word [0x9878e4], ax
add eax, 3
mov word [0x9878e6], ax
lea eax, [ecx - 0x55]
mov word [0x9878e8], ax
add eax, 3
mov word [0x9878ea], ax
lea eax, [ecx - 0x53]
mov word [0x9878ec], ax
add eax, 0xffffffe3
mov word [0x9878ee], ax
lea eax, [ecx - 0x71]
mov word [0x9878f0], ax
add eax, 3
mov word [0x9878f2], ax
lea eax, [ecx - 0x6f]
mov word [0x9878f4], ax
add eax, 3
mov word [0x9878f6], ax
lea eax, [ecx - 0x6d]
mov word [0x9878f8], ax
add eax, 3
mov word [0x9878fa], ax
lea eax, [ecx - 0x6b]
mov word [0x9878fc], ax
add eax, 3
mov word [0x9878fe], ax
lea eax, [ecx - 0x69]
mov word [0x987900], ax
add eax, 3
mov word [0x987902], ax
mov eax, ecx
mov word [0x987904], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x987888]
add eax, 2
mov word [eax + 0x98804e], dx
cmp eax, 0x7e
jb 0x90c61a
mov eax, 0x988050
ret
Function at 0x90ccea
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988694], 1
jne 0x90cd51
or dword [0x988694], 1
mov dword [0x987908], 0x8bae8b9c
mov dword [0x98790c], 0x83ae8198
mov dword [0x987910], 0x94959094
mov dword [0x987914], 0x9f98ae83
mov dword [0x987918], 0x97ae8598
mov dword [0x98791c], 0xd9949d98
mov dword [0x987920], 0x9097d1d8
mov dword [0x987924], 0x95949d98
mov byte [0x987928], 0xf1
xor eax, eax
mov cl, byte [eax + 0x987908]
xor cl, 0xf1
mov byte [eax + 0x9880d0], cl
inc eax
cmp eax, 0x21
jb 0x90cd53
mov eax, 0x9880d0
ret

Function at 0x90cd6e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988690], 1
jne 0x90cdd5
or dword [0x988690], 1
mov dword [0x98792c], 0x8bae8b9c
mov dword [0x987930], 0x83ae8198
mov dword [0x987934], 0x94959094
mov dword [0x987938], 0x9897ae83
mov dword [0x98793c], 0x82ae949d
mov dword [0x987940], 0xd9859085
mov dword [0x987944], 0x9097d1d8
mov dword [0x987948], 0x95949d98
mov byte [0x98794c], 0xf1
xor eax, eax
mov cl, byte [eax + 0x98792c]
xor cl, 0xf1
mov byte [eax + 0x9880f4], cl
inc eax
cmp eax, 0x21
jb 0x90cdd7
mov eax, 0x9880f4
ret

Function at 0x90cdf2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x98868c], 1
jne 0x90ce70
or dword [0x98868c], 1
mov dword [0x987950], 0x8bae8b9c
mov dword [0x987954], 0x83ae8198
mov dword [0x987958], 0x94959094
mov dword [0x98795c], 0x8994ae83
mov dword [0x987960], 0x92908385
mov dword [0x987964], 0x9897ae85
mov dword [0x987968], 0x85ae949d
mov dword [0x98796c], 0x9499ae9e
mov dword [0x987970], 0xd8d98190
mov dword [0x987974], 0x989097d1
mov dword [0x987978], 0xf195949d
xor eax, eax
mov cl, byte [eax + 0x987950]
xor cl, 0xf1
mov byte [eax + 0x988118], cl
inc eax
cmp eax, 0x2c
jb 0x90ce72
mov eax, 0x988118
ret

Function at 0x90ce8d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988688], 1
jne 0x90cef7
or dword [0x988688], 1
mov dword [0x98797c], 0x9d9890b7
mov dword [0x987980], 0x85d19594
mov dword [0x987984], 0x8392d19e
mov dword [0x987988], 0x94859094
mov dword [0x98798c], 0x829495d1
mov dword [0x987990], 0x909f9885
mov dword [0x987994], 0x9f9e9885
mov dword [0x987998], 0x859081d1
mov dword [0x98799c], 0xf1d1cb99
xor eax, eax
mov cl, byte [eax + 0x98797c]
xor cl, 0xf1
mov byte [eax + 0x988144], cl
inc eax
cmp eax, 0x24
jb 0x90cef9
mov eax, 0x988144
ret

Function at 0x90cf14
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988684], 1
jne 0x90cf7a
or dword [0x988684], 1
mov dword [0x9879a0], 0x9d9890b7
mov dword [0x9879a4], 0x85d19594
mov dword [0x9879a8], 0x8392d19e
mov dword [0x9879ac], 0x94859094
mov dword [0x9879b0], 0x85849ed1
mov dword [0x9879b4], 0xd1858481
mov dword [0x9879b8], 0x949d9897
mov word [0x9879bc], 0xd1cb
mov byte [0x9879be], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9879a0]
xor cl, 0xf1
mov byte [eax + 0x988168], cl
inc eax
cmp eax, 0x1f
jb 0x90cf7c
mov eax, 0x988168
ret
Function at 0x90cfb1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988680], 1
jne 0x90cfef
or dword [0x988680], 1
mov dword [0x9879c0], 0x9ea682b8
mov dword [0x9879c4], 0xa1c5c786
mov dword [0x9879c8], 0x94929e83
mov word [0x9879cc], 0x8282
mov byte [0x9879ce], 0xf1
xor eax, eax
mov cl, byte [eax + 0x9879c0]
xor cl, 0xf1
mov byte [eax + 0x988188], cl
inc eax
cmp eax, 0xf
jb 0x90cff1
mov eax, 0x988188
ret

Function at 0x90d107
Capabilities:
Encode data using xor

Disassembly:
test byte [0x98867c], 1
jne 0x90d170
or dword [0x98867c], 1
mov dword [0x9879d0], 0x9e9d9db0
mov dword [0x9879d4], 0x94859092
mov dword [0x9879d8], 0xb8959fb0
mov dword [0x9879dc], 0x9885989f
mov dword [0x9879e0], 0x8b989d90
mov dword [0x9879e4], 0x9598a294
mov dword [0x9879e8], 0x989097d1
mov dword [0x9879ec], 0xcb95949d
mov word [0x9879f0], 0xf1d1
xor eax, eax
mov cl, byte [eax + 0x9879d0]
xor cl, 0xf1
mov byte [eax + 0x988198], cl
inc eax
cmp eax, 0x22
jb 0x90d172
mov eax, 0x988198
ret

Function at 0x90d18d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988678], 1
jne 0x90d1ec
or dword [0x988678], 1
mov dword [0x9879f4], 0x929499b2
mov dword [0x9879f8], 0x9a9ea59a
mov dword [0x9879fc], 0x94bc9f94
mov dword [0x987a00], 0x8394939c
mov dword [0x987a04], 0x81989982
mov dword [0x987a08], 0x989097d1
mov dword [0x987a0c], 0xcb95949d
mov word [0x987a10], 0xf1d1
xor eax, eax
mov cl, byte [eax + 0x9879f4]
xor cl, 0xf1
mov byte [eax + 0x9881bc], cl
inc eax
cmp eax, 0x1e
jb 0x90d1ee
mov eax, 0x9881bc
ret

Function at 0x90d452
Capabilities:
Encode data using xor

Disassembly:
test byte [0x98866c], 1
jne 0x90d4d7
or dword [0x98866c], 1
mov dword [0x987a28], 0x9f9f90b2
mov dword [0x987a2c], 0x80d1859e
mov dword [0x987a30], 0x88839484
mov dword [0x987a34], 0xc7d190d1
mov dword [0x987a38], 0x9893d1c5
mov dword [0x987a3c], 0x9887d185
mov dword [0x987a40], 0x9ed18694
mov dword [0x987a44], 0xc3c2d19f
mov dword [0x987a48], 0x859893d1
mov dword [0x987a4c], 0x9f9886d1
mov dword [0x987a50], 0x82869e95
mov byte [0x987a54], 0xf1
xor eax, eax
mov cl, byte [eax + 0x987a28]
xor cl, 0xf1
mov byte [eax + 0x9881f0], cl
inc eax
cmp eax, 0x2d
jb 0x90d4d9
mov eax, 0x9881f0
ret

Function at 0x90d4f4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x988668], 1
jne 0x90d5a4
or dword [0x988668], 1
push ebx
push esi
mov eax, 0xbcb9
mov word [0x987a58], ax
inc eax
mov word [0x987a5a], ax
push edi
mov edi, 0xbcb4
mov eax, edi
mov word [0x987a5c], ax
add eax, 0xfffffff4
mov word [0x987a5e], ax
lea esi, [edi - 6]
mov eax, esi
mov word [0x987a60], ax
lea edx, [edi + 9]
mov eax, edx
mov word [0x987a62], ax
inc eax
mov word [0x987a64], ax
lea ecx, [edi - 2]
mov eax, ecx
mov word [0x987a66], ax
add eax, 0xfffffffe
mov ebx, eax
lea eax, [edi + 4]
pop edi
mov word [0x987a76], ax
add eax, 0x39
pop esi
mov word [0x987a68], bx
mov dword [0x987a6a], 0xbcaebcbd
mov dword [0x987a6e], 0xbcb0bcbc
mov dword [0x987a72], 0xbcb9bcb2
mov dword [0x987a78], 0xbcb4bcbf
mov word [0x987a7c], ax
pop ebx
xor eax, eax
mov ecx, 0xbcf1
xor cx, word [eax + 0x987a58]
add eax, 2
mov word [eax + 0x98821e], cx
cmp eax, 0x26
jb 0x90d5a6
mov eax, 0x988220
ret