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

Disassembly:
test byte [0xf826a8], 1
mov ecx, 0x794b
jne 0xeec615
or dword [0xf826a8], 1
lea eax, [ecx + 0x30]
mov word [0xf81898], ax
dec eax
mov word [0xf8189a], ax
lea eax, [ecx + 0x2e]
mov word [0xf8189c], ax
dec eax
mov word [0xf8189e], ax
lea eax, [ecx + 0x34]
mov word [0xf818a0], ax
dec eax
mov word [0xf818a2], ax
lea eax, [ecx + 0x32]
mov word [0xf818a4], ax
dec eax
mov word [0xf818a6], ax
lea eax, [ecx + 0x28]
mov word [0xf818a8], ax
dec eax
mov word [0xf818aa], ax
lea eax, [ecx - 0x41]
mov word [0xf818ac], ax
dec eax
mov word [0xf818ae], ax
lea eax, [ecx - 0x43]
mov word [0xf818b0], ax
add eax, 7
mov word [0xf818b2], ax
lea eax, [ecx - 0x3d]
mov word [0xf818b4], ax
dec eax
mov word [0xf818b6], ax
lea eax, [ecx - 0x3f]
mov word [0xf818b8], ax
add eax, 0xfffffff7
mov word [0xf818ba], ax
lea eax, [ecx - 0x49]
mov word [0xf818bc], ax
dec eax
mov word [0xf818be], ax
lea eax, [ecx - 0x4b]
mov word [0xf818c0], ax
add eax, 7
mov word [0xf818c2], ax
lea eax, [ecx - 0x45]
mov word [0xf818c4], ax
dec eax
mov word [0xf818c6], ax
lea eax, [ecx - 0x47]
mov word [0xf818c8], ax
add eax, 0x17
mov word [0xf818ca], ax
lea eax, [ecx - 0x31]
mov word [0xf818cc], ax
dec eax
mov word [0xf818ce], ax
lea eax, [ecx - 0x33]
mov word [0xf818d0], ax
add eax, 7
mov word [0xf818d2], ax
lea eax, [ecx - 0x2d]
mov word [0xf818d4], ax
dec eax
mov word [0xf818d6], ax
lea eax, [ecx - 0x2f]
mov word [0xf818d8], ax
add eax, 0xfffffff7
mov word [0xf818da], ax
lea eax, [ecx - 0x39]
mov word [0xf818dc], ax
dec eax
mov word [0xf818de], ax
lea eax, [ecx - 0x21]
mov word [0xf818e0], ax
dec eax
mov word [0xf818e2], ax
lea eax, [ecx - 0x23]
mov word [0xf818e4], ax
add eax, 7
mov word [0xf818e6], ax
lea eax, [ecx - 0x1d]
mov word [0xf818e8], ax
dec eax
mov word [0xf818ea], ax
lea eax, [ecx - 0x1f]
mov word [0xf818ec], ax
add eax, 0xfffffff7
mov word [0xf818ee], ax
lea eax, [ecx - 0x29]
mov word [0xf818f0], ax
dec eax
mov word [0xf818f2], ax
lea eax, [ecx - 0x2b]
mov word [0xf818f4], ax
add eax, 7
mov word [0xf818f6], ax
lea eax, [ecx - 0x25]
mov word [0xf818f8], ax
dec eax
mov word [0xf818fa], ax
lea eax, [ecx - 0x27]
mov word [0xf818fc], ax
add eax, 0x17
mov word [0xf818fe], ax
lea eax, [ecx - 0x11]
mov word [0xf81900], ax
dec eax
mov word [0xf81902], ax
lea eax, [ecx - 0x13]
mov word [0xf81904], ax
add eax, 7
mov word [0xf81906], ax
lea eax, [ecx - 0xd]
mov word [0xf81908], ax
dec eax
mov word [0xf8190a], ax
lea eax, [ecx - 0xf]
mov word [0xf8190c], ax
add eax, 0xfffffff7
mov word [0xf8190e], ax
lea eax, [ecx - 0x19]
mov word [0xf81910], ax
dec eax
mov word [0xf81912], ax
mov eax, ecx
mov word [0xf81914], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xf81898]
add eax, 2
mov word [eax + 0xf8205e], dx
cmp eax, 0x7e
jb 0xeec617
mov eax, 0xf82060
ret
Function at 0xeecce7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf826a4], 1
jne 0xeecd4e
or dword [0xf826a4], 1
mov dword [0xf81918], 0x31143126
mov dword [0xf8191c], 0x39143b22
mov dword [0xf81920], 0x2e2f2a2e
mov dword [0xf81924], 0x25221439
mov dword [0xf81928], 0x2d143f22
mov dword [0xf8192c], 0x632e2722
mov dword [0xf81930], 0x2a2d6b62
mov dword [0xf81934], 0x2f2e2722
mov byte [0xf81938], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81918]
xor cl, 0x4b
mov byte [eax + 0xf820e0], cl
inc eax
cmp eax, 0x21
jb 0xeecd50
mov eax, 0xf820e0
ret

Function at 0xeecd6b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf826a0], 1
jne 0xeecdd2
or dword [0xf826a0], 1
mov dword [0xf8193c], 0x31143126
mov dword [0xf81940], 0x39143b22
mov dword [0xf81944], 0x2e2f2a2e
mov dword [0xf81948], 0x222d1439
mov dword [0xf8194c], 0x38142e27
mov dword [0xf81950], 0x633f2a3f
mov dword [0xf81954], 0x2a2d6b62
mov dword [0xf81958], 0x2f2e2722
mov byte [0xf8195c], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf8193c]
xor cl, 0x4b
mov byte [eax + 0xf82104], cl
inc eax
cmp eax, 0x21
jb 0xeecdd4
mov eax, 0xf82104
ret

Function at 0xeecdef
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8269c], 1
jne 0xeece6d
or dword [0xf8269c], 1
mov dword [0xf81960], 0x31143126
mov dword [0xf81964], 0x39143b22
mov dword [0xf81968], 0x2e2f2a2e
mov dword [0xf8196c], 0x332e1439
mov dword [0xf81970], 0x282a393f
mov dword [0xf81974], 0x222d143f
mov dword [0xf81978], 0x3f142e27
mov dword [0xf8197c], 0x2e231424
mov dword [0xf81980], 0x62633b2a
mov dword [0xf81984], 0x222a2d6b
mov dword [0xf81988], 0x4b2f2e27
xor eax, eax
mov cl, byte [eax + 0xf81960]
xor cl, 0x4b
mov byte [eax + 0xf82128], cl
inc eax
cmp eax, 0x2c
jb 0xeece6f
mov eax, 0xf82128
ret

Function at 0xeece8a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82698], 1
jne 0xeecef4
or dword [0xf82698], 1
mov dword [0xf8198c], 0x27222a0d
mov dword [0xf81990], 0x3f6b2f2e
mov dword [0xf81994], 0x39286b24
mov dword [0xf81998], 0x2e3f2a2e
mov dword [0xf8199c], 0x382e2f6b
mov dword [0xf819a0], 0x2a25223f
mov dword [0xf819a4], 0x2524223f
mov dword [0xf819a8], 0x3f2a3b6b
mov dword [0xf819ac], 0x4b6b7123
xor eax, eax
mov cl, byte [eax + 0xf8198c]
xor cl, 0x4b
mov byte [eax + 0xf82154], cl
inc eax
cmp eax, 0x24
jb 0xeecef6
mov eax, 0xf82154
ret

Function at 0xeecf11
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82694], 1
jne 0xeecf77
or dword [0xf82694], 1
mov dword [0xf819b0], 0x27222a0d
mov dword [0xf819b4], 0x3f6b2f2e
mov dword [0xf819b8], 0x39286b24
mov dword [0xf819bc], 0x2e3f2a2e
mov dword [0xf819c0], 0x3f3e246b
mov dword [0xf819c4], 0x6b3f3e3b
mov dword [0xf819c8], 0x2e27222d
mov word [0xf819cc], 0x6b71
mov byte [0xf819ce], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf819b0]
xor cl, 0x4b
mov byte [eax + 0xf82178], cl
inc eax
cmp eax, 0x1f
jb 0xeecf79
mov eax, 0xf82178
ret
Function at 0xeecfae
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82690], 1
jne 0xeecfec
or dword [0xf82690], 1
mov dword [0xf819d0], 0x241c3802
mov dword [0xf819d4], 0x1b7f7d3c
mov dword [0xf819d8], 0x2e282439
mov word [0xf819dc], 0x3838
mov byte [0xf819de], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf819d0]
xor cl, 0x4b
mov byte [eax + 0xf82198], cl
inc eax
cmp eax, 0xf
jb 0xeecfee
mov eax, 0xf82198
ret

Function at 0xeed104
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8268c], 1
jne 0xeed16d
or dword [0xf8268c], 1
mov dword [0xf819e0], 0x2427270a
mov dword [0xf819e4], 0x2e3f2a28
mov dword [0xf819e8], 0x22f250a
mov dword [0xf819ec], 0x223f2225
mov dword [0xf819f0], 0x3122272a
mov dword [0xf819f4], 0x2f22182e
mov dword [0xf819f8], 0x222a2d6b
mov dword [0xf819fc], 0x712f2e27
mov word [0xf81a00], 0x4b6b
xor eax, eax
mov cl, byte [eax + 0xf819e0]
xor cl, 0x4b
mov byte [eax + 0xf821a8], cl
inc eax
cmp eax, 0x22
jb 0xeed16f
mov eax, 0xf821a8
ret

Function at 0xeed18a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82688], 1
jne 0xeed1e9
or dword [0xf82688], 1
mov dword [0xf81a04], 0x282e2308
mov dword [0xf81a08], 0x20241f20
mov dword [0xf81a0c], 0x2e06252e
mov dword [0xf81a10], 0x392e2926
mov dword [0xf81a14], 0x3b222338
mov dword [0xf81a18], 0x222a2d6b
mov dword [0xf81a1c], 0x712f2e27
mov word [0xf81a20], 0x4b6b
xor eax, eax
mov cl, byte [eax + 0xf81a04]
xor cl, 0x4b
mov byte [eax + 0xf821cc], cl
inc eax
cmp eax, 0x1e
jb 0xeed1eb
mov eax, 0xf821cc
ret

Function at 0xeed44f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8267c], 1
jne 0xeed4d4
or dword [0xf8267c], 1
mov dword [0xf81a38], 0x25252a08
mov dword [0xf81a3c], 0x3a6b3f24
mov dword [0xf81a40], 0x32392e3e
mov dword [0xf81a44], 0x7d6b2a6b
mov dword [0xf81a48], 0x22296b7f
mov dword [0xf81a4c], 0x223d6b3f
mov dword [0xf81a50], 0x246b3c2e
mov dword [0xf81a54], 0x79786b25
mov dword [0xf81a58], 0x3f22296b
mov dword [0xf81a5c], 0x25223c6b
mov dword [0xf81a60], 0x383c242f
mov byte [0xf81a64], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81a38]
xor cl, 0x4b
mov byte [eax + 0xf82200], cl
inc eax
cmp eax, 0x2d
jb 0xeed4d6
mov eax, 0xf82200
ret

Function at 0xeed4f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82678], 1
jne 0xeed5a5
push ebx
push esi
or dword [0xf82678], 1
mov eax, 0x7903
mov word [0xf81a68], ax
add eax, 0xfffffffd
mov word [0xf81a6a], ax
push edi
mov edi, 0x790e
mov eax, edi
mov word [0xf81a6c], ax
add eax, 4
mov word [0xf81a6e], ax
lea esi, [edi + 6]
mov eax, esi
mov word [0xf81a70], ax
lea edx, [edi - 7]
mov eax, edx
mov word [0xf81a72], ax
add eax, 0xfffffffd
mov word [0xf81a74], ax
lea ecx, [edi - 6]
mov eax, ecx
mov word [0xf81a76], ax
add eax, 2
mov ebx, eax
lea eax, [edi - 0xc]
pop edi
mov word [0xf81a86], ax
add eax, 0x49
pop esi
mov word [0xf81a78], bx
mov dword [0xf81a7a], 0x79147907
mov dword [0xf81a7e], 0x790a7906
mov dword [0xf81a82], 0x79037908
mov dword [0xf81a88], 0x790e7905
mov word [0xf81a8c], ax
pop ebx
xor eax, eax
mov ecx, 0x794b
xor cx, word [eax + 0xf81a68]
add eax, 2
mov word [eax + 0xf8222e], cx
cmp eax, 0x26
jb 0xeed5a7
mov eax, 0xf82230
ret
Function at 0xeed5c8
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82674], 1
jne 0xeed679
or dword [0xf82674], 1
mov eax, 0x7903
mov word [0xf81a90], ax
add eax, 0xfffffffd
mov word [0xf81a92], ax
mov ecx, 0x790e
push ebx
mov eax, ecx
mov word [0xf81a94], ax
add eax, 4
push esi
mov word [0xf81a96], ax
lea esi, [ecx + 6]
mov eax, esi
mov word [0xf81a98], ax
add eax, 0xfffffff4
mov word [0xf81a9a], ax
lea edx, [ecx + 0x10]
mov eax, edx
mov word [0xf81a9c], ax
add eax, 0xfffffffb
mov ebx, eax
mov word [0xf81a9e], bx
mov word [0xf81aa0], bx
mov ebx, ecx
mov word [0xf81aa2], bx
add ebx, 0xfffffff7
mov word [0xf81ab0], ax
lea eax, [ecx + 0x3d]
pop esi
mov word [0xf81aa4], bx
mov dword [0xf81aa6], 0x7914791f
mov word [0xf81aaa], dx
mov dword [0xf81aac], 0x790e7918
mov word [0xf81ab2], ax
pop ebx
xor eax, eax
mov ecx, 0x794b
xor cx, word [eax + 0xf81a90]
add eax, 2
mov word [eax + 0xf82256], cx
cmp eax, 0x24
jb 0xeed67b
mov eax, 0xf82258
ret

Function at 0xeed69c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82670], 1
mov edx, 0x794b
jne 0xeed710
or dword [0xf82670], 1
lea eax, [edx - 0x48]
mov word [0xf81ab4], ax
add eax, 0xfffffffd
mov word [0xf81ab6], ax
lea ecx, [edx - 0x3d]
mov eax, ecx
mov word [0xf81ab8], ax
add eax, 4
mov word [0xf81aba], ax
lea eax, [edx - 0x37]
mov word [0xf81abc], ax
add eax, 0xa
mov word [0xf81abe], ax
lea eax, [edx - 0x33]
push esi
mov esi, eax
mov eax, edx
mov word [0xf81ac0], si
mov word [0xf81ac2], cx
mov dword [0xf81ac4], 0x79187919
mov word [0xf81ac8], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xf81ab4]
add eax, 2
mov word [eax + 0xf8227a], cx
cmp eax, 0x16
jb 0xeed712
mov eax, 0xf8227c
ret

Function at 0xeed730
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8266c], 1
jne 0xeed7f2
push ebx
mov eax, 0x7903
mov word [0xf81acc], ax
add eax, 0xfffffffd
mov word [0xf81ace], ax
push esi
mov esi, 0x790e
or dword [0xf8266c], 1
mov eax, esi
mov word [0xf81ad0], ax
add eax, 4
mov word [0xf81ad2], ax
lea edx, [esi + 6]
lea ecx, [esi - 6]
mov eax, edx
mov word [0xf81ad4], ax
mov eax, ecx
mov word [0xf81ad6], ax
add eax, 0x16
mov word [0xf81ad8], ax
lea eax, [esi + 0xb]
mov ebx, eax
add eax, 0xffffffec
mov esi, eax
lea eax, [edx - 7]
mov word [0xf81aec], ax
add eax, 0xfffffff5
mov word [0xf81aee], ax
lea eax, [edx - 8]
mov word [0xf81ae0], si
mov word [0xf81af0], ax
add eax, 0x3f
pop esi
mov word [0xf81ada], bx
mov dword [0xf81adc], 0x790e7919
mov dword [0xf81ae2], 0x7914791f
mov word [0xf81ae6], cx
mov dword [0xf81ae8], 0x79057904
mov word [0xf81af2], ax
pop ebx
xor eax, eax
mov ecx, 0x794b
xor cx, word [eax + 0xf81acc]
add eax, 2
mov word [eax + 0xf82292], cx
cmp eax, 0x28
jb 0xeed7f4
mov eax, 0xf82294
ret
Function at 0xeed815
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82668], 1
jne 0xeed8c6
mov eax, 0x7903
mov word [0xf81af4], ax
add eax, 0xfffffffd
mov word [0xf81af6], ax
or dword [0xf82668], 1
mov edx, 0x790e
mov eax, edx
mov word [0xf81af8], ax
add eax, 4
mov word [0xf81afa], ax
lea ecx, [edx + 6]
mov eax, ecx
mov word [0xf81afc], ax
add eax, 0xfffffff4
mov word [0xf81afe], ax
lea eax, [edx - 7]
mov word [0xf81b00], ax
add eax, 3
mov word [0xf81b02], ax
lea eax, [edx + 0xa]
push edi
mov edi, eax
add eax, 0xffffffec
mov ecx, eax
mov word [0xf81b12], ax
lea eax, [edx + 0x11]
mov word [0xf81b14], ax
add eax, 0x2c
mov word [0xf81b04], di
mov word [0xf81b06], di
mov dword [0xf81b08], 0x7918790e
mov dword [0xf81b0c], 0x79197914
mov word [0xf81b10], cx
mov word [0xf81b16], ax
pop edi
xor eax, eax
mov ecx, 0x794b
xor cx, word [eax + 0xf81af4]
add eax, 2
mov word [eax + 0xf822ba], cx
cmp eax, 0x24
jb 0xeed8c8
mov eax, 0xf822bc
ret

Function at 0xeedc94
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82650], 1
jne 0xeedceb
or dword [0xf82650], 1
mov dword [0xf81ba0], 0x82c2e19
mov dword [0xf81ba4], 0x3f2a2e39
mov dword [0xf81ba8], 0x322e002e
mov dword [0xf81bac], 0x6263330e
mov dword [0xf81bb0], 0x222a2d6b
mov dword [0xf81bb4], 0x712f2e27
mov word [0xf81bb8], 0x4b6b
mov cl, byte [eax + 0xf81ba0]
xor cl, 0x4b
mov byte [eax + 0xf82318], cl
inc eax
cmp eax, 0x1a
jb 0xeedceb
mov eax, 0xf82318
ret

Function at 0xeeddcb
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8264c], 1
jne 0xeede31
or dword [0xf8264c], 1
mov dword [0xf81bbc], 0x263e250e
mov dword [0xf81bc0], 0x3f2a392e
mov dword [0xf81bc4], 0x6b252422
mov dword [0xf81bc8], 0x2e2f2522
mov dword [0xf81bcc], 0x3e246b33
mov dword [0xf81bd0], 0x2d246b3f
mov dword [0xf81bd4], 0x252a396b
mov word [0xf81bd8], 0x2e2c
mov byte [0xf81bda], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81bbc]
xor cl, 0x4b
mov byte [eax + 0xf82334], cl
inc eax
cmp eax, 0x1f
jb 0xeede33
mov eax, 0xf82334
ret

Function at 0xeede4e
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82648], 1
jne 0xeede9c
or dword [0xf82648], 1
mov dword [0xf81bdc], 0xe2c2e19
mov dword [0xf81be0], 0x263e25
mov dword [0xf81be4], 0x330e322e
mov dword [0xf81be8], 0x2d6b6263
mov dword [0xf81bec], 0x2e27222a
mov dword [0xf81bf0], 0x4b6b712f
mov cl, byte [eax + 0xf81bdc]
xor cl, 0x4b
mov byte [eax + 0xf82354], cl
inc eax
cmp eax, 0x18
jb 0xeede9c
mov eax, 0xf82354
ret

Function at 0xeedfff
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82644], 1
jne 0xeee034
or dword [0xf82644], 1
mov dword [0xf81bf4], 0x27273e05
mov dword [0xf81bf8], 0x2524286b
mov dword [0xf81bfc], 0x3f332e3f
mov byte [0xf81c00], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81bf4]
xor cl, 0x4b
mov byte [eax + 0xf8236c], cl
inc eax
cmp eax, 0xd
jb 0xeee036
mov eax, 0xf8236c
ret
Function at 0xeee051
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82640], 1
jne 0xeee09f
or dword [0xf82640], 1
mov dword [0xf81c04], 0x42c2e19
mov dword [0xf81c08], 0x252e3b
mov dword [0xf81c0c], 0x330e322e
mov dword [0xf81c10], 0x2d6b6263
mov dword [0xf81c14], 0x2e27222a
mov dword [0xf81c18], 0x4b6b712f
mov cl, byte [eax + 0xf81c04]
xor cl, 0x4b
mov byte [eax + 0xf8237c], cl
inc eax
cmp eax, 0x18
jb 0xeee09f
mov eax, 0xf8237c
ret

Function at 0xeee0ba
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf8263c], 1
jne 0xeee118
or dword [0xf8263c], 1
mov dword [0xf81c1c], 0x1a2c2e19
mov dword [0xf81c20], 0x32392e3e
mov dword [0xf81c24], 0x242d2502
mov dword [0xf81c28], 0x63322e00
mov dword [0xf81c2c], 0x2a2d6b62
mov dword [0xf81c30], 0x2f2e2722
mov word [0xf81c34], 0x6b71
mov byte [0xf81c36], 0x4b
mov cl, byte [eax + 0xf81c1c]
xor cl, 0x4b
mov byte [eax + 0xf82394], cl
inc eax
cmp eax, 0x1b
jb 0xeee118
mov eax, 0xf82394
ret

Function at 0xeee209
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82638], 1
jne 0xeee26f
or dword [0xf82638], 1
mov dword [0xf81c38], 0x263e250e
mov dword [0xf81c3c], 0x3f2a392e
mov dword [0xf81c40], 0x6b252422
mov dword [0xf81c44], 0x2e2f2522
mov dword [0xf81c48], 0x3e246b33
mov dword [0xf81c4c], 0x2d246b3f
mov dword [0xf81c50], 0x252a396b
mov word [0xf81c54], 0x2e2c
mov byte [0xf81c56], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81c38]
xor cl, 0x4b
mov byte [eax + 0xf823b0], cl
inc eax
cmp eax, 0x1f
jb 0xeee271
mov eax, 0xf823b0
ret

Function at 0xeee28c
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82634], 1
jne 0xeee2ea
or dword [0xf82634], 1
mov dword [0xf81c58], 0x1a2c2e19
mov dword [0xf81c5c], 0x32392e3e
mov dword [0xf81c60], 0x242d2502
mov dword [0xf81c64], 0x63322e00
mov dword [0xf81c68], 0x2a2d6b62
mov dword [0xf81c6c], 0x2f2e2722
mov word [0xf81c70], 0x6b71
mov byte [0xf81c72], 0x4b
mov cl, byte [eax + 0xf81c58]
xor cl, 0x4b
mov byte [eax + 0xf823d0], cl
inc eax
cmp eax, 0x1b
jb 0xeee2ea
mov eax, 0xf823d0
ret

Function at 0xeee44a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82630], 1
jne 0xeee47f
or dword [0xf82630], 1
mov dword [0xf81c74], 0x27273e05
mov dword [0xf81c78], 0x2524286b
mov dword [0xf81c7c], 0x3f332e3f
mov byte [0xf81c80], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81c74]
xor cl, 0x4b
mov byte [eax + 0xf823ec], cl
inc eax
cmp eax, 0xd
jb 0xeee481
mov eax, 0xf823ec
ret

Function at 0xeee49c
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf8262c], 1
jne 0xeee4ea
or dword [0xf8262c], 1
mov dword [0xf81c84], 0x42c2e19
mov dword [0xf81c88], 0x252e3b
mov dword [0xf81c8c], 0x330e322e
mov dword [0xf81c90], 0x2d6b6263
mov dword [0xf81c94], 0x2e27222a
mov dword [0xf81c98], 0x4b6b712f
mov cl, byte [eax + 0xf81c84]
xor cl, 0x4b
mov byte [eax + 0xf823fc], cl
inc eax
cmp eax, 0x18
jb 0xeee4ea
mov eax, 0xf823fc
ret
Function at 0xeee505
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82628], 1
jne 0xeee563
or dword [0xf82628], 1
mov dword [0xf81c9c], 0x1a2c2e19
mov dword [0xf81ca0], 0x32392e3e
mov dword [0xf81ca4], 0x242d2502
mov dword [0xf81ca8], 0x63322e00
mov dword [0xf81cac], 0x2a2d6b62
mov dword [0xf81cb0], 0x2f2e2722
mov word [0xf81cb4], 0x6b71
mov byte [0xf81cb6], 0x4b
mov cl, byte [eax + 0xf81c9c]
xor cl, 0x4b
mov byte [eax + 0xf82414], cl
inc eax
cmp eax, 0x1b
jb 0xeee563
mov eax, 0xf82414
ret

Function at 0xeee80f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82624], 1
mov ecx, 0x794b
jne 0xeee87b
or dword [0xf82624], 1
lea eax, [ecx + 0x18]
mov word [0xf81cb8], ax
add eax, 0xffffffac
mov word [0xf81cba], ax
lea eax, [ecx - 0x1d]
mov word [0xf81cbc], ax
dec eax
mov word [0xf81cbe], ax
lea eax, [ecx - 0x21]
mov word [0xf81cc0], ax
add eax, 0x14
mov word [0xf81cc2], ax
lea eax, [ecx - 0x24]
mov word [0xf81cc4], ax
add eax, 0x18
mov word [0xf81cc6], ax
lea eax, [ecx + 0x17]
mov word [0xf81cc8], ax
mov eax, ecx
mov word [0xf81cca], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xf81cb8]
add eax, 2
mov word [eax + 0xf8242e], dx
cmp eax, 0x14
jb 0xeee87d
mov eax, 0xf82430
ret

Function at 0xeee89b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82620], 1
mov ecx, 0x794b
jne 0xeee907
or dword [0xf82620], 1
lea eax, [ecx + 0x18]
mov word [0xf81ccc], ax
add eax, 0xffffffcc
mov word [0xf81cce], ax
lea eax, [ecx - 0x1d]
mov word [0xf81cd0], ax
dec eax
mov word [0xf81cd2], ax
lea eax, [ecx - 0x21]
mov word [0xf81cd4], ax
add eax, 0x14
mov word [0xf81cd6], ax
lea eax, [ecx - 0x24]
mov word [0xf81cd8], ax
add eax, 0x18
mov word [0xf81cda], ax
lea eax, [ecx + 0x17]
mov word [0xf81cdc], ax
mov eax, ecx
mov word [0xf81cde], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xf81ccc]
add eax, 2
mov word [eax + 0xf82442], dx
cmp eax, 0x14
jb 0xeee909
mov eax, 0xf82444
ret

Function at 0xeee927
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf8261c], 1
jne 0xeee975
or dword [0xf8261c], 1
mov dword [0xf81ce0], 0x42c2e19
mov dword [0xf81ce4], 0x252e3b
mov dword [0xf81ce8], 0x330e322e
mov dword [0xf81cec], 0x2d6b6263
mov dword [0xf81cf0], 0x2e27222a
mov dword [0xf81cf4], 0x4b6b712f
mov cl, byte [eax + 0xf81ce0]
xor cl, 0x4b
mov byte [eax + 0xf82458], cl
inc eax
cmp eax, 0x18
jb 0xeee975
mov eax, 0xf82458
ret

Function at 0xeee990
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82618], 1
jne 0xeee9ec
or dword [0xf82618], 1
mov dword [0xf81cf8], 0x1a2c2e19
mov dword [0xf81cfc], 0x32392e3e
mov dword [0xf81d00], 0x3e272a1d
mov dword [0xf81d04], 0x63330e2e
mov dword [0xf81d08], 0x2a2d6b62
mov dword [0xf81d0c], 0x2f2e2722
mov word [0xf81d10], 0x6b71
mov byte [0xf81d12], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81cf8]
xor cl, 0x4b
mov byte [eax + 0xf82470], cl
inc eax
cmp eax, 0x1b
jb 0xeee9ee
mov eax, 0xf82470
ret
Function at 0xeeea09
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82614], 1
jne 0xeeea65
or dword [0xf82614], 1
mov dword [0xf81d14], 0x1a2c2e19
mov dword [0xf81d18], 0x32392e3e
mov dword [0xf81d1c], 0x3e272a1d
mov dword [0xf81d20], 0x63330e2e
mov dword [0xf81d24], 0x2a2d6b62
mov dword [0xf81d28], 0x2f2e2722
mov word [0xf81d2c], 0x6b71
mov byte [0xf81d2e], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81d14]
xor cl, 0x4b
mov byte [eax + 0xf8248c], cl
inc eax
cmp eax, 0x1b
jb 0xeeea67
mov eax, 0xf8248c
ret

Function at 0xeeebe1
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82610], 1
jne 0xeeec2f
or dword [0xf82610], 1
mov dword [0xf81d30], 0x42c2e19
mov dword [0xf81d34], 0x252e3b
mov dword [0xf81d38], 0x330e322e
mov dword [0xf81d3c], 0x2d6b6263
mov dword [0xf81d40], 0x2e27222a
mov dword [0xf81d44], 0x4b6b712f
mov cl, byte [eax + 0xf81d30]
xor cl, 0x4b
mov byte [eax + 0xf824a8], cl
inc eax
cmp eax, 0x18
jb 0xeeec2f
mov eax, 0xf824a8
ret

Function at 0xeeec4a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf8260c], 1
jne 0xeeecb0
or dword [0xf8260c], 1
mov dword [0xf81d48], 0x182c2e19
mov dword [0xf81d4c], 0x2a1d3f2e
mov dword [0xf81d50], 0xe2e3e27
mov dword [0xf81d54], 0x3f386333
mov dword [0xf81d58], 0x2c252239
mov dword [0xf81d5c], 0x2a2d6b62
mov dword [0xf81d60], 0x2f2e2722
mov word [0xf81d64], 0x6b71
mov byte [0xf81d66], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81d48]
xor cl, 0x4b
mov byte [eax + 0xf824c0], cl
inc eax
cmp eax, 0x1f
jb 0xeeecb2
mov eax, 0xf824c0
ret

Function at 0xeeee1c
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xf82608], 1
jne 0xeeee6a
or dword [0xf82608], 1
mov dword [0xf81d68], 0x42c2e19
mov dword [0xf81d6c], 0x252e3b
mov dword [0xf81d70], 0x330e322e
mov dword [0xf81d74], 0x2d6b6263
mov dword [0xf81d78], 0x2e27222a
mov dword [0xf81d7c], 0x4b6b712f
mov cl, byte [eax + 0xf81d68]
xor cl, 0x4b
mov byte [eax + 0xf824e0], cl
inc eax
cmp eax, 0x18
jb 0xeeee6a
mov eax, 0xf824e0
ret

Function at 0xeeee85
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82604], 1
jne 0xeeeee4
or dword [0xf82604], 1
mov dword [0xf81d80], 0x182c2e19
mov dword [0xf81d84], 0x2a1d3f2e
mov dword [0xf81d88], 0xe2e3e27
mov dword [0xf81d8c], 0x3c2f6333
mov dword [0xf81d90], 0x622f3924
mov dword [0xf81d94], 0x222a2d6b
mov dword [0xf81d98], 0x712f2e27
mov word [0xf81d9c], 0x4b6b
xor eax, eax
mov cl, byte [eax + 0xf81d80]
xor cl, 0x4b
mov byte [eax + 0xf824f8], cl
inc eax
cmp eax, 0x1e
jb 0xeeeee6
mov eax, 0xf824f8
ret

Function at 0xeef051
Capabilities:
Encode data using xor

Disassembly:
test byte [0xf82600], 1
jne 0xeef0cb
or dword [0xf82600], 1
mov dword [0xf81da0], 0x3f383e06
mov dword [0xf81da4], 0x2e3b386b
mov dword [0xf81da8], 0x322d2228
mov dword [0xf81dac], 0x256b2a6b
mov dword [0xf81db0], 0x2e662524
mov dword [0xf81db4], 0x323f3b26
mov dword [0xf81db8], 0x293e386b
mov dword [0xf81dbc], 0x6b322e20
mov dword [0xf81dc0], 0x22393f38
mov word [0xf81dc4], 0x2c25
mov byte [0xf81dc6], 0x4b
xor eax, eax
mov cl, byte [eax + 0xf81da0]
xor cl, 0x4b
mov byte [eax + 0xf82518], cl
inc eax
cmp eax, 0x27
jb 0xeef0cd
mov eax, 0xf82518
ret