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

Disassembly:
mov eax, 0x292022
call fcn.00290f48
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 [0x29912c]
test eax, eax
jne 0x249b33
call fcn.00249c8c
mov ecx, dword [ebp + 8]
push eax
call fcn.002269f3
mov eax, dword [ebp + 8]
jmp 0x249c7d
test byte [0x2c64e8], 1
jne 0x249b54
or dword [0x2c64e8], 1
mov dword [0x2c54c0], 0xa2888f8b
mov byte [0x2c54c4], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c54c0]
xor cl, 0x82
mov byte [eax + 0x2c5c94], cl
inc eax
cmp eax, 5
jb 0x249b56
push 0xf
mov esi, 0x2c5c94
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 0x249b81
sub eax, ecx
push eax
push esi
lea ecx, [ebp - 0x48]
call fcn.00224b8d
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.00224c02
lea eax, [ebp - 0x2c]
push eax
lea edi, [ebp - 0x48]
lea eax, [ebp - 0x64]
mov byte [ebp - 4], 1
call fcn.0024efa9
pop ecx
push ebx
push 1
lea ecx, [ebp - 0x2c]
call fcn.00224c23
push ebx
push 1
mov ecx, edi
mov byte [ebp - 4], 4
call fcn.00224c23
push dword [ebp - 0x10]
call dword [0x2990e0]
push ebx
push dword [ebp + 0xc]
lea esi, [ebp - 0xb8]
call fcn.00249fda
pop ecx
pop ecx
push eax
mov byte [ebp - 4], 5
call fcn.00249cf5
push eax
lea eax, [ebp - 0x80]
push eax
call fcn.00226a30
add esp, 0xc
push 0x2b2378
push eax
lea eax, [ebp - 0x9c]
push eax
mov byte [ebp - 4], 6
call fcn.0022d581
add esp, 0xc
push 0xffffffffffffffff
push ebx
push eax
lea esi, [ebp - 0x64]
mov byte [ebp - 4], 7
call fcn.0022b486
push ebx
push 1
lea ecx, [ebp - 0x9c]
call fcn.00224c23
push ebx
push 1
lea ecx, [ebp - 0x80]
call fcn.00224c23
push ebx
push 1
lea ecx, [ebp - 0xb8]
mov byte [ebp - 4], 4
call fcn.00224c23
mov edi, dword [ebp + 8]
mov dword [edi + 0x14], 0xf
mov dword [edi + 0x10], ebx
mov byte [edi], bl
call fcn.00224b43
push ebx
push 1
mov ecx, esi
call fcn.00224c23
mov eax, edi
mov ecx, dword [ebp - 0xc]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
leave
ret

Function at 0x249c8c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64ec], 1
jne 0x249cd8
or dword [0x2c64ec], 1
mov dword [0x2c54a8], 0xe7f0ecd7
mov dword [0x2c54ac], 0xece5ede1
mov dword [0x2c54b0], 0xe6e7f8eb
mov dword [0x2c54b4], 0xf0f0e7a2
mov dword [0x2c54b8], 0xe1a2f0ed
mov dword [0x2c54bc], 0x82e7e6ed
xor eax, eax
mov cl, byte [eax + 0x2c54a8]
xor cl, 0x82
mov byte [eax + 0x2c5c7c], cl
inc eax
cmp eax, 0x18
jb 0x249cda
mov eax, 0x2c5c7c
ret

Function at 0x249cf5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64e4], 1
jne 0x249d33
or dword [0x2c64e4], 1
mov dword [0x2c54c8], 0xf0e7aaa2
mov dword [0x2c54cc], 0xa2f0edf0
mov dword [0x2c54d0], 0xe7e6ede1
mov word [0x2c54d4], 0xa2b8
mov byte [0x2c54d6], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c54c8]
xor cl, 0x82
mov byte [eax + 0x2c5c9c], cl
inc eax
cmp eax, 0xf
jb 0x249d35
mov eax, 0x2c5c9c
ret
Function at 0x249fda
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x48
and dword [ebp - 4], 0
test byte [0x2c64e0], 1
jne 0x24a005
or dword [0x2c64e0], 1
mov dword [0x2c54d8], 0xe6eeeea7
mov byte [0x2c54dc], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c54d8]
xor cl, 0x82
mov byte [eax + 0x2c5cac], cl
inc eax
cmp eax, 5
jb 0x24a007
push dword [ebp + 0xc]
lea eax, [ebp - 0x48]
push dword [ebp + 8]
push 0x2c5cac
push eax
call fcn.0024f002
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.00224c02
mov eax, esi
leave
ret

Function at 0x24a1a9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64dc], 1
jne 0x24a205
or dword [0x2c64dc], 1
mov dword [0x2c54e0], 0xcff6e7c5
mov dword [0x2c54e4], 0xeef7e6ed
mov dword [0x2c54e8], 0xeeebc4e7
mov dword [0x2c54ec], 0xefe3cce7
mov dword [0x2c54f0], 0xe3e4a2e7
mov dword [0x2c54f4], 0xe6e7eeeb
mov word [0x2c54f8], 0xa2b8
mov byte [0x2c54fa], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c54e0]
xor cl, 0x82
mov byte [eax + 0x2c5cb4], cl
inc eax
cmp eax, 0x1b
jb 0x24a207
mov eax, 0x2c5cb4
ret

Function at 0x24a222
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64d8], 1
jne 0x24a27f
or dword [0x2c64d8], 1
mov dword [0x2c54fc], 0xc1f6e7d1
mov dword [0x2c5500], 0xe7f0f0f7
mov dword [0x2c5504], 0xebc6f6ec
mov dword [0x2c5508], 0xf6e1e7f0
mov dword [0x2c550c], 0xa2fbf0ed
mov dword [0x2c5510], 0xeeebe3e4
mov dword [0x2c5514], 0xa2b8e6e7
mov byte [0x2c5518], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c54fc]
xor cl, 0x82
mov byte [eax + 0x2c5cd0], cl
inc eax
cmp eax, 0x1d
jb 0x24a281
mov eax, 0x2c5cd0
ret

Function at 0x24a393
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64d4], 1
jne 0x24a3f0
or dword [0x2c64d4], 1
mov dword [0x2c551c], 0xc1f6e7c5
mov dword [0x2c5520], 0xe7f0f0f7
mov dword [0x2c5524], 0xebc6f6ec
mov dword [0x2c5528], 0xf6e1e7f0
mov dword [0x2c552c], 0xa2fbf0ed
mov dword [0x2c5530], 0xeeebe3e4
mov dword [0x2c5534], 0xa2b8e6e7
mov byte [0x2c5538], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c551c]
xor cl, 0x82
mov byte [eax + 0x2c5cf0], cl
inc eax
cmp eax, 0x1d
jb 0x24a3f2
mov eax, 0x2c5cf0
ret
Function at 0x24a5ab
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64d0], 1
jne 0x24a718
or dword [0x2c64d0], 1
mov eax, 0x87de
mov ecx, eax
mov word [0x2c5540], cx
mov word [0x2c5542], cx
add ecx, 0xfffffff3
mov word [0x2c5544], cx
lea ecx, [eax + 0x18]
mov word [0x2c5546], cx
add ecx, 0xfffffffa
lea edx, [eax + 0xd]
mov word [0x2c5548], cx
push ebx
mov ecx, edx
mov word [0x2c554a], cx
inc ecx
push esi
mov esi, ecx
lea ecx, [eax + 6]
mov word [0x2c554c], si
lea esi, [eax + 7]
mov word [0x2c554e], si
mov word [0x2c555c], cx
add esi, 8
add edx, 3
mov ecx, esi
push edi
lea edi, [eax + 9]
mov word [0x2c555e], cx
mov ecx, eax
mov word [0x2c5554], dx
mov edx, edi
mov word [0x2c5560], cx
mov word [0x2c5562], cx
add ecx, 0xffffffd4
mov word [0x2c5556], dx
mov edx, ecx
mov word [0x2c5564], dx
lea edx, [eax - 0x28]
mov ebx, edx
mov word [0x2c5566], bx
mov ebx, ecx
mov word [0x2c5568], bx
lea ebx, [eax - 0x23]
mov word [0x2c5576], ax
mov word [0x2c556a], bx
mov ebx, ecx
mov ecx, eax
add eax, 0xfffffff4
mov word [0x2c5578], ax
lea eax, [ecx + 8]
mov word [0x2c557e], ax
add eax, 0x11
mov word [0x2c5580], ax
lea eax, [ecx + 3]
mov word [0x2c5582], ax
add eax, 0x15
mov word [0x2c5584], ax
lea eax, [ecx - 0x12]
mov word [0x2c5586], ax
add eax, 0x17
pop edi
mov word [0x2c5588], ax
lea eax, [ecx - 0x5c]
pop esi
mov word [0x2c556c], bx
mov dword [0x2c5550], 0x87eb87c4
mov dword [0x2c5558], 0x87ec87cb
mov word [0x2c556e], dx
mov dword [0x2c5570], 0x87b287c0
mov word [0x2c5574], cx
mov dword [0x2c557a], 0x87ed87f0
mov dword [0x2c558a], 0x87e787ef
mov word [0x2c558e], ax
pop ebx
xor eax, eax
mov ecx, 0x8782
xor cx, word [eax + 0x2c5540]
add eax, 2
mov word [eax + 0x2c5d0e], cx
cmp eax, 0x50
jb 0x24a71a
mov eax, 0x2c5d10
ret

Function at 0x24a73b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64cc], 1
jne 0x24a790
or dword [0x2c64cc], 1
mov dword [0x2c5590], 0xf4a2edcc
mov dword [0x2c5594], 0xebf1f0e7
mov dword [0x2c5598], 0xeba2eced
mov dword [0x2c559c], 0xa2ede4ec
mov dword [0x2c55a0], 0xebe3f4e3
mov dword [0x2c55a4], 0xeee0e3ee
mov word [0x2c55a8], 0x82e7
xor eax, eax
mov cl, byte [eax + 0x2c5590]
xor cl, 0x82
mov byte [eax + 0x2c5d60], cl
inc eax
cmp eax, 0x1a
jb 0x24a792
mov eax, 0x2c5d60
ret

Function at 0x24a97f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64c8], 1
jne 0x24a9d4
or dword [0x2c64c8], 1
mov dword [0x2c55ac], 0xf4a2edcc
mov dword [0x2c55b0], 0xebf1f0e7
mov dword [0x2c55b4], 0xeba2eced
mov dword [0x2c55b8], 0xa2ede4ec
mov dword [0x2c55bc], 0xebe3f4e3
mov dword [0x2c55c0], 0xeee0e3ee
mov word [0x2c55c4], 0x82e7
xor eax, eax
mov cl, byte [eax + 0x2c55ac]
xor cl, 0x82
mov byte [eax + 0x2c5d7c], cl
inc eax
cmp eax, 0x1a
jb 0x24a9d6
mov eax, 0x2c5d7c
ret
Function at 0x24a9f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64c4], 1
jne 0x24aa57
or dword [0x2c64c4], 1
mov dword [0x2c55c8], 0xe3f4eccb
mov dword [0x2c55cc], 0xa2e6ebee
mov dword [0x2c55d0], 0xf1f0e7f4
mov dword [0x2c55d4], 0xa2ecedeb
mov dword [0x2c55d8], 0xede4eceb
mov dword [0x2c55dc], 0xe5ebf1a2
mov dword [0x2c55e0], 0xf7f6e3ec
mov word [0x2c55e4], 0xe7f0
mov byte [0x2c55e6], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c55c8]
xor cl, 0x82
mov byte [eax + 0x2c5d98], cl
inc eax
cmp eax, 0x1f
jb 0x24aa59
mov eax, 0x2c5d98
ret

Function at 0x24ad5e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64c0], 1
jne 0x24adc4
or dword [0x2c64c0], 1
mov dword [0x2c55e8], 0xeeebe3c4
mov dword [0x2c55ec], 0xf6a2e6e7
mov dword [0x2c55f0], 0xe7e5a2ed
mov dword [0x2c55f4], 0xe7f6a2f6
mov dword [0x2c55f8], 0xe4a2f2ef
mov dword [0x2c55fc], 0xe7e6eeed
mov dword [0x2c5600], 0xe3f2a2f0
mov word [0x2c5604], 0xeaf6
mov byte [0x2c5606], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c55e8]
xor cl, 0x82
mov byte [eax + 0x2c5db8], cl
inc eax
cmp eax, 0x1f
jb 0x24adc6
mov eax, 0x2c5db8
ret

Function at 0x24af36
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64bc], 1
jne 0x24af88
or dword [0x2c64bc], 1
mov dword [0x2c5608], 0xc4f6e7c5
mov dword [0x2c560c], 0xe7e6eeed
mov dword [0x2c5610], 0xf6e3d2f0
mov dword [0x2c5614], 0xe3e4a2ea
mov dword [0x2c5618], 0xe6e7eeeb
mov word [0x2c561c], 0xa2b8
mov byte [0x2c561e], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5608]
xor cl, 0x82
mov byte [eax + 0x2c5dd8], cl
inc eax
cmp eax, 0x17
jb 0x24af8a
mov eax, 0x2c5dd8
ret

Function at 0x24b252
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64b8], 1
mov edx, 0x8782
jne 0x24b2e9
or dword [0x2c64b8], 1
lea ecx, [edx + 0x25]
mov eax, ecx
mov word [0x2c5620], ax
add eax, 0x2b
mov word [0x2c5622], ax
push esi
lea eax, [edx + 0x6e]
mov esi, eax
add eax, 0xfffffff3
mov word [0x2c562c], ax
lea eax, [edx + 0x6d]
mov word [0x2c562e], ax
add eax, 0xffffffe6
mov word [0x2c5630], ax
lea eax, [edx + 0x32]
mov word [0x2c5624], si
add esi, 0xfffffffd
mov word [0x2c5632], ax
add eax, 2
mov word [0x2c5634], ax
lea eax, [edx + 0x2f]
mov word [0x2c5636], ax
mov eax, edx
mov word [0x2c5626], si
mov dword [0x2c5628], 0x87f087e5
mov dword [0x2c5638], 0x87a787b0
mov word [0x2c563c], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x2c5620]
add eax, 2
mov word [eax + 0x2c5dee], cx
cmp eax, 0x1e
jb 0x24b2eb
mov eax, 0x2c5df0
ret

Function at 0x24b309
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64b4], 1
mov ecx, 0x8782
jne 0x24b34a
or dword [0x2c64b4], 1
lea eax, [ecx + 0x77]
mov word [0x2c5640], ax
add eax, 0xfffffff9
mov word [0x2c5642], ax
lea eax, [ecx + 0x62]
mov word [0x2c5644], ax
add eax, 0x1b
mov word [0x2c5646], ax
mov eax, ecx
mov word [0x2c5648], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c5640]
add eax, 2
mov word [eax + 0x2c5e0e], dx
cmp eax, 0xa
jb 0x24b34c
mov eax, 0x2c5e10
ret
Function at 0x24b36a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64b0], 1
mov ecx, 0x8782
jne 0x24b3bd
or dword [0x2c64b0], 1
lea eax, [ecx + 0x77]
mov word [0x2c564c], ax
add eax, 0xfffffff9
mov word [0x2c564e], ax
lea eax, [ecx + 0x62]
mov word [0x2c5650], ax
add eax, 0xffffffcd
mov word [0x2c5652], ax
lea eax, [ecx + 0x2e]
mov word [0x2c5654], ax
add eax, 0x4f
mov word [0x2c5656], ax
mov eax, ecx
mov word [0x2c5658], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c564c]
add eax, 2
mov word [eax + 0x2c5e1a], dx
cmp eax, 0xe
jb 0x24b3bf
mov eax, 0x2c5e1c
ret

Function at 0x24b3dd
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64ac], 1
mov ecx, 0x8782
jne 0x24b430
or dword [0x2c64ac], 1
lea eax, [ecx + 0x77]
mov word [0x2c565c], ax
add eax, 0xfffffff9
mov word [0x2c565e], ax
lea eax, [ecx + 0x62]
mov word [0x2c5660], ax
add eax, 0xffffffd0
mov word [0x2c5662], ax
lea eax, [ecx + 0x34]
mov word [0x2c5664], ax
add eax, 0x49
mov word [0x2c5666], ax
mov eax, ecx
mov word [0x2c5668], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c565c]
add eax, 2
mov word [eax + 0x2c5e2a], dx
cmp eax, 0xe
jb 0x24b432
mov eax, 0x2c5e2c
ret

Function at 0x24b450
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64a8], 1
mov ecx, 0x8782
jne 0x24b491
or dword [0x2c64a8], 1
lea eax, [ecx + 0x77]
mov word [0x2c566c], ax
add eax, 0xfffffff9
mov word [0x2c566e], ax
lea eax, [ecx + 0x62]
mov word [0x2c5670], ax
add eax, 0x1b
mov word [0x2c5672], ax
mov eax, ecx
mov word [0x2c5674], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c566c]
add eax, 2
mov word [eax + 0x2c5e3a], dx
cmp eax, 0xa
jb 0x24b493
mov eax, 0x2c5e3c
ret

Function at 0x24b4b1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64a4], 1
mov ecx, 0x8782
jne 0x24b504
or dword [0x2c64a4], 1
lea eax, [ecx + 0x77]
mov word [0x2c5678], ax
add eax, 0xfffffff9
mov word [0x2c567a], ax
lea eax, [ecx + 0x62]
mov word [0x2c567c], ax
add eax, 0xffffffcd
mov word [0x2c567e], ax
lea eax, [ecx + 0x2e]
mov word [0x2c5680], ax
add eax, 0x4f
mov word [0x2c5682], ax
mov eax, ecx
mov word [0x2c5684], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c5678]
add eax, 2
mov word [eax + 0x2c5e46], dx
cmp eax, 0xe
jb 0x24b506
mov eax, 0x2c5e48
ret
Function at 0x24b5fe
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c64a0], 1
mov ecx, 0x8782
jne 0x24b843
or dword [0x2c64a0], 1
lea eax, [ecx + 0x30]
mov word [0x2c5690], ax
inc eax
mov word [0x2c5692], ax
lea eax, [ecx + 0x2e]
mov word [0x2c5694], ax
inc eax
mov word [0x2c5696], ax
lea eax, [ecx + 0x34]
mov word [0x2c5698], ax
inc eax
mov word [0x2c569a], ax
lea eax, [ecx + 0x32]
mov word [0x2c569c], ax
inc eax
mov word [0x2c569e], ax
lea eax, [ecx + 0x38]
mov word [0x2c56a0], ax
inc eax
mov word [0x2c56a2], ax
lea eax, [ecx + 0x41]
mov word [0x2c56a4], ax
add eax, 0xfffffffd
mov word [0x2c56a6], ax
lea eax, [ecx + 0x3f]
mov word [0x2c56a8], ax
add eax, 5
mov word [0x2c56aa], ax
lea eax, [ecx + 0x45]
mov word [0x2c56ac], ax
add eax, 0xfffffffd
mov word [0x2c56ae], ax
lea eax, [ecx + 0x43]
mov word [0x2c56b0], ax
add eax, 5
mov word [0x2c56b2], ax
lea eax, [ecx + 0x49]
mov word [0x2c56b4], ax
add eax, 0xfffffffd
mov word [0x2c56b6], ax
lea eax, [ecx + 0x47]
mov word [0x2c56b8], ax
add eax, 5
mov word [0x2c56ba], ax
lea eax, [ecx + 0x4d]
mov word [0x2c56bc], ax
add eax, 0xfffffffd
mov word [0x2c56be], ax
lea eax, [ecx + 0x4b]
mov word [0x2c56c0], ax
add eax, 5
mov word [0x2c56c2], ax
lea eax, [ecx + 0x51]
mov word [0x2c56c4], ax
add eax, 0xfffffffd
mov word [0x2c56c6], ax
lea eax, [ecx + 0x4f]
mov word [0x2c56c8], ax
add eax, 5
mov word [0x2c56ca], ax
lea eax, [ecx + 0x55]
mov word [0x2c56cc], ax
add eax, 0xfffffffd
mov word [0x2c56ce], ax
lea eax, [ecx + 0x53]
mov word [0x2c56d0], ax
add eax, 5
mov word [0x2c56d2], ax
lea eax, [ecx + 0x59]
mov word [0x2c56d4], ax
add eax, 0xfffffffd
mov word [0x2c56d6], ax
lea eax, [ecx + 0x61]
mov word [0x2c56d8], ax
add eax, 0xfffffffd
mov word [0x2c56da], ax
lea eax, [ecx + 0x5f]
mov word [0x2c56dc], ax
add eax, 5
mov word [0x2c56de], ax
lea eax, [ecx + 0x65]
mov word [0x2c56e0], ax
add eax, 0xfffffffd
mov word [0x2c56e2], ax
lea eax, [ecx + 0x63]
mov word [0x2c56e4], ax
add eax, 5
mov word [0x2c56e6], ax
lea eax, [ecx + 0x69]
mov word [0x2c56e8], ax
add eax, 0xfffffffd
mov word [0x2c56ea], ax
lea eax, [ecx + 0x67]
mov word [0x2c56ec], ax
add eax, 5
mov word [0x2c56ee], ax
lea eax, [ecx + 0x6d]
mov word [0x2c56f0], ax
add eax, 0xfffffffd
mov word [0x2c56f2], ax
lea eax, [ecx + 0x6b]
mov word [0x2c56f4], ax
add eax, 5
mov word [0x2c56f6], ax
lea eax, [ecx + 0x71]
mov word [0x2c56f8], ax
add eax, 0xfffffffd
mov word [0x2c56fa], ax
lea eax, [ecx + 0x6f]
mov word [0x2c56fc], ax
add eax, 5
mov word [0x2c56fe], ax
lea eax, [ecx + 0x75]
mov word [0x2c5700], ax
add eax, 0xfffffffd
mov word [0x2c5702], ax
lea eax, [ecx + 0x73]
mov word [0x2c5704], ax
add eax, 5
mov word [0x2c5706], ax
lea eax, [ecx + 0x79]
mov word [0x2c5708], ax
add eax, 0xfffffffd
mov word [0x2c570a], ax
mov eax, ecx
mov word [0x2c570c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x2c5690]
add eax, 2
mov word [eax + 0x2c5e56], dx
cmp eax, 0x7e
jb 0x24b845
mov eax, 0x2c5e58
ret
Function at 0x24bf15
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c649c], 1
jne 0x24bf7c
or dword [0x2c649c], 1
mov dword [0x2c5710], 0xf8ddf8ef
mov dword [0x2c5714], 0xf0ddf2eb
mov dword [0x2c5718], 0xe7e6e3e7
mov dword [0x2c571c], 0xecebddf0
mov dword [0x2c5720], 0xe4ddf6eb
mov dword [0x2c5724], 0xaae7eeeb
mov dword [0x2c5728], 0xe3e4a2ab
mov dword [0x2c572c], 0xe6e7eeeb
mov byte [0x2c5730], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5710]
xor cl, 0x82
mov byte [eax + 0x2c5ed8], cl
inc eax
cmp eax, 0x21
jb 0x24bf7e
mov eax, 0x2c5ed8
ret

Function at 0x24bf99
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6498], 1
jne 0x24c000
or dword [0x2c6498], 1
mov dword [0x2c5734], 0xf8ddf8ef
mov dword [0x2c5738], 0xf0ddf2eb
mov dword [0x2c573c], 0xe7e6e3e7
mov dword [0x2c5740], 0xebe4ddf0
mov dword [0x2c5744], 0xf1dde7ee
mov dword [0x2c5748], 0xaaf6e3f6
mov dword [0x2c574c], 0xe3e4a2ab
mov dword [0x2c5750], 0xe6e7eeeb
mov byte [0x2c5754], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5734]
xor cl, 0x82
mov byte [eax + 0x2c5efc], cl
inc eax
cmp eax, 0x21
jb 0x24c002
mov eax, 0x2c5efc
ret

Function at 0x24c01d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6494], 1
jne 0x24c09b
or dword [0x2c6494], 1
mov dword [0x2c5758], 0xf8ddf8ef
mov dword [0x2c575c], 0xf0ddf2eb
mov dword [0x2c5760], 0xe7e6e3e7
mov dword [0x2c5764], 0xfae7ddf0
mov dword [0x2c5768], 0xe1e3f0f6
mov dword [0x2c576c], 0xebe4ddf6
mov dword [0x2c5770], 0xf6dde7ee
mov dword [0x2c5774], 0xe7eadded
mov dword [0x2c5778], 0xabaaf2e3
mov dword [0x2c577c], 0xebe3e4a2
mov dword [0x2c5780], 0x82e6e7ee
xor eax, eax
mov cl, byte [eax + 0x2c5758]
xor cl, 0x82
mov byte [eax + 0x2c5f20], cl
inc eax
cmp eax, 0x2c
jb 0x24c09d
mov eax, 0x2c5f20
ret

Function at 0x24c0b8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6490], 1
jne 0x24c122
or dword [0x2c6490], 1
mov dword [0x2c5784], 0xeeebe3c4
mov dword [0x2c5788], 0xf6a2e6e7
mov dword [0x2c578c], 0xf0e1a2ed
mov dword [0x2c5790], 0xe7f6e3e7
mov dword [0x2c5794], 0xf1e7e6a2
mov dword [0x2c5798], 0xe3ecebf6
mov dword [0x2c579c], 0xecedebf6
mov dword [0x2c57a0], 0xf6e3f2a2
mov dword [0x2c57a4], 0x82a2b8ea
xor eax, eax
mov cl, byte [eax + 0x2c5784]
xor cl, 0x82
mov byte [eax + 0x2c5f4c], cl
inc eax
cmp eax, 0x24
jb 0x24c124
mov eax, 0x2c5f4c
ret

Function at 0x24c13f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c648c], 1
jne 0x24c1a5
or dword [0x2c648c], 1
mov dword [0x2c57a8], 0xeeebe3c4
mov dword [0x2c57ac], 0xf6a2e6e7
mov dword [0x2c57b0], 0xf0e1a2ed
mov dword [0x2c57b4], 0xe7f6e3e7
mov dword [0x2c57b8], 0xf6f7eda2
mov dword [0x2c57bc], 0xa2f6f7f2
mov dword [0x2c57c0], 0xe7eeebe4
mov word [0x2c57c4], 0xa2b8
mov byte [0x2c57c6], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c57a8]
xor cl, 0x82
mov byte [eax + 0x2c5f70], cl
inc eax
cmp eax, 0x1f
jb 0x24c1a7
mov eax, 0x2c5f70
ret
Function at 0x24c1dc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6488], 1
jne 0x24c21a
or dword [0x2c6488], 1
mov dword [0x2c57c8], 0xedd5f1cb
mov dword [0x2c57cc], 0xd2b6b4f5
mov dword [0x2c57d0], 0xe7e1edf0
mov word [0x2c57d4], 0xf1f1
mov byte [0x2c57d6], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c57c8]
xor cl, 0x82
mov byte [eax + 0x2c5f90], cl
inc eax
cmp eax, 0xf
jb 0x24c21c
mov eax, 0x2c5f90
ret

Function at 0x24c332
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6484], 1
jne 0x24c39b
or dword [0x2c6484], 1
mov dword [0x2c57d8], 0xedeeeec3
mov dword [0x2c57dc], 0xe7f6e3e1
mov dword [0x2c57e0], 0xcbe6ecc3
mov dword [0x2c57e4], 0xebf6ebec
mov dword [0x2c57e8], 0xf8ebeee3
mov dword [0x2c57ec], 0xe6ebd1e7
mov dword [0x2c57f0], 0xebe3e4a2
mov dword [0x2c57f4], 0xb8e6e7ee
mov word [0x2c57f8], 0x82a2
xor eax, eax
mov cl, byte [eax + 0x2c57d8]
xor cl, 0x82
mov byte [eax + 0x2c5fa0], cl
inc eax
cmp eax, 0x22
jb 0x24c39d
mov eax, 0x2c5fa0
ret

Function at 0x24c3b8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6480], 1
jne 0x24c417
or dword [0x2c6480], 1
mov dword [0x2c57fc], 0xe1e7eac1
mov dword [0x2c5800], 0xe9edd6e9
mov dword [0x2c5804], 0xe7cfece7
mov dword [0x2c5808], 0xf0e7e0ef
mov dword [0x2c580c], 0xf2ebeaf1
mov dword [0x2c5810], 0xebe3e4a2
mov dword [0x2c5814], 0xb8e6e7ee
mov word [0x2c5818], 0x82a2
xor eax, eax
mov cl, byte [eax + 0x2c57fc]
xor cl, 0x82
mov byte [eax + 0x2c5fc4], cl
inc eax
cmp eax, 0x1e
jb 0x24c419
mov eax, 0x2c5fc4
ret

Function at 0x24c67d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6474], 1
jne 0x24c702
or dword [0x2c6474], 1
mov dword [0x2c5830], 0xecece3c1
mov dword [0x2c5834], 0xf3a2f6ed
mov dword [0x2c5838], 0xfbf0e7f7
mov dword [0x2c583c], 0xb4a2e3a2
mov dword [0x2c5840], 0xebe0a2b6
mov dword [0x2c5844], 0xebf4a2f6
mov dword [0x2c5848], 0xeda2f5e7
mov dword [0x2c584c], 0xb0b1a2ec
mov dword [0x2c5850], 0xf6ebe0a2
mov dword [0x2c5854], 0xecebf5a2
mov dword [0x2c5858], 0xf1f5ede6
mov byte [0x2c585c], 0x82
xor eax, eax
mov cl, byte [eax + 0x2c5830]
xor cl, 0x82
mov byte [eax + 0x2c5ff8], cl
inc eax
cmp eax, 0x2d
jb 0x24c704
mov eax, 0x2c5ff8
ret

Function at 0x24c71f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x2c6470], 1
jne 0x24c7cf
or dword [0x2c6470], 1
push ebx
push esi
mov eax, 0x87ca
mov word [0x2c5860], ax
dec eax
mov word [0x2c5862], ax
push edi
mov edi, 0x87c7
mov eax, edi
mov word [0x2c5864], ax
add eax, 0x14
mov word [0x2c5866], ax
lea esi, [edi + 0x16]
mov eax, esi
mov word [0x2c5868], ax
lea edx, [edi + 7]
mov eax, edx
mov word [0x2c586a], ax
dec eax
mov word [0x2c586c], ax
lea ecx, [edi - 6]
mov eax, ecx
mov word [0x2c586e], ax
add eax, 2
mov ebx, eax
lea eax, [edi + 4]
pop edi
mov word [0x2c587e], ax
add eax, 0xffffffb7
pop esi
mov word [0x2c5870], bx
mov dword [0x2c5872], 0x87dd87ce
mov dword [0x2c5876], 0x87c387cf
mov dword [0x2c587a], 0x87ca87c1
mov dword [0x2c5880], 0x87c787cc
mov word [0x2c5884], ax
pop ebx
xor eax, eax
mov ecx, 0x8782
xor cx, word [eax + 0x2c5860]
add eax, 2
mov word [eax + 0x2c6026], cx
cmp eax, 0x26
jb 0x24c7d1
mov eax, 0x2c6028
ret