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

Disassembly:
mov eax, 0xe9d567
call fcn.00e9cd48
sub esp, 0x10
push ebx
push esi
mov esi, 0x110
push esi
call fcn.00e774d0
mov ebx, eax
pop ecx
test ebx, ebx
je 0xe26aa8
push esi
push 0
push ebx
call fcn.00e7b980
add esp, 0xc
mov esi, ebx
jmp 0xe26aaa
xor esi, esi
mov dword [ebp - 0x10], esi
and dword [ebp - 4], 0
mov eax, dword [edi + 4]
mov dword [esi + 0x100], eax
mov eax, dword [edi + 8]
sub eax, 0x14
test byte [0xed81a0], 1
mov dword [esi + 0x104], eax
mov eax, dword [edi + 0xc]
mov dword [esi + 0x108], eax
mov eax, dword [ebp + 8]
mov dword [esi + 0x10c], eax
jne 0xe26af9
or dword [0xed81a0], 1
mov dword [0xed3f60], 0xaba6a5ab
mov byte [0xed3f64], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3f60]
xor cl, 0xc9
mov byte [eax + 0xed4060], cl
inc eax
cmp eax, 5
jb 0xe26afb
push 0
push 0xed4060
push esi
push 0xe26738
push dword [edi]
call fcn.00e64327
add esp, 0x14
test eax, eax
je 0xe26b63
push 0
call fcn.00e26c53
push eax
push 0xffffffffffffffff
push dword [edi]
call fcn.00e62fcf
mov dword [ebp + 8], eax
add esp, 0x10
lea eax, [ebp + 8]
push eax
lea ecx, [ebp - 0x1c]
call fcn.00e76a75
push 0xec2d20
lea eax, [ebp - 0x1c]
push eax
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
call fcn.00e80985
push esi
call fcn.00e77393
pop ecx
mov ecx, dword [ebp - 0xc]
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret 4

Function at 0xe26b7a
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x10
test byte [0xed8198], 1
jne 0xe26bb7
or dword [0xed8198], 1
mov dword [0xed3f78], 0xb9b0bbaa
mov dword [0xed3f7c], 0xafe9a6bd
mov dword [0xed3f80], 0xaca5a0a8
mov word [0xed3f84], 0xc9ad
xor eax, eax
mov cl, byte [eax + 0xed3f78]
xor cl, 0xc9
mov byte [eax + 0xed4078], cl
inc eax
cmp eax, 0xe
jb 0xe26bb9
lea eax, [ebp - 4]
push eax
lea ecx, [ebp - 0x10]
mov dword [ebp - 4], 0xed4078
call fcn.00e76a75
push 0xec2d20
lea eax, [ebp - 0x10]
push eax
mov dword [ebp - 0x10], vtable.std::runtime_error.0
call fcn.00e80985
int3

Function at 0xe26bf7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed81a4], 1
jne 0xe26c36
or dword [0xed81a4], 1
mov dword [0xed3f4c], 0x96a8bca5
mov dword [0xed3f50], 0xa5a8aab9
mov dword [0xed3f54], 0xa8afe9a5
mov dword [0xed3f58], 0xadaca5a0
mov byte [0xed3f5c], 0xc9
xor eax, eax
mov cl, byte [eax + 0xed3f4c]
xor cl, 0xc9
mov byte [eax + 0xed4088], cl
inc eax
cmp eax, 0x11
jb 0xe26c38
mov eax, 0xed4088
ret

Function at 0xe26c53
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed819c], 1
jne 0xe26c8b
or dword [0xed819c], 1
mov dword [0xed3f68], 0x96a8bca5
mov dword [0xed3f6c], 0xada8a6a5
mov dword [0xed3f70], 0xa0a8afe9
mov dword [0xed3f74], 0xc9adaca5
xor eax, eax
mov cl, byte [eax + 0xed3f68]
xor cl, 0xc9
mov byte [eax + 0xed4068], cl
inc eax
cmp eax, 0x10
jb 0xe26c8d
mov eax, 0xed4068
ret
Function at 0xe273d1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8180], 1
jne 0xe2741a
or dword [0xed8180], 1
mov dword [0xed412c], 0xaeb8aaa9
mov dword [0xed4130], 0xaeebfffd
mov dword [0xed4134], 0xafa4a8a5
mov dword [0xed4138], 0xaaadebae
mov dword [0xed413c], 0xafaea7a2
mov byte [0xed4140], 0xcb
xor eax, eax
mov cl, byte [eax + 0xed412c]
xor cl, 0xcb
mov byte [eax + 0xed4190], cl
inc eax
cmp eax, 0x15
jb 0xe2741c
mov eax, 0xed4190
ret

Function at 0xe27562
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed817c], 1
jne 0xe275ab
or dword [0xed817c], 1
mov dword [0xed4144], 0xaeb8aaa9
mov dword [0xed4148], 0xafebfffd
mov dword [0xed414c], 0xafa4a8ae
mov dword [0xed4150], 0xaaadebae
mov dword [0xed4154], 0xafaea7a2
mov byte [0xed4158], 0xcb
xor eax, eax
mov cl, byte [eax + 0xed4144]
xor cl, 0xcb
mov byte [eax + 0xed41a8], cl
inc eax
cmp eax, 0x15
jb 0xe275ad
mov eax, 0xed41a8
ret

Function at 0xe29dc5
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80dc], 1
jne 0xe29e6f
or dword [0xed80dc], 1
mov dword [0xed4580], 0xbdaca18a
mov dword [0xed4584], 0xa6bbbfb6
mov dword [0xed4588], 0xbdefa1a0
mov dword [0xed458c], 0xaababeaa
mov dword [0xed4590], 0xabaabbbc
mov dword [0xed4594], 0xbbbaadef
mov dword [0xed4598], 0xa6a7bbef
mov dword [0xed459c], 0xa7bbefbc
mov dword [0xed45a0], 0xabaeaabd
mov dword [0xed45a4], 0xbcaea7ef
mov dword [0xed45a8], 0xefa0a1ef
mov dword [0xed45ac], 0xbfb6bdac
mov dword [0xed45b0], 0xa6efa0bb
mov dword [0xed45b4], 0xaebbbca1
mov dword [0xed45b8], 0xcfaaaca1
xor eax, eax
mov cl, byte [eax + 0xed4580]
xor cl, 0xcf
mov byte [eax + 0xed46a4], cl
inc eax
cmp eax, 0x3c
jb 0xe29e71
mov eax, 0xed46a4
ret

Function at 0xe29e8c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80d8], 1
jne 0xe29ee2
or dword [0xed80d8], 1
mov dword [0xed45bc], 0xa3a6ae89
mov dword [0xed45c0], 0xbbefabaa
mov dword [0xed45c4], 0xa1aaefa0
mov dword [0xed45c8], 0xbfb6bdac
mov dword [0xed45cc], 0xa0bfefbb
mov dword [0xed45d0], 0xadefbbbc
mov dword [0xed45d4], 0xcfb6aba0
xor eax, eax
mov cl, byte [eax + 0xed45bc]
xor cl, 0xcf
mov byte [eax + 0xed46e0], cl
inc eax
cmp eax, 0x1c
jb 0xe29ee4
mov eax, 0xed46e0
ret

Function at 0xe29f86
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80d4], 1
jne 0xe29fef
or dword [0xed80d4], 1
mov dword [0xed45d8], 0xa3a6ae89
mov dword [0xed45dc], 0xbbefabaa
mov dword [0xed45e0], 0xaaabefa0
mov dword [0xed45e4], 0xbfb6bdac
mov dword [0xed45e8], 0xaabcefbb
mov dword [0xed45ec], 0xbdaab9bd
mov dword [0xed45f0], 0xbcaabdef
mov dword [0xed45f4], 0xbca1a0bf
mov word [0xed45f8], 0xcfaa
xor eax, eax
mov cl, byte [eax + 0xed45d8]
xor cl, 0xcf
mov byte [eax + 0xed46fc], cl
inc eax
cmp eax, 0x22
jb 0xe29ff1
mov eax, 0xed46fc
ret
Function at 0xe2a365
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80d0], 1
jne 0xe2a3c4
or dword [0xed80d0], 1
mov dword [0xed45fc], 0x8b839d9a
mov dword [0xed4600], 0xa3a1b8a0
mov dword [0xed4604], 0x9babaea0
mov dword [0xed4608], 0xa3a689a0
mov dword [0xed460c], 0xaea9efaa
mov dword [0xed4610], 0xabaaa3a6
mov dword [0xed4614], 0xbda7eff5
mov word [0xed4618], 0xcff2
xor eax, eax
mov cl, byte [eax + 0xed45fc]
xor cl, 0xcf
mov byte [eax + 0xed4720], cl
inc eax
cmp eax, 0x1e
jb 0xe2a3c6
mov eax, 0xed4720
ret

Function at 0xe2af29
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80b8], 1
jne 0xe2af75
or dword [0xed80b8], 1
mov dword [0xed479c], 0x9ea6b795
mov dword [0xed47a0], 0x9ba6a1b3
mov dword [0xed47a4], 0xa6a7a2bc
mov dword [0xed47a8], 0xbdb4bc9b
mov dword [0xed47ac], 0xbbb3b4f2
mov dword [0xed47b0], 0xd2b6b7be
xor eax, eax
mov cl, byte [eax + 0xed479c]
xor cl, 0xd2
mov byte [eax + 0xed4828], cl
inc eax
cmp eax, 0x18
jb 0xe2af77
mov eax, 0xed4828
ret

Function at 0xe2b10a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80b4], 1
jne 0xe2b169
or dword [0xed80b4], 1
mov dword [0xed47b4], 0xa7b1b780
mov dword [0xed47b8], 0xbdbba1a0
mov dword [0xed47bc], 0xbff2a1bc
mov dword [0xed47c0], 0xf2a6a1a7
mov dword [0xed47c4], 0xb3f2b7b0
mov dword [0xed47c8], 0xb7bef2a6
mov dword [0xed47cc], 0xf2a6a1b3
mov word [0xed47d0], 0xd2e3
xor eax, eax
mov cl, byte [eax + 0xed47b4]
xor cl, 0xd2
mov byte [eax + 0xed4840], cl
inc eax
cmp eax, 0x1e
jb 0xe2b16b
mov eax, 0xed4840
ret

Function at 0xe2b186
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80ac], 1
jne 0xe2b1db
or dword [0xed80ac], 1
mov dword [0xed47e0], 0x8da6b7b5
mov dword [0xed47e4], 0xb7bfbba6
mov dword [0xed47e8], 0xbcbba18d
mov dword [0xed47ec], 0xbe8db7b1
mov dword [0xed47f0], 0x8da6a1b3
mov dword [0xed47f4], 0xa7a2bcbb
mov word [0xed47f8], 0xd2a6
xor eax, eax
mov cl, byte [eax + 0xed47e0]
xor cl, 0xd2
mov byte [eax + 0xed486c], cl
inc eax
cmp eax, 0x1a
jb 0xe2b1dd
mov eax, 0xed486c
ret

Function at 0xe2b1f8
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80a8], 1
jne 0xe2b24b
or dword [0xed80a8], 1
mov dword [0xed47fc], 0x8da6b7b5
mov dword [0xed4800], 0xb7b1bcb3
mov dword [0xed4804], 0xa0bda6a1
mov dword [0xed4808], 0xb6bdbf8d
mov dword [0xed480c], 0x8db7bea7
mov dword [0xed4810], 0xbaa6b3a2
mov byte [0xed4814], 0xd2
xor eax, eax
mov cl, byte [eax + 0xed47fc]
xor cl, 0xd2
mov byte [eax + 0xed4888], cl
inc eax
cmp eax, 0x19
jb 0xe2b24d
mov eax, 0xed4888
ret

Function at 0xe2b4ce
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed80a0], 1
jne 0xe2b534
or dword [0xed80a0], 1
mov dword [0xed48b4], 0xb0bfab81
mov dword [0xed48b8], 0xb1f2bebd
mov dword [0xed48bc], 0xb6bea7bd
mov dword [0xed48c0], 0xa6bdbcf2
mov dword [0xed48c4], 0xf2b7b0f2
mov dword [0xed48c8], 0xbda1b7a0
mov dword [0xed48cc], 0xb6b7a4be
mov word [0xed48d0], 0xf2e8
mov byte [0xed48d2], 0xd2
xor eax, eax
mov cl, byte [eax + 0xed48b4]
xor cl, 0xd2
mov byte [eax + 0xed48f4], cl
inc eax
cmp eax, 0x1f
jb 0xe2b536
mov eax, 0xed48f4
ret
Function at 0xe2bab9
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8094], 1
jne 0xe2bb15
or dword [0xed8094], 1
mov dword [0xed4934], 0xb5a2ba9d
mov dword [0xed4938], 0xf4b0bdb8
mov dword [0xed493c], 0xb9a1bab1
mov dword [0xed4940], 0xa0b5a6b1
mov dword [0xed4944], 0xf4babbbd
mov dword [0xed4948], 0xb0bab5bc
mov word [0xed494c], 0xb1b8
mov byte [0xed494e], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed4934]
xor cl, 0xd4
mov byte [eax + 0xed4ae4], cl
inc eax
cmp eax, 0x1b
jb 0xe2bb17
mov eax, 0xed4ae4
ret

Function at 0xe2bc17
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8090], 1
jne 0xe2bc73
or dword [0xed8090], 1
mov dword [0xed4950], 0xb5a2ba9d
mov dword [0xed4954], 0xf4b0bdb8
mov dword [0xed4958], 0xb9a1bab1
mov dword [0xed495c], 0xa0b5a6b1
mov dword [0xed4960], 0xf4babbbd
mov dword [0xed4964], 0xb0bab5bc
mov word [0xed4968], 0xb1b8
mov byte [0xed496a], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed4950]
xor cl, 0xd4
mov byte [eax + 0xed4b00], cl
inc eax
cmp eax, 0x1b
jb 0xe2bc75
mov eax, 0xed4b00
ret

Function at 0xe2bec7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed808c], 1
jne 0xe2bf23
or dword [0xed808c], 1
mov dword [0xed496c], 0xb5a2ba9d
mov dword [0xed4970], 0xf4b0bdb8
mov dword [0xed4974], 0xb9a1bab1
mov dword [0xed4978], 0xa0b5a6b1
mov dword [0xed497c], 0xf4babbbd
mov dword [0xed4980], 0xb0bab5bc
mov word [0xed4984], 0xb1b8
mov byte [0xed4986], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed496c]
xor cl, 0xd4
mov byte [eax + 0xed4b1c], cl
inc eax
cmp eax, 0x1b
jb 0xe2bf25
mov eax, 0xed4b1c
ret

Function at 0xe2c025
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8088], 1
jne 0xe2c081
or dword [0xed8088], 1
mov dword [0xed4988], 0xb5a2ba9d
mov dword [0xed498c], 0xf4b0bdb8
mov dword [0xed4990], 0xb9a1bab1
mov dword [0xed4994], 0xa0b5a6b1
mov dword [0xed4998], 0xf4babbbd
mov dword [0xed499c], 0xb0bab5bc
mov word [0xed49a0], 0xb1b8
mov byte [0xed49a2], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed4988]
xor cl, 0xd4
mov byte [eax + 0xed4b38], cl
inc eax
cmp eax, 0x1b
jb 0xe2c083
mov eax, 0xed4b38
ret

Function at 0xe2c272
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8084], 1
jne 0xe2c2db
or dword [0xed8084], 1
mov dword [0xed49a4], 0xb5a2ba9d
mov dword [0xed49a8], 0xf4b0bdb8
mov dword [0xed49ac], 0xb5a0b5b0
mov dword [0xed49b0], 0xaebda7f4
mov dword [0xed49b4], 0xbbb2f4b1
mov dword [0xed49b8], 0xbda3f4a6
mov dword [0xed49bc], 0x86f4b1b0
mov dword [0xed49c0], 0x878b9391
mov word [0xed49c4], 0xd48e
xor eax, eax
mov cl, byte [eax + 0xed49a4]
xor cl, 0xd4
mov byte [eax + 0xed4b54], cl
inc eax
cmp eax, 0x22
jb 0xe2c2dd
mov eax, 0xed4b54
ret
Function at 0xe2c2f8
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8080], 1
jne 0xe2c358
or dword [0xed8080], 1
mov dword [0xed49c8], 0xb5a2ba9d
mov dword [0xed49cc], 0xf4b0bdb8
mov dword [0xed49d0], 0xb5a0b5b0
mov dword [0xed49d4], 0xaebda7f4
mov dword [0xed49d8], 0xbbb2f4b1
mov dword [0xed49dc], 0x9186f4a6
mov dword [0xed49e0], 0x83908b93
mov dword [0xed49e4], 0xd490869b
xor eax, eax
mov cl, byte [eax + 0xed49c8]
xor cl, 0xd4
mov byte [eax + 0xed4b78], cl
inc eax
cmp eax, 0x20
jb 0xe2c35a
mov eax, 0xed4b78
ret

Function at 0xe2c4fc
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed807c], 1
jne 0xe2c547
or dword [0xed807c], 1
mov dword [0xed49e8], 0xa1a7ba81
mov dword [0xed49ec], 0xa6bba4a4
mov dword [0xed49f0], 0xf4b0b1a0
mov dword [0xed49f4], 0xb5a0b5b0
mov dword [0xed49f8], 0xa4ada0f4
mov word [0xed49fc], 0xd4b1
xor eax, eax
mov cl, byte [eax + 0xed49e8]
xor cl, 0xd4
mov byte [eax + 0xed4b98], cl
inc eax
cmp eax, 0x16
jb 0xe2c549
mov eax, 0xed4b98
ret

Function at 0xe2c702
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed806c], 1
jne 0xe2c754
or dword [0xed806c], 1
mov dword [0xed4a2c], 0xb9a1bab1
mov dword [0xed4a30], 0xa0b5a6b1
mov dword [0xed4a34], 0xa1a78bb1
mov dword [0xed4a38], 0xadb1bfb6
mov dword [0xed4a3c], 0xb1ba8ba7
mov word [0xed4a40], 0xa0ac
mov byte [0xed4a42], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed4a2c]
xor cl, 0xd4
mov byte [eax + 0xed4bdc], cl
inc eax
cmp eax, 0x17
jb 0xe2c756
mov eax, 0xed4bdc
ret

Function at 0xe2c771
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed805c], 1
jne 0xe2c7c3
or dword [0xed805c], 1
mov dword [0xed4a88], 0xb9a1bab1
mov dword [0xed4a8c], 0xa0b5a6b1
mov dword [0xed4a90], 0xb5a28bb1
mov dword [0xed4a94], 0xa7b1a1b8
mov dword [0xed4a98], 0xbbb8b78b
mov word [0xed4a9c], 0xb1a7
mov byte [0xed4a9e], 0xd4
xor eax, eax
mov cl, byte [eax + 0xed4a88]
xor cl, 0xd4
mov byte [eax + 0xed4c38], cl
inc eax
cmp eax, 0x17
jb 0xe2c7c5
mov eax, 0xed4c38
ret

Function at 0xe2d02c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8028], 1
jne 0xe2d050
or dword [0xed8028], 1
mov dword [0xed4cd8], 0xa6a6b0b8
mov dword [0xed4cdc], 0xd5b0b2b4
xor eax, eax
mov cl, byte [eax + 0xed4cd8]
xor cl, 0xd5
mov byte [eax + 0xed5038], cl
inc eax
cmp eax, 8
jb 0xe2d052
mov eax, 0xed5038
ret

Function at 0xe2d06d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8024], 1
jne 0xe2d091
or dword [0xed8024], 1
mov dword [0xed4ce0], 0xa6a6b0b8
mov dword [0xed4ce4], 0xd5b0b2b4
xor eax, eax
mov cl, byte [eax + 0xed4ce0]
xor cl, 0xd5
mov byte [eax + 0xed5040], cl
inc eax
cmp eax, 8
jb 0xe2d093
mov eax, 0xed5040
ret

Function at 0xe2dbdf
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed801c], 1
mov ecx, 0xb1d5
jne 0xe2dc20
or dword [0xed801c], 1
lea eax, [ecx + 0x26]
mov word [0xed4cf0], ax
add eax, 0xffffffbe
mov word [0xed4cf2], ax
lea eax, [ecx - 0x1a]
mov word [0xed4cf4], ax
add eax, 3
mov word [0xed4cf6], ax
mov eax, ecx
mov word [0xed4cf8], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed4cf0]
add eax, 2
mov word [eax + 0xed504e], dx
cmp eax, 0xa
jb 0xe2dc22
mov eax, 0xed5050
ret
Function at 0xe2dc40
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8018], 1
mov ecx, 0xb1d5
jne 0xe2dc81
or dword [0xed8018], 1
lea eax, [ecx + 0x26]
mov word [0xed4cfc], ax
add eax, 0xffffffbe
mov word [0xed4cfe], ax
lea eax, [ecx - 0x1a]
mov word [0xed4d00], ax
add eax, 3
mov word [0xed4d02], ax
mov eax, ecx
mov word [0xed4d04], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed4cfc]
add eax, 2
mov word [eax + 0xed505a], dx
cmp eax, 0xa
jb 0xe2dc83
mov eax, 0xed505c
ret

Function at 0xe2e211
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8014], 1
jne 0xe2e264
or dword [0xed8014], 1
mov dword [0xed4d08], 0x99a1b092
mov dword [0xed4d0c], 0xb9b4b6ba
mov dword [0xed4d10], 0xb3bb9cb0
mov dword [0xed4d14], 0xf5fcfdba
mov dword [0xed4d18], 0xb9bcb4b3
mov dword [0xed4d1c], 0xf5efb1b0
mov byte [0xed4d20], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4d08]
xor cl, 0xd5
mov byte [eax + 0xed5068], cl
inc eax
cmp eax, 0x19
jb 0xe2e266
mov eax, 0xed5068
ret

Function at 0xe2e3a7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8010], 1
jne 0xe2e3fa
or dword [0xed8010], 1
mov dword [0xed4d24], 0x99a1b092
mov dword [0xed4d28], 0xb9b4b6ba
mov dword [0xed4d2c], 0xb3bb9cb0
mov dword [0xed4d30], 0xf5fcfdba
mov dword [0xed4d34], 0xb9bcb4b3
mov dword [0xed4d38], 0xf5efb1b0
mov byte [0xed4d3c], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4d24]
xor cl, 0xd5
mov byte [eax + 0xed5084], cl
inc eax
cmp eax, 0x19
jb 0xe2e3fc
mov eax, 0xed5084
ret

Function at 0xe2e549
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed800c], 1
jne 0xe2e59c
or dword [0xed800c], 1
mov dword [0xed4d40], 0x99a1b092
mov dword [0xed4d44], 0xb9b4b6ba
mov dword [0xed4d48], 0xb3bb9cb0
mov dword [0xed4d4c], 0xf5fcfdba
mov dword [0xed4d50], 0xb9bcb4b3
mov dword [0xed4d54], 0xf5efb1b0
mov byte [0xed4d58], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4d40]
xor cl, 0xd5
mov byte [eax + 0xed50a0], cl
inc eax
cmp eax, 0x19
jb 0xe2e59e
mov eax, 0xed50a0
ret

Function at 0xe2e881
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8008], 1
jne 0xe2e91e
or dword [0xed8008], 1
mov dword [0xed4d5c], 0xa796999c
mov dword [0xed4d60], 0xb0a1b4b0
mov dword [0xed4d64], 0xb8baa793
mov dword [0xed4d68], 0xbda1b485
mov dword [0xed4d6c], 0xbcb4b3f5
mov dword [0xed4d70], 0xefb1b0b9
mov dword [0xed4d74], 0xa1b0a7f5
mov dword [0xed4d78], 0xb0bba7a0
mov dword [0xed4d7c], 0xbbb4f5b1
mov dword [0xed4d80], 0xa5b8b0f5
mov dword [0xed4d84], 0xbcf5aca1
mov dword [0xed4d88], 0xf5b8b0a1
mov dword [0xed4d8c], 0xa1a6bcb9
mov byte [0xed4d90], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4d5c]
xor cl, 0xd5
mov byte [eax + 0xed50bc], cl
inc eax
cmp eax, 0x35
jb 0xe2e920
mov eax, 0xed50bc
ret
Function at 0xe2e93b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8004], 1
jne 0xe2e9a5
or dword [0xed8004], 1
mov dword [0xed4d94], 0xa59a9d86
mov dword [0xed4d98], 0xba93bbb0
mov dword [0xed4d9c], 0xa7b0b1b9
mov dword [0xed4da0], 0x86b1bb94
mov dword [0xed4da4], 0xb6b0b9b0
mov dword [0xed4da8], 0xb0a19ca1
mov dword [0xed4dac], 0xb3f5a6b8
mov dword [0xed4db0], 0xb0b9bcb4
mov dword [0xed4db4], 0xd5f5efb1
xor eax, eax
mov cl, byte [eax + 0xed4d94]
xor cl, 0xd5
mov byte [eax + 0xed50f4], cl
inc eax
cmp eax, 0x24
jb 0xe2e9a7
mov eax, 0xed50f4
ret

Function at 0xe2ec72
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7ff8], 1
jne 0xe2ecd1
or dword [0xed7ff8], 1
mov dword [0xed4dc8], 0x85a1b092
mov dword [0xed4dcc], 0xb496a7a2
mov dword [0xed4dd0], 0xbcb7b4a5
mov dword [0xed4dd4], 0xbca1bcb9
mov dword [0xed4dd8], 0xfcfda6b0
mov dword [0xed4ddc], 0xbcb4b3f5
mov dword [0xed4de0], 0xefb1b0b9
mov word [0xed4de4], 0xd5f5
xor eax, eax
mov cl, byte [eax + 0xed4dc8]
xor cl, 0xd5
mov byte [eax + 0xed5128], cl
inc eax
cmp eax, 0x1e
jb 0xe2ecd3
mov eax, 0xed5128
ret

Function at 0xe2ed7e
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7fec], 1
jne 0xe2edd4
or dword [0xed7fec], 1
mov dword [0xed4dfc], 0xa58aa6bc
mov dword [0xed4e00], 0xb0b6baa7
mov dword [0xed4e04], 0xa78aa6a6
mov dword [0xed4e08], 0xbcbbbba0
mov dword [0xed4e0c], 0xb48ab2bb
mov dword [0xed4e10], 0xb1b48aa6
mov dword [0xed4e14], 0xd5bbbcb8
xor eax, eax
mov cl, byte [eax + 0xed4dfc]
xor cl, 0xd5
mov byte [eax + 0xed515c], cl
inc eax
cmp eax, 0x1c
jb 0xe2edd6
mov eax, 0xed515c
ret

Function at 0xe2edf1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7fe8], 1
jne 0xe2ee47
or dword [0xed7fe8], 1
mov dword [0xed4e18], 0xb68aa6bc
mov dword [0xed4e1c], 0xb0a7a7a0
mov dword [0xed4e20], 0xa08aa1bb
mov dword [0xed4e24], 0x8aa7b0a6
mov dword [0xed4e28], 0xb4b6bab9
mov dword [0xed4e2c], 0xb1b48ab9
mov dword [0xed4e30], 0xd5bbbcb8
xor eax, eax
mov cl, byte [eax + 0xed4e18]
xor cl, 0xd5
mov byte [eax + 0xed5178], cl
inc eax
cmp eax, 0x1c
jb 0xe2ee49
mov eax, 0xed5178
ret

Function at 0xe2ee64
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7fd4], 1
jne 0xe2eeb6
or dword [0xed7fd4], 1
mov dword [0xed4e7c], 0xa1bcb4a2
mov dword [0xed4e80], 0xa7bab38a
mov dword [0xed4e84], 0xbbbca68a
mov dword [0xed4e88], 0x8ab0b9b2
mov dword [0xed4e8c], 0xb0bfb7ba
mov word [0xed4e90], 0xa1b6
mov byte [0xed4e92], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4e7c]
xor cl, 0xd5
mov byte [eax + 0xed51dc], cl
inc eax
cmp eax, 0x17
jb 0xe2eeb8
mov eax, 0xed51dc
ret

Function at 0xe2eed3
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7f8c], 1
jne 0xe2ef25
or dword [0xed7f8c], 1
mov dword [0xed4f98], 0x8aa1b0b2
mov dword [0xed4f9c], 0xa7a7a0b6
mov dword [0xed4fa0], 0x8aa1bbb0
mov dword [0xed4fa4], 0xb6baa7a5
mov dword [0xed4fa8], 0x8aa6a6b0
mov word [0xed4fac], 0xb1bc
mov byte [0xed4fae], 0xd5
xor eax, eax
mov cl, byte [eax + 0xed4f98]
xor cl, 0xd5
mov byte [eax + 0xed52f8], cl
inc eax
cmp eax, 0x17
jb 0xe2ef27
mov eax, 0xed52f8
ret
Function at 0xe2f6dd
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7f78], 1
mov ecx, 0xb1d7
jne 0xe2f752
or dword [0xed7f78], 1
lea eax, [ecx - 0x1c]
mov word [0xed5354], ax
add eax, 0xffffffe7
mov word [0xed5356], ax
lea eax, [ecx - 0x21]
mov word [0xed5358], ax
add eax, 0xffffffd2
mov word [0xed535a], ax
lea eax, [ecx - 0x37]
mov edx, eax
mov word [0xed535c], dx
add edx, 0x1e
mov word [0xed535e], dx
lea edx, [ecx - 0x1e]
mov word [0xed5360], dx
add edx, 0xfffffffa
mov eax, ecx
mov word [0xed5362], dx
mov dword [0xed5364], 0xb1a0b1b8
mov word [0xed5368], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed5354]
add eax, 2
mov word [eax + 0xed55d6], dx
cmp eax, 0x16
jb 0xe2f754
mov eax, 0xed55d8
ret

Function at 0xe2f772
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7f74], 1
mov edx, 0xb1d7
jne 0xe2f816
or dword [0xed7f74], 1
lea ecx, [edx - 0x1c]
mov eax, ecx
mov word [0xed536c], ax
add eax, 0xffffffe7
mov word [0xed536e], ax
lea eax, [edx - 0x21]
mov word [0xed5370], ax
add eax, 0xffffffd2
push esi
mov esi, eax
mov word [0xed537c], ax
lea eax, [edx - 0x37]
mov ecx, eax
mov word [0xed537e], cx
add ecx, 0x1e
mov word [0xed5372], si
lea esi, [edx - 0x18]
mov word [0xed5380], cx
lea ecx, [edx - 0x1e]
mov word [0xed5374], si
add esi, 0xffffffe4
mov word [0xed5382], cx
add ecx, 0xfffffffa
mov eax, edx
mov word [0xed5376], si
mov dword [0xed5378], 0xb1bbb1ba
mov word [0xed5384], cx
mov dword [0xed5386], 0xb1a0b1b8
mov word [0xed538a], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xed536c]
add eax, 2
mov word [eax + 0xed55ee], cx
cmp eax, 0x20
jb 0xe2f818
mov eax, 0xed55f0
ret

Function at 0xe2fa5a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7f70], 1
jne 0xe2faa3
or dword [0xed7f70], 1
mov dword [0xed538c], 0xf7b6a29b
mov dword [0xed5390], 0xb8a5a5b2
mov dword [0xed5394], 0xb9bef7a5
mov dword [0xed5398], 0xb3b9a0f7
mov dword [0xed539c], 0xb4b8a5a7
mov byte [0xed53a0], 0xd7
xor eax, eax
mov cl, byte [eax + 0xed538c]
xor cl, 0xd7
mov byte [eax + 0xed5610], cl
inc eax
cmp eax, 0x15
jb 0xe2faa5
mov eax, 0xed5610
ret

Function at 0xe31bad
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7ee0], 1
jne 0xe31bee
or dword [0xed7ee0], 1
mov dword [0xed585c], 0xaef9b697
mov dword [0xed5860], 0xb6bdb7b0
mov dword [0xed5864], 0xb6baf9ae
mov dword [0xed5868], 0xa1bcadb7
mov word [0xed586c], 0xd9ad
xor eax, eax
mov cl, byte [eax + 0xed585c]
xor cl, 0xd9
mov byte [eax + 0xed5ae8], cl
inc eax
cmp eax, 0x12
jb 0xe31bf0
mov eax, 0xed5ae8
ret

Function at 0xe31c0b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed7edc], 1
jne 0xe31c4c
or dword [0xed7edc], 1
mov dword [0xed5870], 0xaef9b697
mov dword [0xed5874], 0xb6bdb7b0
mov dword [0xed5878], 0xb6baf9ae
mov dword [0xed587c], 0xa1bcadb7
mov word [0xed5880], 0xd9ad
xor eax, eax
mov cl, byte [eax + 0xed5870]
xor cl, 0xd9
mov byte [eax + 0xed5afc], cl
inc eax
cmp eax, 0x12
jb 0xe31c4e
mov eax, 0xed5afc
ret