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

Disassembly:
test byte [0x9382b0], 1
jne 0x879b6d
or dword [0x9382b0], 1
mov dword [0x933120], 0xcacfc7e0
mov dword [0x933124], 0xd286c2c3
mov dword [0x933128], 0xc3d486c9
mov dword [0x93312c], 0xc986c2c7
mov dword [0x933130], 0xc986d4d3
mov dword [0x933134], 0xc386c8d1
mov word [0x933138], 0xc3de
mov byte [0x93313a], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933120]
xor cl, 0xa6
mov byte [eax + 0x933850], cl
inc eax
cmp eax, 0x1b
jb 0x879b6f
mov eax, 0x933850
ret

Function at 0x879beb
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382ac], 1
jne 0x879c37
or dword [0x9382ac], 1
mov dword [0x93313c], 0xead2c3e1
mov dword [0x933140], 0xefd2d5c7
mov dword [0x933144], 0xd2d3d6c8
mov dword [0x933148], 0xc9c0c8ef
mov dword [0x93314c], 0xcfc7c086
mov dword [0x933150], 0xa6c2c3ca
xor eax, eax
mov cl, byte [eax + 0x93313c]
xor cl, 0xa6
mov byte [eax + 0x93386c], cl
inc eax
cmp eax, 0x18
jb 0x879c39
mov eax, 0x93386c
ret

Function at 0x879f4b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382a8], 1
mov ecx, 0xdca6
jne 0x879fae
or dword [0x9382a8], 1
lea eax, [ecx + 0x28]
mov word [0x933154], ax
add eax, 4
mov edx, eax
mov word [0x933158], ax
lea eax, [ecx + 0x30]
mov word [0x93315a], ax
dec eax
mov word [0x93315c], ax
lea eax, [ecx - 0xa]
mov word [0x93315e], ax
add eax, 0xffffffed
mov word [0x933156], dx
mov edx, eax
mov word [0x933162], ax
mov eax, ecx
mov word [0x933160], dx
mov word [0x933164], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x933154]
add eax, 2
mov word [eax + 0x933882], dx
cmp eax, 0x12
jb 0x879fb0
mov eax, 0x933884
ret

Function at 0x879fce
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382a4], 1
mov ecx, 0xdca6
jne 0x87a02a
or dword [0x9382a4], 1
lea eax, [ecx + 0x28]
mov word [0x933168], ax
add eax, 4
mov edx, eax
mov word [0x93316c], ax
lea eax, [ecx + 0x30]
mov word [0x93316e], ax
add eax, 0xffffffc6
mov word [0x933170], ax
lea eax, [ecx - 0x1d]
mov word [0x93316a], dx
mov edx, eax
mov word [0x933174], ax
mov eax, ecx
mov word [0x933172], dx
mov word [0x933176], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x933168]
add eax, 2
mov word [eax + 0x933896], dx
cmp eax, 0x10
jb 0x87a02c
mov eax, 0x933898
ret

Function at 0x87a04a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93829c], 1
jne 0x87a093
or dword [0x93829c], 1
mov dword [0x933184], 0xe1d5c8e2
mov dword [0x933188], 0xc7e5d2c3
mov dword [0x93318c], 0xe2c3cec5
mov dword [0x933190], 0xf2c7d2c7
mov dword [0x933194], 0xc3cac4c7
mov byte [0x933198], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933184]
xor cl, 0xa6
mov byte [eax + 0x9338b4], cl
inc eax
cmp eax, 0x15
jb 0x87a095
mov eax, 0x9338b4
ret
Function at 0x87a97b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938298], 1
mov ecx, 0xdca6
jne 0x87aa05
or dword [0x938298], 1
lea eax, [ecx + 0x1f]
mov word [0x93319c], ax
add eax, 0xf
mov edx, eax
mov word [0x93319e], dx
lea edx, [ecx + 0x21]
mov word [0x9331a0], dx
add edx, 0xe
mov word [0x9331a2], dx
lea edx, [ecx + 0x28]
mov word [0x9331a4], dx
add edx, 0x2b
mov word [0x9331a6], dx
mov edx, eax
mov word [0x9331a8], dx
lea edx, [ecx + 0x1d]
lea eax, [ecx + 0x2c]
mov word [0x9331aa], dx
mov word [0x9331b2], ax
add edx, 0x13
mov eax, ecx
mov word [0x9331ac], dx
mov dword [0x9331ae], 0xdcd4dcc9
mov word [0x9331b4], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x93319c]
add eax, 2
mov word [eax + 0x9338ca], dx
cmp eax, 0x1a
jb 0x87aa07
mov eax, 0x9338cc
ret

Function at 0x87aa25
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938294], 1
jne 0x87aa9f
or dword [0x938294], 1
mov dword [0x9331b8], 0xd4d4c9f5
mov dword [0x9331bc], 0xd2868adf
mov dword [0x9331c0], 0x86d5cfce
mov dword [0x9331c4], 0xd2c0c9d5
mov dword [0x9331c8], 0xc3d4c7d1
mov dword [0x9331cc], 0x86d5cf86
mov dword [0x9331d0], 0x86d2c9c8
mov dword [0x9331d4], 0xcfc7d0c7
mov dword [0x9331d8], 0xcac4c7ca
mov word [0x9331dc], 0x88c3
mov byte [0x9331de], 0xa6
xor eax, eax
mov cl, byte [eax + 0x9331b8]
xor cl, 0xa6
mov byte [eax + 0x9338e8], cl
inc eax
cmp eax, 0x27
jb 0x87aaa1
mov eax, 0x9338e8
ret

Function at 0x87aabc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938290], 1
jne 0x87aadf
or dword [0x938290], 1
mov dword [0x9331e0], 0xc9d4d4e3
mov word [0x9331e4], 0xa6d4
xor eax, eax
mov cl, byte [eax + 0x9331e0]
xor cl, 0xa6
mov byte [eax + 0x933910], cl
inc eax
cmp eax, 6
jb 0x87aae1
mov eax, 0x933910
ret

Function at 0x87aafc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93828c], 1
jne 0x87ab76
or dword [0x93828c], 1
mov dword [0x9331e8], 0xd4d4c9f5
mov dword [0x9331ec], 0xd2868adf
mov dword [0x9331f0], 0x86d5cfce
mov dword [0x9331f4], 0xd2c0c9d5
mov dword [0x9331f8], 0xc3d4c7d1
mov dword [0x9331fc], 0x86d5cf86
mov dword [0x933200], 0x86d2c9c8
mov dword [0x933204], 0xcfc7d0c7
mov dword [0x933208], 0xcac4c7ca
mov word [0x93320c], 0x88c3
mov byte [0x93320e], 0xa6
xor eax, eax
mov cl, byte [eax + 0x9331e8]
xor cl, 0xa6
mov byte [eax + 0x933918], cl
inc eax
cmp eax, 0x27
jb 0x87ab78
mov eax, 0x933918
ret

Function at 0x87ab93
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938288], 1
jne 0x87abb6
or dword [0x938288], 1
mov dword [0x933210], 0xc9d4d4e3
mov word [0x933214], 0xa6d4
xor eax, eax
mov cl, byte [eax + 0x933210]
xor cl, 0xa6
mov byte [eax + 0x933940], cl
inc eax
cmp eax, 6
jb 0x87abb8
mov eax, 0x933940
ret
Function at 0x87abd3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938284], 1
jne 0x87ac29
or dword [0x938284], 1
mov dword [0x933218], 0x86c3cae9
mov dword [0x93321c], 0xd2cfc8cf
mov dword [0x933220], 0xcfcac7cf
mov dword [0x933224], 0xcfd2c7dc
mov dword [0x933228], 0xc086c8c9
mov dword [0x93322c], 0xc3cacfc7
mov dword [0x933230], 0xa6869cc2
xor eax, eax
mov cl, byte [eax + 0x933218]
xor cl, 0xa6
mov byte [eax + 0x933948], cl
inc eax
cmp eax, 0x1c
jb 0x87ac2b
mov eax, 0x933948
ret

Function at 0x87ac46
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938280], 1
jne 0x87ac71
or dword [0x938280], 1
mov dword [0x933234], 0xc8d4c3cd
mov dword [0x933238], 0x9495cac3
mov byte [0x93323c], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933234]
xor cl, 0xa6
mov byte [eax + 0x933964], cl
inc eax
cmp eax, 9
jb 0x87ac73
mov eax, 0x933964
ret

Function at 0x87ac8e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93827c], 1
jne 0x87acf7
or dword [0x93827c], 1
mov dword [0x933240], 0xf6d2c3f5
mov dword [0x933244], 0xc3c5c9d4
mov dword [0x933248], 0xd5f3d5d5
mov dword [0x93324c], 0xc9ebd4c3
mov dword [0x933250], 0xdee3c3c2
mov dword [0x933254], 0xd2d6c3c5
mov dword [0x933258], 0xf6c8c9cf
mov dword [0x93325c], 0xc5cfcac9
mov word [0x933260], 0xa6df
xor eax, eax
mov cl, byte [eax + 0x933240]
xor cl, 0xa6
mov byte [eax + 0x933970], cl
inc eax
cmp eax, 0x22
jb 0x87acf9
mov eax, 0x933970
ret

Function at 0x87ad14
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938278], 1
jne 0x87ad7d
or dword [0x938278], 1
mov dword [0x933264], 0xf6d2c3e1
mov dword [0x933268], 0xc3c5c9d4
mov dword [0x93326c], 0xd5f3d5d5
mov dword [0x933270], 0xc9ebd4c3
mov dword [0x933274], 0xdee3c3c2
mov dword [0x933278], 0xd2d6c3c5
mov dword [0x93327c], 0xf6c8c9cf
mov dword [0x933280], 0xc5cfcac9
mov word [0x933284], 0xa6df
xor eax, eax
mov cl, byte [eax + 0x933264]
xor cl, 0xa6
mov byte [eax + 0x933994], cl
inc eax
cmp eax, 0x22
jb 0x87ad7f
mov eax, 0x933994
ret

Function at 0x87ad9a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938274], 1
mov ecx, 0xdca6
jne 0x87adc9
or dword [0x938274], 1
lea eax, [ecx + 0x21]
mov word [0x933288], ax
add eax, 0xffffffcd
mov word [0x93328a], ax
mov eax, ecx
mov word [0x93328c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x933288]
add eax, 2
mov word [eax + 0x9339b6], dx
cmp eax, 6
jb 0x87adcb
mov eax, 0x9339b8
ret

Function at 0x87ade9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93826c], 1
jne 0x87ae59
or dword [0x93826c], 1
mov dword [0x933298], 0xcacfc7e0
mov dword [0x93329c], 0xd286c2c3
mov dword [0x9332a0], 0xc8cf86c9
mov dword [0x9332a4], 0xc7cfd2cf
mov dword [0x9332a8], 0xc3dccfca
mov dword [0x9332ac], 0xd0c8c386
mov dword [0x9332b0], 0xc8c9d4cf
mov dword [0x9332b4], 0xd2c8c3cb
mov word [0x9332b8], 0x869c
mov byte [0x9332ba], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933298]
xor cl, 0xa6
mov byte [eax + 0x9339c8], cl
inc eax
cmp eax, 0x23
jb 0x87ae5b
mov eax, 0x9339c8
ret
Function at 0x87ae76
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938264], 1
mov ecx, 0xdca6
jne 0x87aec0
or dword [0x938264], 1
lea eax, [ecx + 0x1d]
mov word [0x9332c4], ax
add eax, 5
mov word [0x9332c6], ax
lea eax, [ecx + 0x2c]
mov word [0x9332c8], ax
add eax, 2
mov word [0x9332ca], ax
lea eax, [ecx + 0x39]
mov word [0x9332cc], ax
mov eax, ecx
mov word [0x9332ce], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x9332c4]
add eax, 2
mov word [eax + 0x9339f2], dx
cmp eax, 0xc
jb 0x87aec2
mov eax, 0x9339f4
ret

Function at 0x87aee0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938260], 1
jne 0x87af2b
or dword [0x938260], 1
mov dword [0x9332d0], 0xc7cec8f3
mov dword [0x9332d4], 0xc3cac2c8
mov dword [0x9332d8], 0xdec386c2
mov dword [0x9332dc], 0xd2d6c3c5
mov dword [0x9332e0], 0x9cc8c9cf
mov word [0x9332e4], 0xa686
xor eax, eax
mov cl, byte [eax + 0x9332d0]
xor cl, 0xa6
mov byte [eax + 0x933a00], cl
inc eax
cmp eax, 0x16
jb 0x87af2d
mov eax, 0x933a00
ret

Function at 0x87af48
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93825c], 1
jne 0x87af9b
or dword [0x93825c], 1
mov dword [0x9332e8], 0xc7cec8f3
mov dword [0x9332ec], 0xc3cac2c8
mov dword [0x9332f0], 0xdec386c2
mov dword [0x9332f4], 0xd2d6c3c5
mov dword [0x9332f8], 0x9cc8c9cf
mov dword [0x9332fc], 0xacd58386
mov byte [0x933300], 0xa6
xor eax, eax
mov cl, byte [eax + 0x9332e8]
xor cl, 0xa6
mov byte [eax + 0x933a18], cl
inc eax
cmp eax, 0x19
jb 0x87af9d
mov eax, 0x933a18
ret

Function at 0x87afbb
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938258], 1
jne 0x87aff3
or dword [0x938258], 1
mov dword [0x933304], 0xc4d3d2f5
mov dword [0x933308], 0xcfdec386
mov dword [0x93330c], 0x838e86d2
mov dword [0x933310], 0xa6ac8fc2
xor eax, eax
mov cl, byte [eax + 0x933304]
xor cl, 0xa6
mov byte [eax + 0x933a34], cl
inc eax
cmp eax, 0x10
jb 0x87aff5
mov eax, 0x933a34
ret
Function at 0x87cf42
Capabilities:
Write file on windows

Disassembly:
mov eax, 0x8fdd9c
call fcn.008fcc58
sub esp, 0x20
push ebx
xor ebx, ebx
cmp dword [edi + 0x44], ebx
je 0x87d026
cmp byte [edi + 0x49], bl
je 0x87d026
mov eax, dword [edi]
push 0xffffffffffffffff
mov ecx, edi
call dword [eax + 0xc]
cmp eax, 0xffffffff
jne 0x87cf79
xor al, al
jmp 0x87d028
push esi
lea esi, [ebp - 0x2c]
call fcn.0087c8e7
mov dword [ebp - 4], ebx
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0x87cfc9
lea eax, [ebp - 0x2c]
mov edx, eax
mov ecx, dword [edi + 0x44]
mov esi, dword [ecx]
lea ebx, [ebp - 0x10]
push ebx
mov ebx, dword [ebp - 0x1c]
add eax, ebx
push eax
push edx
lea eax, [edi + 0x4c]
push eax
call dword [esi + 0x18]
sub eax, 0
je 0x87cfce
dec eax
je 0x87cfd2
dec eax
dec eax
je 0x87d022
xor bl, bl
push 0
push 1
lea ecx, [ebp - 0x2c]
call fcn.00874c70
mov al, bl
pop esi
jmp 0x87d028
mov edx, dword [ebp - 0x2c]
jmp 0x87cf93
mov byte [edi + 0x49], 0
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0x87cfde
lea eax, [ebp - 0x2c]
mov esi, dword [ebp - 0x10]
sub esi, eax
je 0x87d004
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0x87cff1
lea eax, [ebp - 0x2c]
push dword [edi + 0x54]
push esi
push 1
push eax
call fcn.008d889f
add esp, 0x10
cmp esi, eax
jne 0x87cfb6
cmp byte [edi + 0x49], 0
je 0x87d022
test esi, esi
jne 0x87cf85
push esi
push 8
lea esi, [ebp - 0x2c]
call fcn.0087c9c0
jmp 0x87cf85
mov bl, 1
jmp 0x87cfb8
mov al, 1
mov ecx, dword [ebp - 0xc]
pop ebx
mov dword fs:[0], ecx
leave
ret

Function at 0x88285c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938254], 1
jne 0x8828d0
or dword [0x938254], 1
mov dword [0x933a54], 0xc5dcc6ea
mov dword [0x933a58], 0xc6c789cd
mov dword [0x933a5c], 0xccce89dd
mov dword [0x933a60], 0xc0cd89dd
mov dword [0x933a64], 0xcdc0d9da
mov dword [0x933a68], 0x89cfc689
mov dword [0x933a6c], 0xc1ddccc4
mov dword [0x933a70], 0x8e89cdc6
mov dword [0x933a74], 0xc5c5c8ca
mov dword [0x933a78], 0xa989938e
xor eax, eax
mov cl, byte [eax + 0x933a54]
xor cl, 0xa9
mov byte [eax + 0x933b98], cl
inc eax
cmp eax, 0x28
jb 0x8828d2
mov eax, 0x933b98
ret

Function at 0x8828ed
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938250], 1
jne 0x882954
or dword [0x938250], 1
mov dword [0x933a7c], 0xc5c0c8ef
mov dword [0x933a80], 0xdd89cdcc
mov dword [0x933a84], 0xc7c089c6
mov dword [0x933a88], 0xccc2c6df
mov dword [0x933a8c], 0xddccc489
mov dword [0x933a90], 0x89cdc6c1
mov dword [0x933a94], 0xc5c8ca8e
mov dword [0x933a98], 0x89938ec5
mov byte [0x933a9c], 0xa9
xor eax, eax
mov cl, byte [eax + 0x933a7c]
xor cl, 0xa9
mov byte [eax + 0x933bc0], cl
inc eax
cmp eax, 0x21
jb 0x882956
mov eax, 0x933bc0
ret
Function at 0x882971
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93824c], 1
jne 0x8829d1
or dword [0x93824c], 1
mov dword [0x933aa0], 0xc6dbf9a3
mov dword [0x933aa4], 0xc5cbc8cb
mov dword [0x933aa8], 0xdccd89d0
mov dword [0x933aac], 0xc6dd89cc
mov dword [0x933ab0], 0xdbcada89
mov dword [0x933ab4], 0x89ddd9c0
mov dword [0x933ab8], 0xc6dbdbcc
mov dword [0x933abc], 0xa98993db
xor eax, eax
mov cl, byte [eax + 0x933aa0]
xor cl, 0xa9
mov byte [eax + 0x933be4], cl
inc eax
cmp eax, 0x20
jb 0x8829d3
mov eax, 0x933be4
ret

Function at 0x882fae
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push ecx
and dword [ebp - 4], 0
cmp dword [ebp + 0xc], 0
push ebx
push esi
push edi
mov edi, eax
jbe 0x8830f3
mov ebx, dword [ebp + 8]
push 4
sub ebx, edi
pop esi
test byte [0x938248], 1
jne 0x883010
or dword [0x938248], 1
mov eax, 0xdcda
mov word [0x933ac0], ax
add eax, 0xfffffff2
mov word [0x933ac2], ax
mov eax, 0xdcc7
mov word [0x933ac4], ax
add eax, 6
mov word [0x933ac6], ax
mov eax, 0xdca9
mov word [0x933ac8], ax
xor eax, eax
mov ecx, 0xdca9
xor cx, word [eax + 0x933ac0]
add eax, 2
mov word [eax + 0x933c02], cx
cmp eax, 0xa
jb 0x883012
mov eax, dword [ebx + edi]
mov ecx, 0x933c04
mov dx, word [eax]
cmp dx, word [ecx]
jne 0x883059
test dx, dx
je 0x883055
mov dx, word [eax + 2]
cmp dx, word [ecx + 2]
jne 0x883059
add eax, esi
add ecx, esi
test dx, dx
jne 0x883035
xor eax, eax
jmp 0x88305e
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0x88306a
mov dword [edi], 0x385
jmp 0x8830e2
call fcn.00883103
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0x883096
test dx, dx
je 0x883092
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0x883096
add ecx, esi
add eax, esi
test dx, dx
jne 0x883072
xor eax, eax
jmp 0x88309b
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0x8830a7
mov dword [edi], 0x386
jmp 0x8830e2
call fcn.008831d6
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0x8830d3
test dx, dx
je 0x8830cf
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0x8830d3
add ecx, esi
add eax, esi
test dx, dx
jne 0x8830af
xor eax, eax
jmp 0x8830d8
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0x8830fc
mov dword [edi], 0x387
inc dword [ebp - 4]
mov eax, dword [ebp - 4]
add edi, esi
cmp eax, dword [ebp + 0xc]
jb 0x882fcd
xor eax, eax
pop edi
pop esi
pop ebx
leave
ret 8
mov eax, 0x80020006
jmp 0x8830f5
Function at 0x883103
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938244], 1
jne 0x8831b3
or dword [0x938244], 1
mov eax, 0xdcc8
mov word [0x933acc], ax
add eax, 5
mov ecx, eax
mov word [0x933ad0], ax
mov eax, 0xdcec
mov word [0x933ad2], ax
add eax, 0xfffffff3
mov word [0x933ad4], ax
mov eax, 0xdccc
mov word [0x933ace], cx
mov ecx, eax
lea edx, [eax - 5]
mov word [0x933ad6], cx
mov ecx, edx
push edi
mov word [0x933ad8], cx
add ecx, 0x16
mov edi, ecx
mov word [0x933ada], di
lea edi, [eax + 0x19]
mov word [0x933adc], di
add edi, 0xffffffdb
mov ecx, eax
add eax, 0xf
mov word [0x933aea], ax
lea eax, [ecx - 0x23]
mov word [0x933ade], di
mov dword [0x933ae0], 0xdcdddcda
mov word [0x933ae4], cx
mov dword [0x933ae6], 0xdcccdcc7
mov word [0x933aec], ax
pop edi
xor eax, eax
mov ecx, 0xdca9
xor cx, word [eax + 0x933acc]
add eax, 2
mov word [eax + 0x933c0e], cx
cmp eax, 0x22
jb 0x8831b5
mov eax, 0x933c10
ret

Function at 0x8831d6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938240], 1
mov ecx, 0xdca9
jne 0x883230
or dword [0x938240], 1
lea eax, [ecx + 0x36]
mov word [0x933af0], ax
add eax, 0xffffffed
mov word [0x933af2], ax
lea eax, [ecx + 0x32]
mov word [0x933af4], ax
dec eax
mov word [0x933af6], ax
lea eax, [ecx + 0x17]
mov word [0x933af8], ax
add eax, 6
mov word [0x933afa], ax
lea eax, [ecx + 0x1e]
mov word [0x933afc], ax
mov eax, ecx
mov word [0x933afe], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x933af0]
add eax, 2
mov word [eax + 0x933c32], dx
cmp eax, 0x10
jb 0x883232
mov eax, 0x933c34
ret

Function at 0x883ba3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93823c], 1
mov edx, 0xdca9
jne 0x883c06
or dword [0x93823c], 1
lea ecx, [edx + 0x23]
mov eax, ecx
mov word [0x933b00], ax
add eax, 0xf
push esi
mov esi, eax
lea eax, [edx + 0x3c]
mov word [0x933b0a], ax
add eax, 0xffffffdb
mov word [0x933b0c], ax
mov eax, edx
mov word [0x933b02], si
mov word [0x933b04], si
mov dword [0x933b06], 0xdcdbdcc6
mov dword [0x933b0e], 0xdcccdcc7
mov word [0x933b12], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x933b00]
add eax, 2
mov word [eax + 0x933c42], cx
cmp eax, 0x14
jb 0x883c08
mov eax, 0x933c44
ret

Function at 0x883c26
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938238], 1
jne 0x883cc2
or dword [0x938238], 1
mov edx, 0xdccc
mov eax, edx
mov word [0x933b14], ax
add eax, 0xf
mov ecx, eax
mov word [0x933b16], cx
mov word [0x933b18], cx
lea ecx, [edx - 6]
mov word [0x933b1a], cx
mov ecx, eax
mov word [0x933b1c], cx
lea ecx, [edx + 0x1e]
mov word [0x933b1e], cx
add ecx, 0xffffffd7
mov word [0x933b20], cx
lea ecx, [edx - 4]
push edi
mov edi, ecx
mov word [0x933b22], di
mov edi, eax
mov word [0x933b26], cx
mov word [0x933b2e], ax
add ecx, 2
lea eax, [edx - 0x23]
mov word [0x933b24], di
mov word [0x933b28], cx
mov dword [0x933b2a], 0xdcccdcdd
mov word [0x933b30], ax
pop edi
xor eax, eax
mov ecx, 0xdca9
xor cx, word [eax + 0x933b14]
add eax, 2
mov word [eax + 0x933c56], cx
cmp eax, 0x1e
jb 0x883cc4
mov eax, 0x933c58
ret
Function at 0x883ce5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938234], 1
jne 0x883d46
or dword [0x938234], 1
mov edx, 0xdccc
mov eax, edx
mov word [0x933b34], ax
add eax, 0xf
mov ecx, eax
mov word [0x933b36], cx
mov word [0x933b38], cx
push edi
lea ecx, [edx - 6]
mov edi, ecx
mov word [0x933b3c], ax
lea eax, [edx - 0x23]
mov word [0x933b3a], di
mov dword [0x933b3e], 0xdcc6dcea
mov dword [0x933b42], 0xdcccdccd
mov word [0x933b46], ax
pop edi
xor eax, eax
mov ecx, 0xdca9
xor cx, word [eax + 0x933b34]
add eax, 2
mov word [eax + 0x933c76], cx
cmp eax, 0x14
jb 0x883d48
mov eax, 0x933c78
ret

Function at 0x883d69
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938230], 1
mov edx, 0xdca9
jne 0x883de6
or dword [0x938230], 1
lea ecx, [edx + 0x23]
mov eax, ecx
mov word [0x933b48], ax
add eax, 0xf
push esi
mov esi, eax
lea eax, [edx + 0x3b]
mov word [0x933b52], ax
mov eax, ecx
mov word [0x933b54], ax
add eax, 0xe
mov word [0x933b4a], si
mov word [0x933b4c], si
mov esi, eax
mov word [0x933b58], ax
lea eax, [edx + 0x1f]
mov word [0x933b5a], ax
mov eax, edx
mov word [0x933b56], si
mov dword [0x933b4e], 0xdcdbdcc6
mov dword [0x933b5c], 0xdcccdcce
mov word [0x933b60], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x933b48]
add eax, 2
mov word [eax + 0x933c8a], cx
cmp eax, 0x1a
jb 0x883de8
mov eax, 0x933c8c
ret

Function at 0x883e06
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93822c], 1
mov ecx, 0xdca9
jne 0x883e65
or dword [0x93822c], 1
lea eax, [ecx + 0x23]
mov word [0x933b64], ax
add eax, 0xf
mov edx, eax
mov word [0x933b66], dx
mov word [0x933b68], dx
lea edx, [ecx + 0x1d]
mov word [0x933b6a], dx
mov edx, eax
lea eax, [ecx + 0x1c]
mov word [0x933b72], ax
mov eax, ecx
mov word [0x933b6c], dx
mov dword [0x933b6e], 0xdcdbdcfc
mov word [0x933b74], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x933b64]
add eax, 2
mov word [eax + 0x933ca6], dx
cmp eax, 0x12
jb 0x883e67
mov eax, 0x933ca8
ret

Function at 0x88450a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938228], 1
jne 0x884534
or dword [0x938228], 1
mov dword [0x933b78], 0xc5dcc795
mov word [0x933b7c], 0x97c5
mov byte [0x933b7e], 0xa9
xor eax, eax
mov cl, byte [eax + 0x933b78]
xor cl, 0xa9
mov byte [eax + 0x933cbc], cl
inc eax
cmp eax, 7
jb 0x884536
mov eax, 0x933cbc
ret

Function at 0x884551
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938224], 1
jne 0x88457b
or dword [0x938224], 1
mov dword [0x933b80], 0xc5dcc795
mov word [0x933b84], 0x97c5
mov byte [0x933b86], 0xa9
xor eax, eax
mov cl, byte [eax + 0x933b80]
xor cl, 0xa9
mov byte [eax + 0x933cc4], cl
inc eax
cmp eax, 7
jb 0x88457d
mov eax, 0x933cc4
ret

Function at 0x884598
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93821c], 1
jne 0x8845bc
or dword [0x93821c], 1
mov dword [0x933b8c], 0xc6caf289
mov dword [0x933b90], 0xa994cccd
xor eax, eax
mov cl, byte [eax + 0x933b8c]
xor cl, 0xa9
mov byte [eax + 0x933cd0], cl
inc eax
cmp eax, 8
jb 0x8845be
mov eax, 0x933cd0
ret
Function at 0x8852a9
Capabilities:
Encode data using xor

Disassembly:
push esi
push edi
push 0x31
pop ecx
mov esi, 0x906d38
mov edi, 0x938620
push 0x906dfc
rep movsd dword es:[edi], dword [esi]
call fcn.008bf3e0
pop ecx
pop edi
pop esi
cmp eax, 0xffffffff
jne 0x8852cf
xor al, al
ret
push 0x906bc0
call fcn.008bf330
pop ecx
cmp eax, 0xffffffff
je 0x8852cc
push 0x906e90
call fcn.008be580
pop ecx
cmp eax, 0xffffffff
je 0x8852cc
test byte [0x938210], 1
jne 0x885310
or dword [0x938210], 1
mov dword [0x933cf0], 0x9acac3d8
mov byte [0x933cf4], 0xab
xor eax, eax
mov cl, byte [eax + 0x933cf0]
xor cl, 0xab
mov byte [eax + 0x933dbc], cl
inc eax
cmp eax, 5
jb 0x885312
push 0x933dbc
call fcn.008bf450
pop ecx
mov dword [0x92d928], eax
test eax, eax
js 0x8852cc
call fcn.0088539b
push eax
call fcn.008be5f0
pop ecx
mov dword [0x92d92c], eax
test eax, eax
js 0x8852cc
test byte [0x938208], 1
jne 0x88536e
or dword [0x938208], 1
mov dword [0x933d00], 0xabd8ceca
xor eax, eax
mov cl, byte [eax + 0x933d00]
xor cl, 0xab
mov byte [eax + 0x933dcc], cl
inc eax
cmp eax, 4
jb 0x885370
push 0x933dcc
call fcn.008bf3a0
test eax, eax
mov dword [0x92d930], eax
pop ecx
setns al
ret

Function at 0x88539b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93820c], 1
jne 0x8853bf
or dword [0x93820c], 1
mov dword [0x933cf8], 0xdfd9c4cd
mov dword [0x933cfc], 0xabcac5de
xor eax, eax
mov cl, byte [eax + 0x933cf8]
xor cl, 0xab
mov byte [eax + 0x933dc4], cl
inc eax
cmp eax, 8
jb 0x8853c1
mov eax, 0x933dc4
ret

Function at 0x88563f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938204], 1
jne 0x88567d
or dword [0x938204], 1
mov dword [0x933d04], 0xc28bdbc6
mov dword [0x933d08], 0x8bdfc2c5
mov dword [0x933d0c], 0xc7c2cacd
mov word [0x933d10], 0xcfce
mov byte [0x933d12], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d04]
xor cl, 0xab
mov byte [eax + 0x933dd0], cl
inc eax
cmp eax, 0xf
jb 0x88567f
mov eax, 0x933dd0
ret

Function at 0x88569a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938200], 1
jne 0x8856d8
or dword [0x938200], 1
mov dword [0x933d14], 0xc28bdbc6
mov dword [0x933d18], 0x8bdfc2c5
mov dword [0x933d1c], 0xc7c2cacd
mov word [0x933d20], 0xcfce
mov byte [0x933d22], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d14]
xor cl, 0xab
mov byte [eax + 0x933de0], cl
inc eax
cmp eax, 0xf
jb 0x8856da
mov eax, 0x933de0
ret

Function at 0x8856f5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381fc], 1
jne 0x885733
or dword [0x9381fc], 1
mov dword [0x933d24], 0xf4dfced8
mov dword [0x933d28], 0x8bdfc5c2
mov dword [0x933d2c], 0xc7c2cacd
mov word [0x933d30], 0xcfce
mov byte [0x933d32], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d24]
xor cl, 0xab
mov byte [eax + 0x933df0], cl
inc eax
cmp eax, 0xf
jb 0x885735
mov eax, 0x933df0
ret