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

Disassembly:
test byte [0x272da8], 1
jne 0x1b3acd
or dword [0x272da8], 1
mov dword [0x26cce0], 0xbbaaa183
mov dword [0x26cce4], 0xeef4aba2
mov dword [0x26cce8], 0xc4c3bdeb
mov byte [0x26ccec], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cce0]
xor cl, 0xce
mov byte [eax + 0x26d38c], cl
inc eax
cmp eax, 0xd
jb 0x1b3acf
mov eax, 0x26d38c
ret

Function at 0x1b3aea
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272da4], 1
jne 0x1b3b29
or dword [0x272da4], 1
mov dword [0x26ccf0], 0xabbca69a
mov dword [0x26ccf4], 0xeef4aaaf
mov dword [0x26ccf8], 0xb6ebb6fe
mov dword [0x26ccfc], 0xc4c3c4c3
mov byte [0x26cd00], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ccf0]
xor cl, 0xce
mov byte [eax + 0x26d39c], cl
inc eax
cmp eax, 0x11
jb 0x1b3b2b
mov eax, 0x26d39c
ret

Function at 0x1b3b46
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272da0], 1
jne 0x1b3b84
or dword [0x272da0], 1
mov dword [0x26cd04], 0xabadb68b
mov dword [0x26cd08], 0xa1a7babe
mov dword [0x26cd0c], 0xaaebeea0
mov word [0x26cd10], 0xc4c3
mov byte [0x26cd12], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cd04]
xor cl, 0xce
mov byte [eax + 0x26d3b0], cl
inc eax
cmp eax, 0xf
jb 0x1b3b86
mov eax, 0x26d3b0
ret

Function at 0x1b3ba1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d9c], 1
jne 0x1b3bdf
or dword [0x272d9c], 1
mov dword [0x26cd14], 0xafada182
mov dword [0x26cd18], 0xa0a1a7ba
mov dword [0x26cd1c], 0xbeebeef4
mov word [0x26cd20], 0xc4c3
mov byte [0x26cd22], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cd14]
xor cl, 0xce
mov byte [eax + 0x26d3c0], cl
inc eax
cmp eax, 0xf
jb 0x1b3be1
mov eax, 0x26d3c0
ret

Function at 0x1b3bfc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d98], 1
jne 0x1b3c3d
or dword [0x272d98], 1
mov dword [0x26cd24], 0xabbeb79a
mov dword [0x26cd28], 0xbdebeef4
mov dword [0x26cd2c], 0xb6fee6ee
mov dword [0x26cd30], 0xc3e7b6eb
mov word [0x26cd34], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26cd24]
xor cl, 0xce
mov byte [eax + 0x26d3d0], cl
inc eax
cmp eax, 0x12
jb 0x1b3c3f
mov eax, 0x26d3d0
ret

Function at 0x1b3c5a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d94], 1
jne 0x1b3ce2
or dword [0x272d94], 1
mov dword [0x26cd38], 0xafbaab8a
mov dword [0x26cd3c], 0xf4bda2a7
mov dword [0x26cd40], 0xa7bc9aee
mov dword [0x26cd44], 0xbaeeaaab
mov dword [0x26cd48], 0xabbceea1
mov dword [0x26cd4c], 0xa8eeaaaf
mov dword [0x26cd50], 0xeea3a1bc
mov dword [0x26cd54], 0xa1a3aba3
mov dword [0x26cd58], 0xafeeb7bc
mov dword [0x26cd5c], 0xabbcaaaa
mov dword [0x26cd60], 0xebeebdbd
mov dword [0x26cd64], 0xcec4c3be
xor eax, eax
mov cl, byte [eax + 0x26cd38]
xor cl, 0xce
mov byte [eax + 0x26d3e4], cl
inc eax
cmp eax, 0x30
jb 0x1b3ce4
mov eax, 0x26d3e4
ret
Function at 0x1b3cff
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d90], 1
jne 0x1b3d91
or dword [0x272d90], 1
mov dword [0x26cd68], 0xafbaab8a
mov dword [0x26cd6c], 0xf4bda2a7
mov dword [0x26cd70], 0xa7bc9aee
mov dword [0x26cd74], 0xbaeeaaab
mov dword [0x26cd78], 0xbcb9eea1
mov dword [0x26cd7c], 0xeeabbaa7
mov dword [0x26cd80], 0xa3eea1ba
mov dword [0x26cd84], 0xbca1a3ab
mov dword [0x26cd88], 0xaaafeeb7
mov dword [0x26cd8c], 0xbdabbcaa
mov dword [0x26cd90], 0xbeebeebd
mov word [0x26cd94], 0xc4c3
mov byte [0x26cd96], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cd68]
xor cl, 0xce
mov byte [eax + 0x26d414], cl
inc eax
cmp eax, 0x2f
jb 0x1b3d93
mov eax, 0x26d414
ret

Function at 0x1b3dae
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d8c], 1
jne 0x1b3e41
or dword [0x272d8c], 1
mov dword [0x26cd98], 0xafbaab8a
mov dword [0x26cd9c], 0xf4bda2a7
mov dword [0x26cda0], 0xa7bc9aee
mov dword [0x26cda4], 0xbaeeaaab
mov dword [0x26cda8], 0xb6abeea1
mov dword [0x26cdac], 0xbabbadab
mov dword [0x26cdb0], 0xaba3eeab
mov dword [0x26cdb4], 0xb7bca1a3
mov dword [0x26cdb8], 0xeebaafee
mov dword [0x26cdbc], 0xbcaaaaaf
mov dword [0x26cdc0], 0xeebdbdab
mov dword [0x26cdc4], 0xc4c3beeb
mov byte [0x26cdc8], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cd98]
xor cl, 0xce
mov byte [eax + 0x26d444], cl
inc eax
cmp eax, 0x31
jb 0x1b3e43
mov eax, 0x26d444
ret

Function at 0x1b3e5e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d88], 1
jne 0x1b3e95
or dword [0x272d88], 1
mov dword [0x26cdcc], 0xa9afa288
mov dword [0x26cdd0], 0xfeeef4bd
mov dword [0x26cdd4], 0xc3b6ebb6
mov word [0x26cdd8], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26cdcc]
xor cl, 0xce
mov byte [eax + 0x26d478], cl
inc eax
cmp eax, 0xe
jb 0x1b3e97
mov eax, 0x26d478
ret

Function at 0x1b3eb2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d84], 1
jne 0x1b3ee9
or dword [0x272d84], 1
mov dword [0x26cddc], 0xafbcaf9e
mov dword [0x26cde0], 0xabbaaba3
mov dword [0x26cde4], 0xc3f4bdbc
mov word [0x26cde8], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26cddc]
xor cl, 0xce
mov byte [eax + 0x26d488], cl
inc eax
cmp eax, 0xe
jb 0x1b3eeb
mov eax, 0x26d488
ret

Function at 0x1b3f06
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d80], 1
jne 0x1b3f4f
or dword [0x272d80], 1
mov dword [0x26cdec], 0xbcaf9ec7
mov dword [0x26cdf0], 0xbaaba3af
mov dword [0x26cdf4], 0xeb95bcab
mov dword [0x26cdf8], 0xeef493aa
mov dword [0x26cdfc], 0xc4c3beeb
mov byte [0x26ce00], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cdec]
xor cl, 0xce
mov byte [eax + 0x26d498], cl
inc eax
cmp eax, 0x15
jb 0x1b3f51
mov eax, 0x26d498
ret

Function at 0x1b3f6c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d7c], 1
jne 0x1b3fa4
or dword [0x272d7c], 1
mov dword [0x26ce04], 0xee868b9d
mov dword [0x26ce08], 0xa2afa08f
mov dword [0x26ce0c], 0xbda7bdb7
mov dword [0x26ce10], 0xcec4c3f4
xor eax, eax
mov cl, byte [eax + 0x26ce04]
xor cl, 0xce
mov byte [eax + 0x26d4b0], cl
inc eax
cmp eax, 0x10
jb 0x1b3fa6
mov eax, 0x26d4b0
ret
Function at 0x1b3fc1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d78], 1
jne 0x1b4009
or dword [0x272d78], 1
mov dword [0x26ce14], 0xa4ac81c7
mov dword [0x26ce18], 0xeebaadab
mov dword [0x26ce1c], 0xabbeb7ba
mov dword [0x26ce20], 0xbdebeef4
mov word [0x26ce24], 0xc4c3
mov byte [0x26ce26], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ce14]
xor cl, 0xce
mov byte [eax + 0x26d4c0], cl
inc eax
cmp eax, 0x13
jb 0x1b400b
mov eax, 0x26d4c0
ret

Function at 0x1b4026
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d74], 1
jne 0x1b408f
or dword [0x272d74], 1
mov dword [0x26ce28], 0xa7af88c7
mov dword [0x26ce2c], 0xeeaaaba2
mov dword [0x26ce30], 0xa8eea1ba
mov dword [0x26ce34], 0xa1a2a2a1
mov dword [0x26ce38], 0xa1beeeb9
mov dword [0x26ce3c], 0xabbaa0a7
mov dword [0x26ce40], 0xa6adeebc
mov dword [0x26ce44], 0xc3a0a7af
mov word [0x26ce48], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26ce28]
xor cl, 0xce
mov byte [eax + 0x26d4d4], cl
inc eax
cmp eax, 0x22
jb 0x1b4091
mov eax, 0x26d4d4
ret

Function at 0x1b40ac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d70], 1
jne 0x1b40cf
or dword [0x272d70], 1
mov dword [0x26ce4c], 0xaababd8e
mov word [0x26ce50], 0xce8e
xor eax, eax
mov cl, byte [eax + 0x26ce4c]
xor cl, 0xce
mov byte [eax + 0x26d4f8], cl
inc eax
cmp eax, 6
jb 0x1b40d1
mov eax, 0x26d4f8
ret

Function at 0x1b40ec
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d6c], 1
jne 0x1b4123
or dword [0x272d6c], 1
mov dword [0x26ce54], 0xbaa0bbbc
mov dword [0x26ce58], 0x91aba3a7
mov dword [0x26ce5c], 0xa1bcbcab
mov word [0x26ce60], 0xcebc
xor eax, eax
mov cl, byte [eax + 0x26ce54]
xor cl, 0xce
mov byte [eax + 0x26d500], cl
inc eax
cmp eax, 0xe
jb 0x1b4125
mov eax, 0x26d500
ret

Function at 0x1b4140
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d68], 1
jne 0x1b416e
or dword [0x272d68], 1
mov dword [0x26ce64], 0xa9a0afbc
mov dword [0x26ce68], 0xbcab91ab
mov dword [0x26ce6c], 0xcebca1bc
xor eax, eax
mov cl, byte [eax + 0x26ce64]
xor cl, 0xce
mov byte [eax + 0x26d510], cl
inc eax
cmp eax, 0xc
jb 0x1b4170
mov eax, 0x26d510
ret

Function at 0x1b418b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d64], 1
jne 0x1b41c9
or dword [0x272d64], 1
mov dword [0x26ce70], 0xbcabb8a1
mov dword [0x26ce74], 0xb9a1a2a8
mov dword [0x26ce78], 0xbcbcab91
mov word [0x26ce7c], 0xbca1
mov byte [0x26ce7e], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ce70]
xor cl, 0xce
mov byte [eax + 0x26d51c], cl
inc eax
cmp eax, 0xf
jb 0x1b41cb
mov eax, 0x26d51c
ret

Function at 0x1b41e6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d60], 1
jne 0x1b421e
or dword [0x272d60], 1
mov dword [0x26ce80], 0xabaaa0bb
mov dword [0x26ce84], 0xa1a2a8bc
mov dword [0x26ce88], 0xbcab91b9
mov dword [0x26ce8c], 0xcebca1bc
xor eax, eax
mov cl, byte [eax + 0x26ce80]
xor cl, 0xce
mov byte [eax + 0x26d52c], cl
inc eax
cmp eax, 0x10
jb 0x1b4220
mov eax, 0x26d52c
ret
Function at 0x1b423b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d5c], 1
jne 0x1b4269
or dword [0x272d5c], 1
mov dword [0x26ce90], 0xa7a9a1a2
mov dword [0x26ce94], 0xbcab91ad
mov dword [0x26ce98], 0xcebca1bc
xor eax, eax
mov cl, byte [eax + 0x26ce90]
xor cl, 0xce
mov byte [eax + 0x26d53c], cl
inc eax
cmp eax, 0xc
jb 0x1b426b
mov eax, 0x26d53c
ret

Function at 0x1b4286
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d58], 1
jne 0x1b42bb
or dword [0x272d58], 1
mov dword [0x26ce9c], 0xafa3a1aa
mov dword [0x26cea0], 0xab91a0a7
mov dword [0x26cea4], 0xbca1bcbc
mov byte [0x26cea8], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ce9c]
xor cl, 0xce
mov byte [eax + 0x26d548], cl
inc eax
cmp eax, 0xd
jb 0x1b42bd
mov eax, 0x26d548
ret

Function at 0x1b42d8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d54], 1
jne 0x1b4317
or dword [0x272d54], 1
mov dword [0x26ceac], 0xafb8a0a7
mov dword [0x26ceb0], 0x91aaa7a2
mov dword [0x26ceb4], 0xbba9bcaf
mov dword [0x26ceb8], 0xbaa0aba3
mov byte [0x26cebc], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ceac]
xor cl, 0xce
mov byte [eax + 0x26d558], cl
inc eax
cmp eax, 0x11
jb 0x1b4319
mov eax, 0x26d558
ret

Function at 0x1b4334
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d50], 1
jne 0x1b4369
or dword [0x272d50], 1
mov dword [0x26cec0], 0xa9a0aba2
mov dword [0x26cec4], 0xab91a6ba
mov dword [0x26cec8], 0xbca1bcbc
mov byte [0x26cecc], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cec0]
xor cl, 0xce
mov byte [eax + 0x26d56c], cl
inc eax
cmp eax, 0xd
jb 0x1b436b
mov eax, 0x26d56c
ret

Function at 0x1b4386
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d4c], 1
jne 0x1b43bb
or dword [0x272d4c], 1
mov dword [0x26ced0], 0x91babba1
mov dword [0x26ced4], 0xbc91a8a1
mov dword [0x26ced8], 0xaba9a0af
mov byte [0x26cedc], 0xce
xor eax, eax
mov cl, byte [eax + 0x26ced0]
xor cl, 0xce
mov byte [eax + 0x26d57c], cl
inc eax
cmp eax, 0xd
jb 0x1b43bd
mov eax, 0x26d57c
ret

Function at 0x1b43d8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d48], 1
jne 0x1b4405
or dword [0x272d48], 1
mov dword [0x26cee0], 0xabadb6ab
mov dword [0x26cee4], 0xa1a7babe
mov word [0x26cee8], 0xcea0
xor eax, eax
mov cl, byte [eax + 0x26cee0]
xor cl, 0xce
mov byte [eax + 0x26d58c], cl
inc eax
cmp eax, 0xa
jb 0x1b4407
mov eax, 0x26d58c
ret

Function at 0x1b4422
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d44], 1
jne 0x1b4481
or dword [0x272d44], 1
mov dword [0x26ceec], 0xaababdc7
mov dword [0x26cef0], 0xb6abf4f4
mov dword [0x26cef4], 0xbabeabad
mov dword [0x26cef8], 0xf4a0a1a7
mov dword [0x26cefc], 0xafa6b9f4
mov dword [0x26cf00], 0xf4e7e6ba
mov dword [0x26cf04], 0xc3bdebee
mov word [0x26cf08], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26ceec]
xor cl, 0xce
mov byte [eax + 0x26d598], cl
inc eax
cmp eax, 0x1e
jb 0x1b4483
mov eax, 0x26d598
ret
Function at 0x1b449e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d40], 1
jne 0x1b4512
or dword [0x272d40], 1
mov dword [0x26cf0c], 0xa7af88c7
mov dword [0x26cf10], 0xeeaaaba2
mov dword [0x26cf14], 0xa9eea1ba
mov dword [0x26cf18], 0xbdeebaab
mov dword [0x26cf1c], 0xf4f4aaba
mov dword [0x26cf20], 0xabadb6ab
mov dword [0x26cf24], 0xa1a7babe
mov dword [0x26cf28], 0xb9f4f4a0
mov dword [0x26cf2c], 0xe6baafa6
mov dword [0x26cf30], 0xcec4c3e7
xor eax, eax
mov cl, byte [eax + 0x26cf0c]
xor cl, 0xce
mov byte [eax + 0x26d5b8], cl
inc eax
cmp eax, 0x28
jb 0x1b4514
mov eax, 0x26d5b8
ret

Function at 0x1b452f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d3c], 1
jne 0x1b4563
or dword [0x272d3c], 1
mov dword [0x26cf34], 0xa3a1ad91
mov dword [0x26cf38], 0xbcbcab91
mov word [0x26cf3c], 0xbca1
mov byte [0x26cf3e], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cf34]
xor cl, 0xce
mov byte [eax + 0x26d5e0], cl
inc eax
cmp eax, 0xb
jb 0x1b4565
mov eax, 0x26d5e0
ret

Function at 0x1b4580
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d38], 1
jne 0x1b45e9
or dword [0x272d38], 1
mov dword [0x26cf40], 0xa1ad91c7
mov dword [0x26cf44], 0xbcab91a3
mov dword [0x26cf48], 0xf4bca1bc
mov dword [0x26cf4c], 0xbcbc8bf4
mov dword [0x26cf50], 0xab83bca1
mov dword [0x26cf54], 0xa9afbdbd
mov dword [0x26cf58], 0xf4e7e6ab
mov dword [0x26cf5c], 0xc3bdebee
mov word [0x26cf60], 0xcec4
xor eax, eax
mov cl, byte [eax + 0x26cf40]
xor cl, 0xce
mov byte [eax + 0x26d5ec], cl
inc eax
cmp eax, 0x22
jb 0x1b45eb
mov eax, 0x26d5ec
ret

Function at 0x1b4606
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d34], 1
jne 0x1b4684
or dword [0x272d34], 1
mov dword [0x26cf64], 0xa7af88c7
mov dword [0x26cf68], 0xeeaaaba2
mov dword [0x26cf6c], 0xa9eea1ba
mov dword [0x26cf70], 0x91eebaab
mov dword [0x26cf74], 0x91a3a1ad
mov dword [0x26cf78], 0xa1bcbcab
mov dword [0x26cf7c], 0x8bf4f4bc
mov dword [0x26cf80], 0xbca1bcbc
mov dword [0x26cf84], 0xbdbdab83
mov dword [0x26cf88], 0xe6aba9af
mov dword [0x26cf8c], 0xcec4c3e7
xor eax, eax
mov cl, byte [eax + 0x26cf64]
xor cl, 0xce
mov byte [eax + 0x26d610], cl
inc eax
cmp eax, 0x2c
jb 0x1b4686
mov eax, 0x26d610
ret

Function at 0x1b46a1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d30], 1
jne 0x1b471c
or dword [0x272d30], 1
mov dword [0x26cf90], 0xadafba9d
mov dword [0x26cf94], 0xbbaaeea5
mov dword [0x26cf98], 0xabeebea3
mov dword [0x26cf9c], 0xbca1bcbc
mov dword [0x26cfa0], 0xa18deef4
mov dword [0x26cfa4], 0xb6abbaa0
mov dword [0x26cfa8], 0xadab9cba
mov dword [0x26cfac], 0xeeaabca1
mov dword [0x26cfb0], 0xeebdafb9
mov dword [0x26cfb4], 0xa2a2bba0
mov byte [0x26cfb8], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cf90]
xor cl, 0xce
mov byte [eax + 0x26d63c], cl
inc eax
cmp eax, 0x29
jb 0x1b471e
mov eax, 0x26d63c
ret
Function at 0x1b4739
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d2c], 1
jne 0x1b47b3
or dword [0x272d2c], 1
mov dword [0x26cfbc], 0xadafba9d
mov dword [0x26cfc0], 0xbbaaeea5
mov dword [0x26cfc4], 0xabeebea3
mov dword [0x26cfc8], 0xbca1bcbc
mov dword [0x26cfcc], 0xb79deef4
mov dword [0x26cfd0], 0xa7a087a3
mov dword [0x26cfd4], 0xa2afa7ba
mov dword [0x26cfd8], 0xeeabb4a7
mov dword [0x26cfdc], 0xa2a7afa8
mov word [0x26cfe0], 0xaaab
mov byte [0x26cfe2], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cfbc]
xor cl, 0xce
mov byte [eax + 0x26d668], cl
inc eax
cmp eax, 0x27
jb 0x1b47b5
mov eax, 0x26d668
ret

Function at 0x1b47d0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d28], 1
jne 0x1b4836
or dword [0x272d28], 1
mov dword [0x26cfe4], 0xa7a5bdf2
mov dword [0x26cfe8], 0xaaabbebe
mov dword [0x26cfec], 0xafbca8ee
mov dword [0x26cff0], 0xeee2aba3
mov dword [0x26cff4], 0xb9ee8d9e
mov dword [0x26cff8], 0xa0eebdaf
mov dword [0x26cffc], 0xf0a2a2bb
mov word [0x26d000], 0xc4c3
mov byte [0x26d002], 0xce
xor eax, eax
mov cl, byte [eax + 0x26cfe4]
xor cl, 0xce
mov byte [eax + 0x26d690], cl
inc eax
cmp eax, 0x1f
jb 0x1b4838
mov eax, 0x26d690
ret

Function at 0x1b4853
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d24], 1
jne 0x1b48e6
or dword [0x272d24], 1
mov dword [0x26d004], 0xa7a5bdf2
mov dword [0x26d008], 0xaaabbebe
mov dword [0x26d00c], 0xafbca8ee
mov dword [0x26d010], 0xeee2aba3
mov dword [0x26d014], 0xb9ee8d9e
mov dword [0x26d018], 0xbdeebdaf
mov dword [0x26d01c], 0xeeaba3af
mov dword [0x26d020], 0xbceebdaf
mov dword [0x26d024], 0xbcbbbaab
mov dword [0x26d028], 0xaaafeea0
mov dword [0x26d02c], 0xbdabbcaa
mov dword [0x26d030], 0xc4c3f0bd
mov byte [0x26d034], 0xce
xor eax, eax
mov cl, byte [eax + 0x26d004]
xor cl, 0xce
mov byte [eax + 0x26d6b0], cl
inc eax
cmp eax, 0x31
jb 0x1b48e8
mov eax, 0x26d6b0
ret
Function at 0x1b4903
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, 0x16c4
call fcn.00226ab0
push ebx
push esi
push edi
call dword [0x242094]
test byte [0x272d20], 1
mov dword [ebp - 4], eax
jne 0x1b494a
or dword [0x272d20], 1
mov dword [0x26d038], 0xaaa1a3f2
mov dword [0x26d03c], 0xf1aba2bb
mov dword [0x26d040], 0xcef0f1f1
xor edi, edi
xor eax, eax
mov cl, byte [eax + 0x26d038]
xor cl, 0xce
mov byte [eax + 0x26d6e4], cl
inc eax
cmp eax, 0xc
jb 0x1b494e
test byte [0x272d1c], 1
mov dword [ebp - 8], 0x26d6e4
jne 0x1b4998
or dword [0x272d1c], 1
mov dword [0x26d044], 0xa3b7bdf2
mov dword [0x26d048], 0xf1a2a1ac
mov dword [0x26d04c], 0xcef0f1f1
xor eax, eax
mov cl, byte [eax + 0x26d044]
xor cl, 0xce
mov byte [eax + 0x26d6f0], cl
inc eax
cmp eax, 0xc
jb 0x1b499a
mov esi, 0x688
push esi
lea eax, [ebp - 0x6c0]
push edi
push eax
mov dword [ebp - 0x1c], 0x26d6f0
mov dword [ebp - 0x18], edi
mov dword [ebp - 0x14], edi
call fcn.00216f70
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 [0x2423b0]
test eax, eax
je 0x1b49ff
lea eax, [ebp - 0x69c]
mov dword [ebp - 8], eax
push 0xffa
lea eax, [ebp - 0x16c0]
push edi
push eax
call fcn.00216f70
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 [0x2423bc]
lea ecx, [ebp - 0x166c]
test eax, eax
jne 0x1b4a4b
mov ecx, dword [ebp - 0x1c]
test byte [0x272d18], 1
jne 0x1b4a82
or dword [0x272d18], 1
mov dword [0x26d050], 0xebeebeeb
mov dword [0x26d054], 0xbdebefbd
mov dword [0x26d058], 0xebb6fee5
mov word [0x26d05c], 0xceb6
xor eax, eax
mov dl, byte [eax + 0x26d050]
xor dl, 0xce
mov byte [eax + 0x26d6fc], dl
inc eax
cmp eax, 0xe
jb 0x1b4a84
push dword [ebp - 0x14]
push dword [ebp - 0x18]
push ecx
push dword [ebp - 8]
push dword [ebp + 8]
push 0x26d6fc
push dword [ebp + 0xc]
call fcn.0021419d
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 [0x2423a4]
test eax, eax
je 0x1b4afb
push dword [ebp - 0xc]
push dword [ebp - 0x30]
push dword [ebp - 0x2c]
call fcn.001b4b48
push eax
push dword [ebp + 0xc]
call fcn.0021419d
add esp, 0x14
test byte [0x272d10], 1
jne 0x1b4b1b
or dword [0x272d10], 1
mov word [0x26d070], 0xc4c3
mov byte [0x26d072], 0xce
xor eax, eax
mov cl, byte [eax + 0x26d070]
xor cl, 0xce
mov byte [eax + 0x26d71c], cl
inc eax
cmp eax, 3
jb 0x1b4b1d
push dword [ebp + 0xc]
push 0x26d71c
call fcn.00213e11
pop ecx
pop ecx
pop edi
pop esi
pop ebx
leave
ret 8
Function at 0x1b4b48
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d14], 1
jne 0x1b4b80
or dword [0x272d14], 1
mov dword [0x26d060], 0xbdebe6ee
mov dword [0x26d064], 0xeeaaebf4
mov dword [0x26d068], 0xb6feeee5
mov dword [0x26d06c], 0xcee7b6eb
xor eax, eax
mov cl, byte [eax + 0x26d060]
xor cl, 0xce
mov byte [eax + 0x26d70c], cl
inc eax
cmp eax, 0x10
jb 0x1b4b82
mov eax, 0x26d70c
ret

Function at 0x1b5df8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d04], 1
jne 0x1b5e4d
or dword [0x272d04], 1
mov dword [0x26d740], 0x94829198
mov dword [0x26d744], 0x95829187
mov dword [0x26d748], 0x8093918c
mov dword [0x26d74c], 0x83948c99
mov dword [0x26d750], 0x868c8494
mov dword [0x26d754], 0x8f889f92
mov word [0x26d758], 0xd08f
xor eax, eax
mov cl, byte [eax + 0x26d740]
xor cl, 0xd0
mov byte [eax + 0x26d940], cl
inc eax
cmp eax, 0x1a
jb 0x1b5e4f
mov eax, 0x26d940
ret

Function at 0x1b5f5e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272d00], 1
jne 0x1b5f88
or dword [0x272d00], 1
mov dword [0x26d75c], 0xb1879d86
mov word [0x26d760], 0xb5a2
mov byte [0x26d762], 0xd0
xor eax, eax
mov cl, byte [eax + 0x26d75c]
xor cl, 0xd0
mov byte [eax + 0x26d95c], cl
inc eax
cmp eax, 7
jb 0x1b5f8a
mov eax, 0x26d95c
ret

Function at 0x1b5fa5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272cfc], 1
jne 0x1b5fd2
or dword [0x272cfc], 1
mov dword [0x26d764], 0xa4a2b986
mov dword [0x26d768], 0x80bcb1a5
mov word [0x26d76c], 0xd093
xor eax, eax
mov cl, byte [eax + 0x26d764]
xor cl, 0xd0
mov byte [eax + 0x26d964], cl
inc eax
cmp eax, 0xa
jb 0x1b5fd4
mov eax, 0x26d964
ret

Function at 0x1b5fef
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272cf8], 1
jne 0x1b6023
or dword [0x272cf8], 1
mov dword [0x26d770], 0xa4a2b986
mov dword [0x26d774], 0x92bcb1a5
mov word [0x26d778], 0xa8bf
mov byte [0x26d77a], 0xd0
xor eax, eax
mov cl, byte [eax + 0x26d770]
xor cl, 0xd0
mov byte [eax + 0x26d970], cl
inc eax
cmp eax, 0xb
jb 0x1b6025
mov eax, 0x26d970
ret

Function at 0x1b6040
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272cf4], 1
jne 0x1b6064
or dword [0x272cf4], 1
mov dword [0x26d77c], 0xb5beb597
mov dword [0x26d780], 0xd0b3b9a2
xor eax, eax
mov cl, byte [eax + 0x26d77c]
xor cl, 0xd0
mov byte [eax + 0x26d97c], cl
inc eax
cmp eax, 8
jb 0x1b6066
mov eax, 0x26d97c
ret
Function at 0x1b6081
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
push 0xffffffffffffffff
push 0x23b2df
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
sub esp, 0xa8
and dword [esp], 0
test byte [0x272cf0], 1
push esi
jne 0x1b60d4
or dword [0x272cf0], 1
mov dword [0x26d784], 0xbcb4a4be
mov dword [0x26d788], 0xbcb4febc
mov word [0x26d78c], 0xd0bc
xor eax, eax
mov cl, byte [eax + 0x26d784]
xor cl, 0xd0
mov byte [eax + 0x26d984], cl
inc eax
cmp eax, 0xa
jb 0x1b60d6
push 0x26d984
call dword [0x2420cc]
mov esi, eax
test esi, esi
jne 0x1b6148
call dword [0x2420a8]
push eax
lea eax, [esp + 0x40]
push eax
call fcn.001da918
pop ecx
pop ecx
and dword [esp + 0xb4], esi
push eax
call fcn.001b628f
push eax
lea eax, [esp + 0x28]
push eax
call fcn.001b6ae0
add esp, 0xc
lea esi, [esp + 8]
mov byte [esp + 0xb4], 1
call fcn.001b5bc9
push 0x25ec28
mov eax, esi
push eax
call fcn.0021d8c5
call fcn.001b62f5
push eax
push esi
call dword [0x2420c8]
test eax, eax
jne 0x1b61a5
call dword [0x2420a8]
push eax
lea eax, [esp + 0x24]
push eax
call fcn.001da918
pop ecx
pop ecx
push eax
mov dword [esp + 0xb8], 2
call fcn.001b6367
push eax
lea eax, [esp + 0x44]
push eax
call fcn.001b6ae0
add esp, 0xc
lea esi, [esp + 8]
mov byte [esp + 0xb4], 3
call fcn.001b5bc9
push 0x25ec28
mov eax, esi
jmp 0x1b6142
lea ecx, [esp + 4]
push ecx
push 0x18
lea ecx, [esp + 0x60]
push ecx
push 0
push dword [ebp + 8]
call eax
test eax, eax
jne 0x1b622d
cmp dword [esp + 4], 0x18
jne 0x1b622d
push dword [esp + 0x6c]
push eax
push 0x410
call dword [0x2420c4]
test eax, eax
jne 0x1b627c
call dword [0x2420a8]
push eax
lea eax, [esp + 0x74]
push eax
call fcn.001da918
pop ecx
pop ecx
push eax
mov dword [esp + 0xb8], 6
call fcn.001b64a7
push eax
lea eax, [esp + 0x94]
push eax
call fcn.001b6ae0
add esp, 0xc
lea esi, [esp + 0x14]
mov byte [esp + 0xb4], 7
call fcn.001b5bc9
push 0x25ec28
mov eax, esi
jmp 0x1b6142
call dword [0x2420a8]
push eax
lea eax, [esp + 0x24]
push eax
call fcn.001da918
pop ecx
pop ecx
push eax
mov dword [esp + 0xb8], 4
call fcn.001b641a
push eax
lea eax, [esp + 0x44]
push eax
call fcn.001b6ae0
add esp, 0xc
lea esi, [esp + 8]
mov byte [esp + 0xb4], 5
call fcn.001b5bc9
push 0x25ec28
mov eax, esi
jmp 0x1b6142
mov ecx, dword [esp + 0xac]
mov dword fs:[0], ecx
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x1b628f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x272cec], 1
jne 0x1b62d8
or dword [0x272cec], 1
mov dword [0x26d790], 0xb4b1bf9c
mov dword [0x26d794], 0xa2b2b99c
mov dword [0x26d798], 0xf0a9a2b1
mov dword [0x26d79c], 0xbcb9b1b6
mov dword [0x26d7a0], 0xf0eab4b5
mov byte [0x26d7a4], 0xd0
xor eax, eax
mov cl, byte [eax + 0x26d790]
xor cl, 0xd0
mov byte [eax + 0x26d990], cl
inc eax
cmp eax, 0x15
jb 0x1b62da
mov eax, 0x26d990
ret