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

Disassembly:
mov eax, 0xe9dc72
call fcn.00e9cd48
sub esp, 0x64
test byte [0xed832c], 1
jne 0xe17edd
or dword [0xed832c], 1
mov word [0xed2ec4], 0x8fe7
mov byte [0xed2ec6], 0xc2
push ebx
push esi
xor ebx, ebx
push edi
xor eax, eax
mov cl, byte [eax + 0xed2ec4]
xor cl, 0xc2
mov byte [eax + 0xed35f4], cl
inc eax
cmp eax, 3
jb 0xe17ee4
mov esi, 0xed35f4
mov eax, esi
mov dword [ebp - 0x40], 0xf
mov dword [ebp - 0x44], ebx
mov byte [ebp - 0x54], bl
lea edi, [eax + 1]
mov cl, byte [eax]
inc eax
cmp cl, bl
jne 0xe17f10
sub eax, edi
push eax
push esi
lea ecx, [ebp - 0x54]
call fcn.00e14e72
push dword [ebp + 0x10]
lea eax, [ebp - 0x54]
push eax
push dword [ebp + 0xc]
lea eax, [ebp - 0x70]
push eax
mov dword [ebp - 4], ebx
call fcn.00e1ea27
add esp, 0x10
push ebx
push 1
lea ecx, [ebp - 0x54]
mov byte [ebp - 4], 2
call fcn.00e14cae
cmp dword [ebp - 0x5c], 0x10
mov eax, dword [ebp - 0x70]
jae 0xe17f57
lea eax, [ebp - 0x70]
mov esi, dword [ebp + 8]
push eax
push esi
call fcn.00e62838
pop ecx
pop ecx
cmp eax, ebx
je 0xe17fa8
cmp eax, 3
jne 0xe17f95
call fcn.00e180af
mov dword [ebp - 0x10], eax
lea eax, [ebp - 0x10]
push eax
lea ecx, [ebp - 0x1c]
call fcn.00e76a75
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
push 0xec2d20
lea eax, [ebp - 0x1c]
push eax
call fcn.00e80985
cmp eax, 4
jne 0xe17fa1
call fcn.00e18162
jmp 0xe17f71
call fcn.00e18215
jmp 0xe17f71
push ebx
push ebx
push ebx
push 1
push ebx
push esi
call fcn.00e6426e
mov edi, eax
add esp, 0x18
cmp edi, ebx
je 0xe1805f
push ebx
call fcn.00e18299
push eax
push 0xffffffffffffffff
push esi
call fcn.00e62fcf
add esp, 0x10
push eax
lea ecx, [ebp - 0x38]
mov dword [ebp - 0x24], 0xf
mov dword [ebp - 0x28], ebx
mov byte [ebp - 0x38], bl
call fcn.00e14c8d
mov byte [ebp - 4], 3
cmp edi, 2
jne 0xe18017
call fcn.00e182e0
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.00e1ea98
pop ecx
pop ecx
mov byte [ebp - 4], 4
lea esi, [ebp - 0x1c]
call fcn.00e15c05
jmp 0xe17f87
cmp edi, 4
jne 0xe18036
call fcn.00e1833f
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.00e1ea98
pop ecx
pop ecx
mov byte [ebp - 4], 5
jmp 0xe1800a
cmp edi, 6
jne 0xe18055
call fcn.00e183a4
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.00e1ea98
pop ecx
pop ecx
mov byte [ebp - 4], 6
jmp 0xe1800a
call fcn.00e18428
jmp 0xe17f71
or edi, 0xffffffff
push edi
push esi
mov dword [ebp - 0x10], edi
call fcn.00e6362a
pop ecx
pop ecx
test eax, eax
je 0xe18080
push ebx
push edi
push esi
call fcn.00e637ee
add esp, 0xc
mov dword [ebp - 0x10], eax
push esi
call fcn.00e63424
sub edi, eax
push edi
push esi
call fcn.00e6343a
add esp, 0xc
push ebx
push 1
lea ecx, [ebp - 0x70]
call fcn.00e14cae
mov ecx, dword [ebp - 0xc]
mov eax, dword [ebp - 0x10]
pop edi
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret
Function at 0xe180af
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8328], 1
jne 0xe18145
or dword [0xed8328], 1
mov dword [0xed2ec8], 0xaeaba384
mov dword [0xed2ecc], 0xb6e2a6a7
mov dword [0xed2ed0], 0xb4a7e2ad
mov dword [0xed2ed4], 0xa3b7aea3
mov dword [0xed2ed8], 0xa0e2a7b6
mov dword [0xed2edc], 0xb1b6adad
mov dword [0xed2ee0], 0xb2a3b0b6
mov dword [0xed2ee4], 0xa3b0a4e2
mov dword [0xed2ee8], 0xaca7afa5
mov dword [0xed2eec], 0xb1e2eeb6
mov dword [0xed2ef0], 0xa3b6acbb
mov dword [0xed2ef4], 0xb0a7e2ba
mov dword [0xed2ef8], 0xc2b0adb0
xor eax, eax
mov cl, byte [eax + 0xed2ec8]
xor cl, 0xc2
mov byte [eax + 0xed35f8], cl
inc eax
cmp eax, 0x34
jb 0xe18147
mov eax, 0xed35f8
ret

Function at 0xe18162
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8324], 1
jne 0xe181f8
or dword [0xed8324], 1
mov dword [0xed2efc], 0xaeaba384
mov dword [0xed2f00], 0xb6e2a6a7
mov dword [0xed2f04], 0xb4a7e2ad
mov dword [0xed2f08], 0xa3b7aea3
mov dword [0xed2f0c], 0xa0e2a7b6
mov dword [0xed2f10], 0xb1b6adad
mov dword [0xed2f14], 0xb2a3b0b6
mov dword [0xed2f18], 0xa3b0a4e2
mov dword [0xed2f1c], 0xaca7afa5
mov dword [0xed2f20], 0xafe2eeb6
mov dword [0xed2f24], 0xb0adafa7
mov dword [0xed2f28], 0xb0a7e2bb
mov dword [0xed2f2c], 0xc2b0adb0
xor eax, eax
mov cl, byte [eax + 0xed2efc]
xor cl, 0xc2
mov byte [eax + 0xed362c], cl
inc eax
cmp eax, 0x34
jb 0xe181fa
mov eax, 0xed362c
ret

Function at 0xe18215
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8320], 1
jne 0xe1827c
or dword [0xed8320], 1
mov dword [0xed2f30], 0xaca9ac97
mov dword [0xed2f34], 0xe2acb5ad
mov dword [0xed2f38], 0xadb0b0a7
mov dword [0xed2f3c], 0xacabe2b0
mov dword [0xed2f40], 0xa3b7aee2
mov dword [0xed2f44], 0xadae9d8e
mov dword [0xed2f48], 0xb6b1a6a3
mov dword [0xed2f4c], 0xa5acabb0
mov byte [0xed2f50], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2f30]
xor cl, 0xc2
mov byte [eax + 0xed3660], cl
inc eax
cmp eax, 0x21
jb 0xe1827e
mov eax, 0xed3660
ret

Function at 0xe18299
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed831c], 1
jne 0xe182c3
or dword [0xed831c], 1
mov dword [0xed2f54], 0xacadacfe
mov word [0xed2f58], 0xfca7
mov byte [0xed2f5a], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2f54]
xor cl, 0xc2
mov byte [eax + 0xed3684], cl
inc eax
cmp eax, 7
jb 0xe182c5
mov eax, 0xed3684
ret

Function at 0xe182e0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8318], 1
jne 0xe18322
or dword [0xed8318], 1
mov dword [0xed2f5c], 0xe2a3b78e
mov dword [0xed2f60], 0xb6acb7b0
mov dword [0xed2f64], 0xe2a7afab
mov dword [0xed2f68], 0xadb0b0a7
mov dword [0xed2f6c], 0xc2e2f8b0
xor eax, eax
mov cl, byte [eax + 0xed2f5c]
xor cl, 0xc2
mov byte [eax + 0xed368c], cl
inc eax
cmp eax, 0x14
jb 0xe18324
mov eax, 0xed368c
ret
Function at 0xe1833f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8314], 1
jne 0xe18387
or dword [0xed8314], 1
mov dword [0xed2f70], 0xe2a3b78e
mov dword [0xed2f74], 0xadafa7af
mov dword [0xed2f78], 0xa7e2bbb0
mov dword [0xed2f7c], 0xb0adb0b0
mov word [0xed2f80], 0xe2f8
mov byte [0xed2f82], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2f70]
xor cl, 0xc2
mov byte [eax + 0xed36a0], cl
inc eax
cmp eax, 0x13
jb 0xe18389
mov eax, 0xed36a0
ret

Function at 0xe183a4
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8310], 1
jne 0xe1840b
or dword [0xed8310], 1
mov dword [0xed2f84], 0xe2a3b78e
mov dword [0xed2f88], 0xadb0b0a7
mov dword [0xed2f8c], 0xacabe2b0
mov dword [0xed2f90], 0xa7a6abb1
mov dword [0xed2f94], 0xb0b0a7e2
mov dword [0xed2f98], 0xaae2b0ad
mov dword [0xed2f9c], 0xaea6aca3
mov dword [0xed2fa0], 0xe2f8b0a7
mov byte [0xed2fa4], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2f84]
xor cl, 0xc2
mov byte [eax + 0xed36b4], cl
inc eax
cmp eax, 0x21
jb 0xe1840d
mov eax, 0xed36b4
ret

Function at 0xe18428
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed830c], 1
jne 0xe18484
or dword [0xed830c], 1
mov dword [0xed2fa8], 0xaca9ac97
mov dword [0xed2fac], 0xe2acb5ad
mov dword [0xed2fb0], 0xadb0b0a7
mov dword [0xed2fb4], 0xacabe2b0
mov dword [0xed2fb8], 0xa3b7aee2
mov dword [0xed2fbc], 0xa3a1b29d
mov word [0xed2fc0], 0xaeae
mov byte [0xed2fc2], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2fa8]
xor cl, 0xc2
mov byte [eax + 0xed36d8], cl
inc eax
cmp eax, 0x1b
jb 0xe18486
mov eax, 0xed36d8
ret

Function at 0xe186c2
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8308], 1
jne 0xe1870b
or dword [0xed8308], 1
mov dword [0xed2fc4], 0xa7b1a380
mov dword [0xed2fc8], 0xa6e2f6f4
mov dword [0xed2fcc], 0xa6ada1a7
mov dword [0xed2fd0], 0xa3a4e2a7
mov dword [0xed2fd4], 0xa6a7aeab
mov byte [0xed2fd8], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2fc4]
xor cl, 0xc2
mov byte [eax + 0xed36f4], cl
inc eax
cmp eax, 0x15
jb 0xe1870d
mov eax, 0xed36f4
ret
Function at 0xe18728
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
push 0xffffffffffffffff
push 0xe9f3bb
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
sub esp, 0x50
push ebx
push esi
push edi
push dword [ebp + 0xc]
lea eax, [esp + 0x24]
xor ebx, ebx
push eax
mov dword [esp + 0x18], ebx
call fcn.00e3fb94
lea ecx, [esp + 0x44]
push ecx
mov ecx, eax
mov dword [esp + 0x70], ebx
call fcn.00e3df5f
add esp, 0xc
push 1
xor edi, edi
lea esi, [esp + 0x24]
call fcn.00e14dec
mov dword [esp + 0x20], ebx
mov dword [esp + 0x24], ebx
mov dword [esp + 0x28], ebx
mov byte [esp + 0x64], 3
mov esi, dword [esp + 0x4c]
lea eax, [esp + 0x20]
call fcn.00e1bd80
mov eax, dword [esp + 0x24]
sub eax, dword [esp + 0x20]
cmp dword [esp + 0x50], 0x10
mov dword [esp + 0xc], eax
mov eax, dword [esp + 0x3c]
jae 0xe187b5
lea eax, [esp + 0x3c]
lea ecx, [esp + 0xc]
push ecx
push dword [esp + 0x24]
push esi
push eax
call fcn.00e42167
add esp, 0x10
test al, al
jne 0xe187fa
call fcn.00e18871
mov dword [esp + 0xc], eax
lea eax, [esp + 0xc]
push eax
lea ecx, [esp + 0x18]
call fcn.00e76a75
push 0xec2d20
lea eax, [esp + 0x18]
push eax
mov dword [esp + 0x1c], vtable.std::runtime_error.0
call fcn.00e80985
mov esi, dword [esp + 0xc]
lea eax, [esp + 0x20]
call fcn.00e1bd80
mov ecx, dword [esp + 0x24]
mov eax, dword [esp + 0x20]
xor esi, esi
sub ecx, eax
mov dword [esp + 0xc], ecx
je 0xe1883a
mov eax, dword [ebp + 0x10]
mov ecx, dword [eax]
mov edi, dword [eax + 4]
sub edi, ecx
xor edx, edx
mov eax, esi
div edi
mov eax, dword [esp + 0x20]
mov cl, byte [edx + ecx]
xor byte [eax + esi], cl
inc esi
cmp esi, dword [esp + 0xc]
jb 0xe18819
push dword [esp + 0xc]
mov esi, dword [ebp + 8]
push eax
call fcn.00e1b0a9
lea esi, [esp + 0x20]
call fcn.00e1bd67
push ebx
push 1
lea ecx, [esp + 0x44]
call fcn.00e14cae
mov ecx, dword [esp + 0x5c]
mov eax, dword [ebp + 8]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0xe18871
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8304], 1
jne 0xe188ba
or dword [0xed8304], 1
mov dword [0xed2fdc], 0xa7b1a380
mov dword [0xed2fe0], 0xa6e2f6f4
mov dword [0xed2fe4], 0xa6ada1a7
mov dword [0xed2fe8], 0xa3a4e2a7
mov dword [0xed2fec], 0xa6a7aeab
mov byte [0xed2ff0], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed2fdc]
xor cl, 0xc2
mov byte [eax + 0xed370c], cl
inc eax
cmp eax, 0x15
jb 0xe188bc
mov eax, 0xed370c
ret

Function at 0xe18f7d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8300], 1
jne 0xe18fd2
or dword [0xed8300], 1
mov dword [0xed2ff4], 0xaeb7ad81
mov dword [0xed2ff8], 0xadace2a6
mov dword [0xed2ffc], 0xb2ade2b6
mov dword [0xed3000], 0xa1e2aca7
mov dword [0xed3004], 0xaab1a3b0
mov dword [0xed3008], 0xafb7a6e2
mov word [0xed300c], 0xc2b2
xor eax, eax
mov cl, byte [eax + 0xed2ff4]
xor cl, 0xc2
mov byte [eax + 0xed3724], cl
inc eax
cmp eax, 0x1a
jb 0xe18fd4
mov eax, 0xed3724
ret
Function at 0xe18fef
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82f8], 1
jne 0xe19012
or dword [0xed82f8], 1
mov dword [0xed3014], 0xa5adaeed
mov word [0xed3018], 0xc2ed
xor eax, eax
mov cl, byte [eax + 0xed3014]
xor cl, 0xc2
mov byte [eax + 0xed3744], cl
inc eax
cmp eax, 6
jb 0xe19014
mov eax, 0xed3744
ret

Function at 0xe1902f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82f4], 1
jne 0xe190aa
or dword [0xed82f4], 1
mov dword [0xed301c], 0xb2b6b6aa
mov dword [0xed3020], 0xa3ededf8
mov dword [0xed3024], 0xbbaea3ac
mov dword [0xed3028], 0xb1a1abb6
mov dword [0xed302c], 0xb6a7a5ec
mov dword [0xed3030], 0xacb5ada6
mov dword [0xed3034], 0xb6b1a7b6
mov dword [0xed3038], 0xafada1ec
mov dword [0xed303c], 0xedf0b4ed
mov dword [0xed3040], 0xeda5adae
mov byte [0xed3044], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed301c]
xor cl, 0xc2
mov byte [eax + 0xed374c], cl
inc eax
cmp eax, 0x29
jb 0xe190ac
mov eax, 0xed374c
ret

Function at 0xe190c7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82f0], 1
jne 0xe190f2
or dword [0xed82f0], 1
mov dword [0xed3048], 0xb1e4ffa1
mov dword [0xed304c], 0xffb6e4ff
mov byte [0xed3050], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3048]
xor cl, 0xc2
mov byte [eax + 0xed3778], cl
inc eax
cmp eax, 9
jb 0xe190f4
mov eax, 0xed3778
ret

Function at 0xe1910f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82e0], 1
jne 0xe19197
or dword [0xed82e0], 1
mov dword [0xed3064], 0xb6acad81
mov dword [0xed3068], 0xefb6aca7
mov dword [0xed306c], 0xa7b2bb96
mov dword [0xed3070], 0xb2a3e2f8
mov dword [0xed3074], 0xa1abaeb2
mov dword [0xed3078], 0xadabb6a3
mov dword [0xed307c], 0xefbaedac
mov dword [0xed3080], 0xefb5b5b5
mov dword [0xed3084], 0xafb0ada4
mov dword [0xed3088], 0xaeb0b7ef
mov dword [0xed308c], 0xada1aca7
mov dword [0xed3090], 0xc2a6a7a6
xor eax, eax
mov cl, byte [eax + 0xed3064]
xor cl, 0xc2
mov byte [eax + 0xed3794], cl
inc eax
cmp eax, 0x30
jb 0xe19199
mov eax, 0xed3794
ret

Function at 0xe191b4
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82dc], 1
jne 0xe191df
or dword [0xed82dc], 1
mov dword [0xed3094], 0x96918d92
mov dword [0xed3098], 0xe2adb6e2
mov byte [0xed309c], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3094]
xor cl, 0xc2
mov byte [eax + 0xed37c4], cl
inc eax
cmp eax, 9
jb 0xe191e1
mov eax, 0xed37c4
ret

Function at 0xe191fc
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82d8], 1
jne 0xe19245
or dword [0xed82d8], 1
mov dword [0xed30a0], 0xaba3a4e2
mov dword [0xed30a4], 0xe2a6a7ae
mov dword [0xed30a8], 0xaab6abb5
mov dword [0xed30ac], 0xa3b6b1e2
mov dword [0xed30b0], 0xe2b1b7b6
mov byte [0xed30b4], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed30a0]
xor cl, 0xc2
mov byte [eax + 0xed37d0], cl
inc eax
cmp eax, 0x15
jb 0xe19247
mov eax, 0xed37d0
ret
Function at 0xe19b89
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82b0], 1
jne 0xe19be5
or dword [0xed82b0], 1
mov dword [0xed3120], 0xaeaba384
mov dword [0xed3124], 0xb6e2a6a7
mov dword [0xed3128], 0xa7b0e2ad
mov dword [0xed312c], 0xade2a6a3
mov dword [0xed3130], 0xade2b0b7
mov dword [0xed3134], 0xa7e2acb5
mov word [0xed3138], 0xa7ba
mov byte [0xed313a], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3120]
xor cl, 0xc2
mov byte [eax + 0xed3850], cl
inc eax
cmp eax, 0x1b
jb 0xe19be7
mov eax, 0xed3850
ret

Function at 0xe19c63
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82ac], 1
jne 0xe19caf
or dword [0xed82ac], 1
mov dword [0xed313c], 0x8eb6a785
mov dword [0xed3140], 0x8bb6b1a3
mov dword [0xed3144], 0xb6b7b2ac
mov dword [0xed3148], 0xada4ac8b
mov dword [0xed314c], 0xaba3a4e2
mov dword [0xed3150], 0xc2a6a7ae
xor eax, eax
mov cl, byte [eax + 0xed313c]
xor cl, 0xc2
mov byte [eax + 0xed386c], cl
inc eax
cmp eax, 0x18
jb 0xe19cb1
mov eax, 0xed386c
ret

Function at 0xe19fc3
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82a8], 1
mov ecx, 0xb1c2
jne 0xe1a026
or dword [0xed82a8], 1
lea eax, [ecx - 0x18]
mov word [0xed3154], ax
add eax, 0xc
mov edx, eax
mov word [0xed3158], ax
lea eax, [ecx - 0x10]
mov word [0xed315a], ax
dec eax
mov word [0xed315c], ax
lea eax, [ecx + 0x36]
mov word [0xed315e], ax
add eax, 0xfffffff5
mov word [0xed3156], dx
mov edx, eax
mov word [0xed3162], ax
mov eax, ecx
mov word [0xed3160], dx
mov word [0xed3164], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed3154]
add eax, 2
mov word [eax + 0xed3882], dx
cmp eax, 0x12
jb 0xe1a028
mov eax, 0xed3884
ret

Function at 0xe1a046
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed82a4], 1
mov ecx, 0xb1c2
jne 0xe1a0a2
or dword [0xed82a4], 1
lea eax, [ecx - 0x18]
mov word [0xed3168], ax
add eax, 0xc
mov edx, eax
mov word [0xed316c], ax
lea eax, [ecx - 0x10]
mov word [0xed316e], ax
add eax, 0x46
mov word [0xed3170], ax
lea eax, [ecx + 0x2b]
mov word [0xed316a], dx
mov edx, eax
mov word [0xed3174], ax
mov eax, ecx
mov word [0xed3172], dx
mov word [0xed3176], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed3168]
add eax, 2
mov word [eax + 0xed3896], dx
cmp eax, 0x10
jb 0xe1a0a4
mov eax, 0xed3898
ret

Function at 0xe1a0c2
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed829c], 1
jne 0xe1a10b
or dword [0xed829c], 1
mov dword [0xed3184], 0x85b1ac86
mov dword [0xed3188], 0xa381b6a7
mov dword [0xed318c], 0x86a7aaa1
mov dword [0xed3190], 0x96a3b6a3
mov dword [0xed3194], 0xa7aea0a3
mov byte [0xed3198], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3184]
xor cl, 0xc2
mov byte [eax + 0xed38b4], cl
inc eax
cmp eax, 0x15
jb 0xe1a10d
mov eax, 0xed38b4
ret
Function at 0xe1a9f3
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8298], 1
mov ecx, 0xb1c2
jne 0xe1aa7d
or dword [0xed8298], 1
lea eax, [ecx - 0x21]
mov word [0xed319c], ax
add eax, 0xf
mov edx, eax
mov word [0xed319e], dx
lea edx, [ecx - 0x1f]
mov word [0xed31a0], dx
add edx, 0xe
mov word [0xed31a2], dx
lea edx, [ecx - 0x18]
mov word [0xed31a4], dx
add edx, 0xfffffff3
mov word [0xed31a6], dx
mov edx, eax
mov word [0xed31a8], dx
lea edx, [ecx - 0x1b]
lea eax, [ecx - 0xc]
mov word [0xed31aa], dx
mov word [0xed31b2], ax
add edx, 0xb
mov eax, ecx
mov word [0xed31ac], dx
mov dword [0xed31ae], 0xb1b0b1ad
mov word [0xed31b4], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed319c]
add eax, 2
mov word [eax + 0xed38ca], dx
cmp eax, 0x1a
jb 0xe1aa7f
mov eax, 0xed38cc
ret

Function at 0xe1aa9d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8294], 1
jne 0xe1ab17
or dword [0xed8294], 1
mov dword [0xed31b8], 0xb0b0ad91
mov dword [0xed31bc], 0xb6e2eebb
mov dword [0xed31c0], 0xe2b1abaa
mov dword [0xed31c4], 0xb6a4adb1
mov dword [0xed31c8], 0xa7b0a3b5
mov dword [0xed31cc], 0xe2b1abe2
mov dword [0xed31d0], 0xe2b6adac
mov dword [0xed31d4], 0xaba3b4a3
mov dword [0xed31d8], 0xaea0a3ae
mov word [0xed31dc], 0xeca7
mov byte [0xed31de], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed31b8]
xor cl, 0xc2
mov byte [eax + 0xed38e8], cl
inc eax
cmp eax, 0x27
jb 0xe1ab19
mov eax, 0xed38e8
ret

Function at 0xe1ab34
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8290], 1
jne 0xe1ab57
or dword [0xed8290], 1
mov dword [0xed31e0], 0xadb0b087
mov word [0xed31e4], 0xc2b0
xor eax, eax
mov cl, byte [eax + 0xed31e0]
xor cl, 0xc2
mov byte [eax + 0xed3910], cl
inc eax
cmp eax, 6
jb 0xe1ab59
mov eax, 0xed3910
ret

Function at 0xe1ab74
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed828c], 1
jne 0xe1abee
or dword [0xed828c], 1
mov dword [0xed31e8], 0xb0b0ad91
mov dword [0xed31ec], 0xb6e2eebb
mov dword [0xed31f0], 0xe2b1abaa
mov dword [0xed31f4], 0xb6a4adb1
mov dword [0xed31f8], 0xa7b0a3b5
mov dword [0xed31fc], 0xe2b1abe2
mov dword [0xed3200], 0xe2b6adac
mov dword [0xed3204], 0xaba3b4a3
mov dword [0xed3208], 0xaea0a3ae
mov word [0xed320c], 0xeca7
mov byte [0xed320e], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed31e8]
xor cl, 0xc2
mov byte [eax + 0xed3918], cl
inc eax
cmp eax, 0x27
jb 0xe1abf0
mov eax, 0xed3918
ret

Function at 0xe1ac0b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8288], 1
jne 0xe1ac2e
or dword [0xed8288], 1
mov dword [0xed3210], 0xadb0b087
mov word [0xed3214], 0xc2b0
xor eax, eax
mov cl, byte [eax + 0xed3210]
xor cl, 0xc2
mov byte [eax + 0xed3940], cl
inc eax
cmp eax, 6
jb 0xe1ac30
mov eax, 0xed3940
ret
Function at 0xe1ac4b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8284], 1
jne 0xe1aca1
or dword [0xed8284], 1
mov dword [0xed3218], 0xe2a7ae8d
mov dword [0xed321c], 0xb6abacab
mov dword [0xed3220], 0xabaea3ab
mov dword [0xed3224], 0xabb6a3b8
mov dword [0xed3228], 0xa4e2acad
mov dword [0xed322c], 0xa7aeaba3
mov dword [0xed3230], 0xc2e2f8a6
xor eax, eax
mov cl, byte [eax + 0xed3218]
xor cl, 0xc2
mov byte [eax + 0xed3948], cl
inc eax
cmp eax, 0x1c
jb 0xe1aca3
mov eax, 0xed3948
ret

Function at 0xe1acbe
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8280], 1
jne 0xe1ace9
or dword [0xed8280], 1
mov dword [0xed3234], 0xacb0a7a9
mov dword [0xed3238], 0xf0f1aea7
mov byte [0xed323c], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3234]
xor cl, 0xc2
mov byte [eax + 0xed3964], cl
inc eax
cmp eax, 9
jb 0xe1aceb
mov eax, 0xed3964
ret

Function at 0xe1ad06
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed827c], 1
jne 0xe1ad6f
or dword [0xed827c], 1
mov dword [0xed3240], 0x92b6a791
mov dword [0xed3244], 0xa7a1adb0
mov dword [0xed3248], 0xb197b1b1
mov dword [0xed324c], 0xad8fb0a7
mov dword [0xed3250], 0xba87a7a6
mov dword [0xed3254], 0xb6b2a7a1
mov dword [0xed3258], 0x92acadab
mov dword [0xed325c], 0xa1abaead
mov word [0xed3260], 0xc2bb
xor eax, eax
mov cl, byte [eax + 0xed3240]
xor cl, 0xc2
mov byte [eax + 0xed3970], cl
inc eax
cmp eax, 0x22
jb 0xe1ad71
mov eax, 0xed3970
ret

Function at 0xe1ad8c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8278], 1
jne 0xe1adf5
or dword [0xed8278], 1
mov dword [0xed3264], 0x92b6a785
mov dword [0xed3268], 0xa7a1adb0
mov dword [0xed326c], 0xb197b1b1
mov dword [0xed3270], 0xad8fb0a7
mov dword [0xed3274], 0xba87a7a6
mov dword [0xed3278], 0xb6b2a7a1
mov dword [0xed327c], 0x92acadab
mov dword [0xed3280], 0xa1abaead
mov word [0xed3284], 0xc2bb
xor eax, eax
mov cl, byte [eax + 0xed3264]
xor cl, 0xc2
mov byte [eax + 0xed3994], cl
inc eax
cmp eax, 0x22
jb 0xe1adf7
mov eax, 0xed3994
ret

Function at 0xe1ae12
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8274], 1
mov ecx, 0xb1c2
jne 0xe1ae41
or dword [0xed8274], 1
lea eax, [ecx - 0x1f]
mov word [0xed3288], ax
add eax, 0x4d
mov word [0xed328a], ax
mov eax, ecx
mov word [0xed328c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed3288]
add eax, 2
mov word [eax + 0xed39b6], dx
cmp eax, 6
jb 0xe1ae43
mov eax, 0xed39b8
ret

Function at 0xe1ae61
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed826c], 1
jne 0xe1aed1
or dword [0xed826c], 1
mov dword [0xed3298], 0xaeaba384
mov dword [0xed329c], 0xb6e2a6a7
mov dword [0xed32a0], 0xacabe2ad
mov dword [0xed32a4], 0xa3abb6ab
mov dword [0xed32a8], 0xa7b8abae
mov dword [0xed32ac], 0xb4aca7e2
mov dword [0xed32b0], 0xacadb0ab
mov dword [0xed32b4], 0xb6aca7af
mov word [0xed32b8], 0xe2f8
mov byte [0xed32ba], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed3298]
xor cl, 0xc2
mov byte [eax + 0xed39c8], cl
inc eax
cmp eax, 0x23
jb 0xe1aed3
mov eax, 0xed39c8
ret
Function at 0xe1aeee
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8264], 1
mov ecx, 0xb1c2
jne 0xe1af38
or dword [0xed8264], 1
lea eax, [ecx - 0x1b]
mov word [0xed32c4], ax
add eax, 5
mov word [0xed32c6], ax
lea eax, [ecx - 0xc]
mov word [0xed32c8], ax
add eax, 0xfffffffa
mov word [0xed32ca], ax
lea eax, [ecx - 7]
mov word [0xed32cc], ax
mov eax, ecx
mov word [0xed32ce], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xed32c4]
add eax, 2
mov word [eax + 0xed39f2], dx
cmp eax, 0xc
jb 0xe1af3a
mov eax, 0xed39f4
ret

Function at 0xe1af58
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8260], 1
jne 0xe1afa3
or dword [0xed8260], 1
mov dword [0xed32d0], 0xa3aaac97
mov dword [0xed32d4], 0xa7aea6ac
mov dword [0xed32d8], 0xbaa7e2a6
mov dword [0xed32dc], 0xb6b2a7a1
mov dword [0xed32e0], 0xf8acadab
mov word [0xed32e4], 0xc2e2
xor eax, eax
mov cl, byte [eax + 0xed32d0]
xor cl, 0xc2
mov byte [eax + 0xed3a00], cl
inc eax
cmp eax, 0x16
jb 0xe1afa5
mov eax, 0xed3a00
ret

Function at 0xe1afc0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed825c], 1
jne 0xe1b013
or dword [0xed825c], 1
mov dword [0xed32e8], 0xa3aaac97
mov dword [0xed32ec], 0xa7aea6ac
mov dword [0xed32f0], 0xbaa7e2a6
mov dword [0xed32f4], 0xb6b2a7a1
mov dword [0xed32f8], 0xf8acadab
mov dword [0xed32fc], 0xc8b1e7e2
mov byte [0xed3300], 0xc2
xor eax, eax
mov cl, byte [eax + 0xed32e8]
xor cl, 0xc2
mov byte [eax + 0xed3a18], cl
inc eax
cmp eax, 0x19
jb 0xe1b015
mov eax, 0xed3a18
ret

Function at 0xe1b030
Capabilities:
Encode data using xor

Disassembly:
test byte [0xed8258], 1
jne 0xe1b068
or dword [0xed8258], 1
mov dword [0xed3304], 0xa0b7b691
mov dword [0xed3308], 0xabbaa7e2
mov dword [0xed330c], 0xe7eae2b6
mov dword [0xed3310], 0xc2c8eba6
xor eax, eax
mov cl, byte [eax + 0xed3304]
xor cl, 0xc2
mov byte [eax + 0xed3a34], cl
inc eax
cmp eax, 0x10
jb 0xe1b06a
mov eax, 0xed3a34
ret