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

Disassembly:
test byte [0x1b270c], 1
jne 0x119c15
or dword [0x1b270c], 1
mov dword [0x1b1554], 0xa7e2ad8c
mov dword [0x1b1558], 0xb0adb0b0
mov dword [0x1b155c], 0xb1a7afe2
mov dword [0x1b1560], 0xa7a5a3b1
mov dword [0x1b1564], 0xb6a7b0e2
mov dword [0x1b1568], 0xa7acb0b7
mov dword [0x1b156c], 0xbba0e2a6
mov dword [0x1b1570], 0xa0ada8e2
mov byte [0x1b1574], 0xc2
xor eax, eax
mov cl, byte [eax + 0x1b1554]
xor cl, 0xc2
mov byte [eax + 0x1b161c], cl
inc eax
cmp eax, 0x21
jb 0x119c17
mov eax, 0x1b161c
ret

Function at 0x119c32
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2700], 1
jne 0x119c9b
or dword [0x1b2700], 1
mov dword [0x1b15a0], 0xe2a3b78e
mov dword [0x1b15a4], 0xadb0b0a7
mov dword [0x1b15a8], 0xb7b0e2b0
mov dword [0x1b15ac], 0xacabacac
mov dword [0x1b15b0], 0xb0a7e2a5
mov dword [0x1b15b4], 0xe2b0adb0
mov dword [0x1b15b8], 0xa6aca3aa
mov dword [0x1b15bc], 0xf8b0a7ae
mov word [0x1b15c0], 0xc2e2
xor eax, eax
mov cl, byte [eax + 0x1b15a0]
xor cl, 0xc2
mov byte [eax + 0x1b1668], cl
inc eax
cmp eax, 0x22
jb 0x119c9d
mov eax, 0x1b1668
ret

Function at 0x119cb8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26fc], 1
jne 0x119d0a
or dword [0x1b26fc], 1
mov dword [0x1b15c4], 0x8ea3b7ae
mov dword [0x1b15c8], 0xa3adae9d
mov dword [0x1b15cc], 0xb0b6b1a6
mov dword [0x1b15d0], 0xe2a5acab
mov dword [0x1b15d4], 0xaeaba3a4
mov word [0x1b15d8], 0xa6a7
mov byte [0x1b15da], 0xc2
xor eax, eax
mov cl, byte [eax + 0x1b15c4]
xor cl, 0xc2
mov byte [eax + 0x1b168c], cl
inc eax
cmp eax, 0x17
jb 0x119d0c
mov eax, 0x1b168c
ret
Function at 0x11aa2a
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x17af0f
call fcn.00179dc8
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 [0x18212c]
test eax, eax
jne 0x11aa72
call fcn.0011abcb
mov ecx, dword [ebp + 8]
push eax
call fcn.000f6b9c
mov eax, dword [ebp + 8]
jmp 0x11abbc
test byte [0x1b26f0], 1
jne 0x11aa93
or dword [0x1b26f0], 1
mov dword [0x1b16c8], 0xe5cfc8cc
mov byte [0x1b16cc], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b16c8]
xor cl, 0xc5
mov byte [eax + 0x1b1e9c], cl
inc eax
cmp eax, 5
jb 0x11aa95
push 0xf
mov esi, 0x1b1e9c
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 0x11aac0
sub eax, ecx
push eax
push esi
lea ecx, [ebp - 0x48]
call fcn.000f4c4f
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.000f4cc4
lea eax, [ebp - 0x2c]
push eax
lea edi, [ebp - 0x48]
lea eax, [ebp - 0x64]
mov byte [ebp - 4], 1
call fcn.0011fef9
pop ecx
push ebx
push 1
lea ecx, [ebp - 0x2c]
call fcn.000f4ce5
push ebx
push 1
mov ecx, edi
mov byte [ebp - 4], 4
call fcn.000f4ce5
push dword [ebp - 0x10]
call dword [0x1820e0]
push ebx
push dword [ebp + 0xc]
lea esi, [ebp - 0xb8]
call fcn.0011af16
pop ecx
pop ecx
push eax
mov byte [ebp - 4], 5
call fcn.0011ac34
push eax
lea eax, [ebp - 0x80]
push eax
call fcn.000f6bd9
add esp, 0xc
push 0x19d290
push eax
lea eax, [ebp - 0x9c]
push eax
mov byte [ebp - 4], 6
call fcn.000fd7df
add esp, 0xc
push 0xffffffffffffffff
push ebx
push eax
lea esi, [ebp - 0x64]
mov byte [ebp - 4], 7
call fcn.000fb704
push ebx
push 1
lea ecx, [ebp - 0x9c]
call fcn.000f4ce5
push ebx
push 1
lea ecx, [ebp - 0x80]
call fcn.000f4ce5
push ebx
push 1
lea ecx, [ebp - 0xb8]
mov byte [ebp - 4], 4
call fcn.000f4ce5
mov edi, dword [ebp + 8]
mov dword [edi + 0x14], 0xf
mov dword [edi + 0x10], ebx
mov byte [edi], bl
call fcn.000f4c05
push ebx
push 1
mov ecx, esi
call fcn.000f4ce5
mov eax, edi
mov ecx, dword [ebp - 0xc]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
leave
ret

Function at 0x11abcb
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26f4], 1
jne 0x11ac17
or dword [0x1b26f4], 1
mov dword [0x1b16b0], 0xa0b7ab90
mov dword [0x1b16b4], 0xaba2aaa6
mov dword [0x1b16b8], 0xa1a0bfac
mov dword [0x1b16bc], 0xb7b7a0e5
mov dword [0x1b16c0], 0xa6e5b7aa
mov dword [0x1b16c4], 0xc5a0a1aa
xor eax, eax
mov cl, byte [eax + 0x1b16b0]
xor cl, 0xc5
mov byte [eax + 0x1b1e84], cl
inc eax
cmp eax, 0x18
jb 0x11ac19
mov eax, 0x1b1e84
ret

Function at 0x11ac34
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26ec], 1
jne 0x11ac72
or dword [0x1b26ec], 1
mov dword [0x1b16d0], 0xb7a0ede5
mov dword [0x1b16d4], 0xe5b7aab7
mov dword [0x1b16d8], 0xa0a1aaa6
mov word [0x1b16dc], 0xe5ff
mov byte [0x1b16de], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b16d0]
xor cl, 0xc5
mov byte [eax + 0x1b1ea4], cl
inc eax
cmp eax, 0xf
jb 0x11ac74
mov eax, 0x1b1ea4
ret
Function at 0x11af16
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x48
and dword [ebp - 4], 0
test byte [0x1b26e8], 1
jne 0x11af41
or dword [0x1b26e8], 1
mov dword [0x1b16e0], 0xa1a9a9e0
mov byte [0x1b16e4], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b16e0]
xor cl, 0xc5
mov byte [eax + 0x1b1eb4], cl
inc eax
cmp eax, 5
jb 0x11af43
push dword [ebp + 0xc]
lea eax, [ebp - 0x48]
push dword [ebp + 8]
push 0x1b1eb4
push eax
call fcn.0011ff52
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.000f4cc4
mov eax, esi
leave
ret

Function at 0x11b0e5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26e4], 1
jne 0x11b141
or dword [0x1b26e4], 1
mov dword [0x1b16e8], 0x88b1a082
mov dword [0x1b16ec], 0xa9b0a1aa
mov dword [0x1b16f0], 0xa9ac83a0
mov dword [0x1b16f4], 0xa8a48ba0
mov dword [0x1b16f8], 0xa4a3e5a0
mov dword [0x1b16fc], 0xa1a0a9ac
mov word [0x1b1700], 0xe5ff
mov byte [0x1b1702], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b16e8]
xor cl, 0xc5
mov byte [eax + 0x1b1ebc], cl
inc eax
cmp eax, 0x1b
jb 0x11b143
mov eax, 0x1b1ebc
ret

Function at 0x11b15e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26e0], 1
jne 0x11b1bb
or dword [0x1b26e0], 1
mov dword [0x1b1704], 0x86b1a096
mov dword [0x1b1708], 0xa0b7b7b0
mov dword [0x1b170c], 0xac81b1ab
mov dword [0x1b1710], 0xb1a6a0b7
mov dword [0x1b1714], 0xe5bcb7aa
mov dword [0x1b1718], 0xa9aca4a3
mov dword [0x1b171c], 0xe5ffa1a0
mov byte [0x1b1720], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b1704]
xor cl, 0xc5
mov byte [eax + 0x1b1ed8], cl
inc eax
cmp eax, 0x1d
jb 0x11b1bd
mov eax, 0x1b1ed8
ret

Function at 0x11b2cf
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26dc], 1
jne 0x11b32c
or dword [0x1b26dc], 1
mov dword [0x1b1724], 0x86b1a082
mov dword [0x1b1728], 0xa0b7b7b0
mov dword [0x1b172c], 0xac81b1ab
mov dword [0x1b1730], 0xb1a6a0b7
mov dword [0x1b1734], 0xe5bcb7aa
mov dword [0x1b1738], 0xa9aca4a3
mov dword [0x1b173c], 0xe5ffa1a0
mov byte [0x1b1740], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b1724]
xor cl, 0xc5
mov byte [eax + 0x1b1ef8], cl
inc eax
cmp eax, 0x1d
jb 0x11b32e
mov eax, 0x1b1ef8
ret
Function at 0x11b4e7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26d8], 1
jne 0x11b654
or dword [0x1b26d8], 1
mov eax, 0x8399
mov ecx, eax
mov word [0x1b1748], cx
mov word [0x1b174a], cx
add ecx, 0xfffffffd
mov word [0x1b174c], cx
lea ecx, [eax + 0x18]
mov word [0x1b174e], cx
add ecx, 6
lea edx, [eax + 0x13]
mov word [0x1b1750], cx
push ebx
mov ecx, edx
mov word [0x1b1752], cx
dec ecx
push esi
mov esi, ecx
lea ecx, [eax + 0xa]
mov word [0x1b1754], si
lea esi, [eax + 9]
mov word [0x1b1756], si
mov word [0x1b1764], cx
add esi, 8
add edx, 0xfffffffd
mov ecx, esi
push edi
lea edi, [eax + 7]
mov word [0x1b1766], cx
mov ecx, eax
mov word [0x1b175c], dx
mov edx, edi
mov word [0x1b1768], cx
mov word [0x1b176a], cx
add ecx, 0x5c
mov word [0x1b175e], dx
mov edx, ecx
mov word [0x1b176c], dx
lea edx, [eax + 0x58]
mov ebx, edx
mov word [0x1b176e], bx
mov ebx, ecx
mov word [0x1b1770], bx
lea ebx, [eax + 0x63]
mov word [0x1b177e], ax
mov word [0x1b1772], bx
mov ebx, ecx
mov ecx, eax
add eax, 0xfffffffc
mov word [0x1b1780], ax
lea eax, [ecx + 8]
mov word [0x1b1786], ax
add eax, 0xf
mov word [0x1b1788], ax
lea eax, [ecx + 0xd]
mov word [0x1b178a], ax
add eax, 0xb
mov word [0x1b178c], ax
lea eax, [ecx - 0xe]
mov word [0x1b178e], ax
add eax, 0x19
pop edi
mov word [0x1b1790], ax
lea eax, [ecx + 0x2c]
pop esi
mov word [0x1b1774], bx
mov dword [0x1b1758], 0x83ac8383
mov dword [0x1b1760], 0x83ab838c
mov word [0x1b1776], dx
mov dword [0x1b1778], 0x83f58387
mov word [0x1b177c], cx
mov dword [0x1b1782], 0x83aa83b7
mov dword [0x1b1792], 0x83a083a8
mov word [0x1b1796], ax
pop ebx
xor eax, eax
mov ecx, 0x83c5
xor cx, word [eax + 0x1b1748]
add eax, 2
mov word [eax + 0x1b1f16], cx
cmp eax, 0x50
jb 0x11b656
mov eax, 0x1b1f18
ret

Function at 0x11b677
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26d4], 1
jne 0x11b6cc
or dword [0x1b26d4], 1
mov dword [0x1b1798], 0xb3e5aa8b
mov dword [0x1b179c], 0xacb6b7a0
mov dword [0x1b17a0], 0xace5abaa
mov dword [0x1b17a4], 0xe5aaa3ab
mov dword [0x1b17a8], 0xaca4b3a4
mov dword [0x1b17ac], 0xa9a7a4a9
mov word [0x1b17b0], 0xc5a0
xor eax, eax
mov cl, byte [eax + 0x1b1798]
xor cl, 0xc5
mov byte [eax + 0x1b1f68], cl
inc eax
cmp eax, 0x1a
jb 0x11b6ce
mov eax, 0x1b1f68
ret

Function at 0x11b8bb
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26d0], 1
jne 0x11b910
or dword [0x1b26d0], 1
mov dword [0x1b17b4], 0xb3e5aa8b
mov dword [0x1b17b8], 0xacb6b7a0
mov dword [0x1b17bc], 0xace5abaa
mov dword [0x1b17c0], 0xe5aaa3ab
mov dword [0x1b17c4], 0xaca4b3a4
mov dword [0x1b17c8], 0xa9a7a4a9
mov word [0x1b17cc], 0xc5a0
xor eax, eax
mov cl, byte [eax + 0x1b17b4]
xor cl, 0xc5
mov byte [eax + 0x1b1f84], cl
inc eax
cmp eax, 0x1a
jb 0x11b912
mov eax, 0x1b1f84
ret
Function at 0x11b92d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26cc], 1
jne 0x11b993
or dword [0x1b26cc], 1
mov dword [0x1b17d0], 0xa4b3ab8c
mov dword [0x1b17d4], 0xe5a1aca9
mov dword [0x1b17d8], 0xb6b7a0b3
mov dword [0x1b17dc], 0xe5abaaac
mov dword [0x1b17e0], 0xaaa3abac
mov dword [0x1b17e4], 0xa2acb6e5
mov dword [0x1b17e8], 0xb0b1a4ab
mov word [0x1b17ec], 0xa0b7
mov byte [0x1b17ee], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b17d0]
xor cl, 0xc5
mov byte [eax + 0x1b1fa0], cl
inc eax
cmp eax, 0x1f
jb 0x11b995
mov eax, 0x1b1fa0
ret

Function at 0x11bc9a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26c8], 1
jne 0x11bd00
or dword [0x1b26c8], 1
mov dword [0x1b17f0], 0xa9aca483
mov dword [0x1b17f4], 0xb1e5a1a0
mov dword [0x1b17f8], 0xa0a2e5aa
mov dword [0x1b17fc], 0xa0b1e5b1
mov dword [0x1b1800], 0xa3e5b5a8
mov dword [0x1b1804], 0xa0a1a9aa
mov dword [0x1b1808], 0xa4b5e5b7
mov word [0x1b180c], 0xadb1
mov byte [0x1b180e], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b17f0]
xor cl, 0xc5
mov byte [eax + 0x1b1fc0], cl
inc eax
cmp eax, 0x1f
jb 0x11bd02
mov eax, 0x1b1fc0
ret

Function at 0x11be72
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26c4], 1
jne 0x11bec4
or dword [0x1b26c4], 1
mov dword [0x1b1810], 0x83b1a082
mov dword [0x1b1814], 0xa0a1a9aa
mov dword [0x1b1818], 0xb1a495b7
mov dword [0x1b181c], 0xa4a3e5ad
mov dword [0x1b1820], 0xa1a0a9ac
mov word [0x1b1824], 0xe5ff
mov byte [0x1b1826], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b1810]
xor cl, 0xc5
mov byte [eax + 0x1b1fe0], cl
inc eax
cmp eax, 0x17
jb 0x11bec6
mov eax, 0x1b1fe0
ret

Function at 0x11c18e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26c0], 1
mov edx, 0x83c5
jne 0x11c225
or dword [0x1b26c0], 1
lea ecx, [edx + 0x1b]
mov eax, ecx
mov word [0x1b1828], ax
add eax, 0xffffffb5
mov word [0x1b182a], ax
push esi
lea eax, [edx - 0xe]
mov esi, eax
add eax, 0xffffffed
mov word [0x1b1834], ax
lea eax, [edx - 0x1d]
mov word [0x1b1836], ax
add eax, 0xffffffea
mov word [0x1b1838], ax
lea eax, [edx + 0x2e]
mov word [0x1b182c], si
add esi, 0xfffffff3
mov word [0x1b183a], ax
add eax, 0xfffffffe
mov word [0x1b183c], ax
lea eax, [edx + 0x31]
mov word [0x1b183e], ax
mov eax, edx
mov word [0x1b182e], si
mov dword [0x1b1830], 0x83b783a2
mov dword [0x1b1840], 0x83e083f7
mov word [0x1b1844], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x1b1828]
add eax, 2
mov word [eax + 0x1b1ff6], cx
cmp eax, 0x1e
jb 0x11c227
mov eax, 0x1b1ff8
ret

Function at 0x11c245
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26bc], 1
mov ecx, 0x83c5
jne 0x11c286
or dword [0x1b26bc], 1
lea eax, [ecx - 7]
mov word [0x1b1848], ax
add eax, 0xfffffff7
mov word [0x1b184a], ax
lea eax, [ecx - 0x22]
mov word [0x1b184c], ax
add eax, 0x15
mov word [0x1b184e], ax
mov eax, ecx
mov word [0x1b1850], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1848]
add eax, 2
mov word [eax + 0x1b2016], dx
cmp eax, 0xa
jb 0x11c288
mov eax, 0x1b2018
ret
Function at 0x11c2a6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26b8], 1
mov ecx, 0x83c5
jne 0x11c2f9
or dword [0x1b26b8], 1
lea eax, [ecx - 7]
mov word [0x1b1854], ax
add eax, 0xfffffff7
mov word [0x1b1856], ax
lea eax, [ecx - 0x22]
mov word [0x1b1858], ax
add eax, 0x53
mov word [0x1b185a], ax
lea eax, [ecx + 0x32]
mov word [0x1b185c], ax
add eax, 0xffffffc1
mov word [0x1b185e], ax
mov eax, ecx
mov word [0x1b1860], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1854]
add eax, 2
mov word [eax + 0x1b2022], dx
cmp eax, 0xe
jb 0x11c2fb
mov eax, 0x1b2024
ret

Function at 0x11c319
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26b4], 1
mov ecx, 0x83c5
jne 0x11c36c
or dword [0x1b26b4], 1
lea eax, [ecx - 7]
mov word [0x1b1864], ax
add eax, 0xfffffff7
mov word [0x1b1866], ax
lea eax, [ecx - 0x22]
mov word [0x1b1868], ax
add eax, 0x50
mov word [0x1b186a], ax
lea eax, [ecx + 0x2c]
mov word [0x1b186c], ax
add eax, 0xffffffc7
mov word [0x1b186e], ax
mov eax, ecx
mov word [0x1b1870], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1864]
add eax, 2
mov word [eax + 0x1b2032], dx
cmp eax, 0xe
jb 0x11c36e
mov eax, 0x1b2034
ret

Function at 0x11c38c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26b0], 1
mov ecx, 0x83c5
jne 0x11c3cd
or dword [0x1b26b0], 1
lea eax, [ecx - 7]
mov word [0x1b1874], ax
add eax, 0xfffffff7
mov word [0x1b1876], ax
lea eax, [ecx - 0x22]
mov word [0x1b1878], ax
add eax, 0x15
mov word [0x1b187a], ax
mov eax, ecx
mov word [0x1b187c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1874]
add eax, 2
mov word [eax + 0x1b2042], dx
cmp eax, 0xa
jb 0x11c3cf
mov eax, 0x1b2044
ret

Function at 0x11c3ed
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26ac], 1
mov ecx, 0x83c5
jne 0x11c440
or dword [0x1b26ac], 1
lea eax, [ecx - 7]
mov word [0x1b1880], ax
add eax, 0xfffffff7
mov word [0x1b1882], ax
lea eax, [ecx - 0x22]
mov word [0x1b1884], ax
add eax, 0x53
mov word [0x1b1886], ax
lea eax, [ecx + 0x32]
mov word [0x1b1888], ax
add eax, 0xffffffc1
mov word [0x1b188a], ax
mov eax, ecx
mov word [0x1b188c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1880]
add eax, 2
mov word [eax + 0x1b204e], dx
cmp eax, 0xe
jb 0x11c442
mov eax, 0x1b2050
ret
Function at 0x11c53a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26a8], 1
mov ecx, 0x83c5
jne 0x11c77f
or dword [0x1b26a8], 1
lea eax, [ecx + 0x30]
mov word [0x1b1898], ax
dec eax
mov word [0x1b189a], ax
lea eax, [ecx + 0x32]
mov word [0x1b189c], ax
dec eax
mov word [0x1b189e], ax
lea eax, [ecx + 0x2c]
mov word [0x1b18a0], ax
dec eax
mov word [0x1b18a2], ax
lea eax, [ecx + 0x2e]
mov word [0x1b18a4], ax
dec eax
mov word [0x1b18a6], ax
lea eax, [ecx + 0x38]
mov word [0x1b18a8], ax
dec eax
mov word [0x1b18aa], ax
lea eax, [ecx - 0x41]
mov word [0x1b18ac], ax
add eax, 3
mov word [0x1b18ae], ax
lea eax, [ecx - 0x3f]
mov word [0x1b18b0], ax
add eax, 0xfffffffb
mov word [0x1b18b2], ax
lea eax, [ecx - 0x45]
mov word [0x1b18b4], ax
add eax, 3
mov word [0x1b18b6], ax
lea eax, [ecx - 0x43]
mov word [0x1b18b8], ax
add eax, 0xb
mov word [0x1b18ba], ax
lea eax, [ecx - 0x39]
mov word [0x1b18bc], ax
add eax, 3
mov word [0x1b18be], ax
lea eax, [ecx - 0x37]
mov word [0x1b18c0], ax
add eax, 0xfffffffb
mov word [0x1b18c2], ax
lea eax, [ecx - 0x3d]
mov word [0x1b18c4], ax
add eax, 3
mov word [0x1b18c6], ax
lea eax, [ecx - 0x3b]
mov word [0x1b18c8], ax
add eax, 0xb
mov word [0x1b18ca], ax
lea eax, [ecx - 0x31]
mov word [0x1b18cc], ax
add eax, 3
mov word [0x1b18ce], ax
lea eax, [ecx - 0x2f]
mov word [0x1b18d0], ax
add eax, 0xfffffffb
mov word [0x1b18d2], ax
lea eax, [ecx - 0x35]
mov word [0x1b18d4], ax
add eax, 3
mov word [0x1b18d6], ax
lea eax, [ecx - 0x33]
mov word [0x1b18d8], ax
add eax, 0xb
mov word [0x1b18da], ax
lea eax, [ecx - 0x29]
mov word [0x1b18dc], ax
add eax, 3
mov word [0x1b18de], ax
lea eax, [ecx - 0x21]
mov word [0x1b18e0], ax
add eax, 3
mov word [0x1b18e2], ax
lea eax, [ecx - 0x1f]
mov word [0x1b18e4], ax
add eax, 0xfffffffb
mov word [0x1b18e6], ax
lea eax, [ecx - 0x25]
mov word [0x1b18e8], ax
add eax, 3
mov word [0x1b18ea], ax
lea eax, [ecx - 0x23]
mov word [0x1b18ec], ax
add eax, 0xb
mov word [0x1b18ee], ax
lea eax, [ecx - 0x19]
mov word [0x1b18f0], ax
add eax, 3
mov word [0x1b18f2], ax
lea eax, [ecx - 0x17]
mov word [0x1b18f4], ax
add eax, 0xfffffffb
mov word [0x1b18f6], ax
lea eax, [ecx - 0x1d]
mov word [0x1b18f8], ax
add eax, 3
mov word [0x1b18fa], ax
lea eax, [ecx - 0x1b]
mov word [0x1b18fc], ax
add eax, 0xb
mov word [0x1b18fe], ax
lea eax, [ecx - 0x11]
mov word [0x1b1900], ax
add eax, 3
mov word [0x1b1902], ax
lea eax, [ecx - 0xf]
mov word [0x1b1904], ax
add eax, 0xfffffffb
mov word [0x1b1906], ax
lea eax, [ecx - 0x15]
mov word [0x1b1908], ax
add eax, 3
mov word [0x1b190a], ax
lea eax, [ecx - 0x13]
mov word [0x1b190c], ax
add eax, 0xb
mov word [0x1b190e], ax
lea eax, [ecx - 9]
mov word [0x1b1910], ax
add eax, 3
mov word [0x1b1912], ax
mov eax, ecx
mov word [0x1b1914], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1b1898]
add eax, 2
mov word [eax + 0x1b205e], dx
cmp eax, 0x7e
jb 0x11c781
mov eax, 0x1b2060
ret
Function at 0x11ce51
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26a4], 1
jne 0x11ceb8
or dword [0x1b26a4], 1
mov dword [0x1b1918], 0xbf9abfa8
mov dword [0x1b191c], 0xb79ab5ac
mov dword [0x1b1920], 0xa0a1a4a0
mov dword [0x1b1924], 0xabac9ab7
mov dword [0x1b1928], 0xa39ab1ac
mov dword [0x1b192c], 0xeda0a9ac
mov dword [0x1b1930], 0xa4a3e5ec
mov dword [0x1b1934], 0xa1a0a9ac
mov byte [0x1b1938], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b1918]
xor cl, 0xc5
mov byte [eax + 0x1b20e0], cl
inc eax
cmp eax, 0x21
jb 0x11ceba
mov eax, 0x1b20e0
ret

Function at 0x11ced5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b26a0], 1
jne 0x11cf3c
or dword [0x1b26a0], 1
mov dword [0x1b193c], 0xbf9abfa8
mov dword [0x1b1940], 0xb79ab5ac
mov dword [0x1b1944], 0xa0a1a4a0
mov dword [0x1b1948], 0xaca39ab7
mov dword [0x1b194c], 0xb69aa0a9
mov dword [0x1b1950], 0xedb1a4b1
mov dword [0x1b1954], 0xa4a3e5ec
mov dword [0x1b1958], 0xa1a0a9ac
mov byte [0x1b195c], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b193c]
xor cl, 0xc5
mov byte [eax + 0x1b2104], cl
inc eax
cmp eax, 0x21
jb 0x11cf3e
mov eax, 0x1b2104
ret

Function at 0x11cf59
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b269c], 1
jne 0x11cfd7
or dword [0x1b269c], 1
mov dword [0x1b1960], 0xbf9abfa8
mov dword [0x1b1964], 0xb79ab5ac
mov dword [0x1b1968], 0xa0a1a4a0
mov dword [0x1b196c], 0xbda09ab7
mov dword [0x1b1970], 0xa6a4b7b1
mov dword [0x1b1974], 0xaca39ab1
mov dword [0x1b1978], 0xb19aa0a9
mov dword [0x1b197c], 0xa0ad9aaa
mov dword [0x1b1980], 0xecedb5a4
mov dword [0x1b1984], 0xaca4a3e5
mov dword [0x1b1988], 0xc5a1a0a9
xor eax, eax
mov cl, byte [eax + 0x1b1960]
xor cl, 0xc5
mov byte [eax + 0x1b2128], cl
inc eax
cmp eax, 0x2c
jb 0x11cfd9
mov eax, 0x1b2128
ret

Function at 0x11cff5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2698], 1
jne 0x11d05f
or dword [0x1b2698], 1
mov dword [0x1b198c], 0xa9aca483
mov dword [0x1b1990], 0xb1e5a1a0
mov dword [0x1b1994], 0xb7a6e5aa
mov dword [0x1b1998], 0xa0b1a4a0
mov dword [0x1b199c], 0xb6a0a1e5
mov dword [0x1b19a0], 0xa4abacb1
mov dword [0x1b19a4], 0xabaaacb1
mov dword [0x1b19a8], 0xb1a4b5e5
mov dword [0x1b19ac], 0xc5e5ffad
xor eax, eax
mov cl, byte [eax + 0x1b198c]
xor cl, 0xc5
mov byte [eax + 0x1b2154], cl
inc eax
cmp eax, 0x24
jb 0x11d061
mov eax, 0x1b2154
ret

Function at 0x11d07c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2694], 1
jne 0x11d0e2
or dword [0x1b2694], 1
mov dword [0x1b19b0], 0xa9aca483
mov dword [0x1b19b4], 0xb1e5a1a0
mov dword [0x1b19b8], 0xb7a6e5aa
mov dword [0x1b19bc], 0xa0b1a4a0
mov dword [0x1b19c0], 0xb1b0aae5
mov dword [0x1b19c4], 0xe5b1b0b5
mov dword [0x1b19c8], 0xa0a9aca3
mov word [0x1b19cc], 0xe5ff
mov byte [0x1b19ce], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b19b0]
xor cl, 0xc5
mov byte [eax + 0x1b2178], cl
inc eax
cmp eax, 0x1f
jb 0x11d0e4
mov eax, 0x1b2178
ret
Function at 0x11d119
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2690], 1
jne 0x11d157
or dword [0x1b2690], 1
mov dword [0x1b19d0], 0xaa92b68c
mov dword [0x1b19d4], 0x95f1f3b2
mov dword [0x1b19d8], 0xa0a6aab7
mov word [0x1b19dc], 0xb6b6
mov byte [0x1b19de], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b19d0]
xor cl, 0xc5
mov byte [eax + 0x1b2198], cl
inc eax
cmp eax, 0xf
jb 0x11d159
mov eax, 0x1b2198
ret

Function at 0x11d26f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b268c], 1
jne 0x11d2d8
or dword [0x1b268c], 1
mov dword [0x1b19e0], 0xaaa9a984
mov dword [0x1b19e4], 0xa0b1a4a6
mov dword [0x1b19e8], 0x8ca1ab84
mov dword [0x1b19ec], 0xacb1acab
mov dword [0x1b19f0], 0xbfaca9a4
mov dword [0x1b19f4], 0xa1ac96a0
mov dword [0x1b19f8], 0xaca4a3e5
mov dword [0x1b19fc], 0xffa1a0a9
mov word [0x1b1a00], 0xc5e5
xor eax, eax
mov cl, byte [eax + 0x1b19e0]
xor cl, 0xc5
mov byte [eax + 0x1b21a8], cl
inc eax
cmp eax, 0x22
jb 0x11d2da
mov eax, 0x1b21a8
ret

Function at 0x11d2f5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2688], 1
jne 0x11d354
or dword [0x1b2688], 1
mov dword [0x1b1a04], 0xa6a0ad86
mov dword [0x1b1a08], 0xaeaa91ae
mov dword [0x1b1a0c], 0xa088aba0
mov dword [0x1b1a10], 0xb7a0a7a8
mov dword [0x1b1a14], 0xb5acadb6
mov dword [0x1b1a18], 0xaca4a3e5
mov dword [0x1b1a1c], 0xffa1a0a9
mov word [0x1b1a20], 0xc5e5
xor eax, eax
mov cl, byte [eax + 0x1b1a04]
xor cl, 0xc5
mov byte [eax + 0x1b21cc], cl
inc eax
cmp eax, 0x1e
jb 0x11d356
mov eax, 0x1b21cc
ret

Function at 0x11d5ba
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b267c], 1
jne 0x11d63f
or dword [0x1b267c], 1
mov dword [0x1b1a38], 0xababa486
mov dword [0x1b1a3c], 0xb4e5b1aa
mov dword [0x1b1a40], 0xbcb7a0b0
mov dword [0x1b1a44], 0xf3e5a4e5
mov dword [0x1b1a48], 0xaca7e5f1
mov dword [0x1b1a4c], 0xacb3e5b1
mov dword [0x1b1a50], 0xaae5b2a0
mov dword [0x1b1a54], 0xf7f6e5ab
mov dword [0x1b1a58], 0xb1aca7e5
mov dword [0x1b1a5c], 0xabacb2e5
mov dword [0x1b1a60], 0xb6b2aaa1
mov byte [0x1b1a64], 0xc5
xor eax, eax
mov cl, byte [eax + 0x1b1a38]
xor cl, 0xc5
mov byte [eax + 0x1b2200], cl
inc eax
cmp eax, 0x2d
jb 0x11d641
mov eax, 0x1b2200
ret

Function at 0x11d65c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2678], 1
jne 0x11d70c
or dword [0x1b2678], 1
push ebx
push esi
mov eax, 0x838d
mov word [0x1b1a68], ax
inc eax
mov word [0x1b1a6a], ax
push edi
mov edi, 0x8380
mov eax, edi
mov word [0x1b1a6c], ax
add eax, 0x1c
mov word [0x1b1a6e], ax
lea esi, [edi + 0x1a]
mov eax, esi
mov word [0x1b1a70], ax
lea edx, [edi + 9]
mov eax, edx
mov word [0x1b1a72], ax
inc eax
mov word [0x1b1a74], ax
lea ecx, [edi + 6]
mov eax, ecx
mov word [0x1b1a76], ax
add eax, 0xfffffffe
mov ebx, eax
lea eax, [edi + 0xc]
pop edi
mov word [0x1b1a86], ax
add eax, 0x39
pop esi
mov word [0x1b1a78], bx
mov dword [0x1b1a7a], 0x839a8389
mov dword [0x1b1a7e], 0x83848388
mov dword [0x1b1a82], 0x838d8386
mov dword [0x1b1a88], 0x8380838b
mov word [0x1b1a8c], ax
pop ebx
xor eax, eax
mov ecx, 0x83c5
xor cx, word [eax + 0x1b1a68]
add eax, 2
mov word [eax + 0x1b222e], cx
cmp eax, 0x26
jb 0x11d70e
mov eax, 0x1b2230
ret