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

Disassembly:
test byte [0xc58bd8], 1
mov ecx, 0x7844
jne 0xbb9edc
or dword [0xc58bd8], 1
lea eax, [ecx - 0x1f]
mov word [0xc54098], ax
add eax, 0x51
mov word [0xc5409a], ax
mov eax, ecx
mov word [0xc5409c], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xc54098]
add eax, 2
mov word [eax + 0xc54686], dx
cmp eax, 6
jb 0xbb9ede
mov eax, 0xc54688
ret

Function at 0xbb9efc
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bd0], 1
jne 0xbb9f6c
or dword [0xc58bd0], 1
mov dword [0xc540a8], 0x282d2502
mov dword [0xc540ac], 0x30642021
mov dword [0xc540b0], 0x2a2d642b
mov dword [0xc540b4], 0x252d302d
mov dword [0xc540b8], 0x213e2d28
mov dword [0xc540bc], 0x322a2164
mov dword [0xc540c0], 0x2a2b362d
mov dword [0xc540c4], 0x302a2129
mov word [0xc540c8], 0x647e
mov byte [0xc540ca], 0x44
xor eax, eax
mov cl, byte [eax + 0xc540a8]
xor cl, 0x44
mov byte [eax + 0xc54698], cl
inc eax
cmp eax, 0x23
jb 0xbb9f6e
mov eax, 0xc54698
ret

Function at 0xbb9f89
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bc8], 1
jne 0xbb9fd4
or dword [0xc58bc8], 1
mov dword [0xc540d4], 0x252c2a11
mov dword [0xc540d8], 0x2128202a
mov dword [0xc540dc], 0x3c216420
mov dword [0xc540e0], 0x30342127
mov dword [0xc540e4], 0x7e2a2b2d
mov word [0xc540e8], 0x4464
xor eax, eax
mov cl, byte [eax + 0xc540d4]
xor cl, 0x44
mov byte [eax + 0xc546c4], cl
inc eax
cmp eax, 0x16
jb 0xbb9fd6
mov eax, 0xc546c4
ret

Function at 0xbb9ff1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bc4], 1
jne 0xbba044
or dword [0xc58bc4], 1
mov dword [0xc540ec], 0x252c2a11
mov dword [0xc540f0], 0x2128202a
mov dword [0xc540f4], 0x3c216420
mov dword [0xc540f8], 0x30342127
mov dword [0xc540fc], 0x7e2a2b2d
mov dword [0xc54100], 0x4e376164
mov byte [0xc54104], 0x44
xor eax, eax
mov cl, byte [eax + 0xc540ec]
xor cl, 0x44
mov byte [eax + 0xc546dc], cl
inc eax
cmp eax, 0x19
jb 0xbba046
mov eax, 0xc546dc
ret

Function at 0xbba061
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bc0], 1
jne 0xbba099
or dword [0xc58bc0], 1
mov dword [0xc54108], 0x26313017
mov dword [0xc5410c], 0x2d3c2164
mov dword [0xc54110], 0x616c6430
mov dword [0xc54114], 0x444e6d20
xor eax, eax
mov cl, byte [eax + 0xc54108]
xor cl, 0x44
mov byte [eax + 0xc546f8], cl
inc eax
cmp eax, 0x10
jb 0xbba09b
mov eax, 0xc546f8
ret
Function at 0xbbbaaa
Capabilities:
Write file on windows

Disassembly:
mov eax, 0xc22ad9
call fcn.00c21d38
sub esp, 0x20
push ebx
xor ebx, ebx
cmp dword [edi + 0x44], ebx
je 0xbbbb8e
cmp byte [edi + 0x49], bl
je 0xbbbb8e
mov eax, dword [edi]
push 0xffffffffffffffff
mov ecx, edi
call dword [eax + 0xc]
cmp eax, 0xffffffff
jne 0xbbbae1
xor al, al
jmp 0xbbbb90
push esi
lea esi, [ebp - 0x2c]
call fcn.00bbb5a3
mov dword [ebp - 4], ebx
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xbbbb31
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 0xbbbb36
dec eax
je 0xbbbb3a
dec eax
dec eax
je 0xbbbb8a
xor bl, bl
push 0
push 1
lea ecx, [ebp - 0x2c]
call fcn.00bb4ca8
mov al, bl
pop esi
jmp 0xbbbb90
mov edx, dword [ebp - 0x2c]
jmp 0xbbbafb
mov byte [edi + 0x49], 0
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xbbbb46
lea eax, [ebp - 0x2c]
mov esi, dword [ebp - 0x10]
sub esi, eax
je 0xbbbb6c
cmp dword [ebp - 0x18], 0x10
mov eax, dword [ebp - 0x2c]
jae 0xbbbb59
lea eax, [ebp - 0x2c]
push dword [edi + 0x54]
push esi
push 1
push eax
call fcn.00bfd82e
add esp, 0x10
cmp esi, eax
jne 0xbbbb1e
cmp byte [edi + 0x49], 0
je 0xbbbb8a
test esi, esi
jne 0xbbbaed
push esi
push 8
lea esi, [ebp - 0x2c]
call fcn.00bbb67c
jmp 0xbbbaed
mov bl, 1
jmp 0xbbbb20
mov al, 1
mov ecx, dword [ebp - 0xc]
pop ebx
mov dword fs:[0], ecx
leave
ret

Function at 0xbc03d2
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bbc], 1
jne 0xbc0446
or dword [0xc58bbc], 1
mov dword [0xc54718], 0x29302a06
mov dword [0xc5471c], 0x2a2b6521
mov dword [0xc54720], 0x20226531
mov dword [0xc54724], 0x2c216531
mov dword [0xc54728], 0x212c3536
mov dword [0xc5472c], 0x65232a65
mov dword [0xc54730], 0x2d312028
mov dword [0xc54734], 0x6265212a
mov dword [0xc54738], 0x29292426
mov dword [0xc5473c], 0x45657f62
xor eax, eax
mov cl, byte [eax + 0xc54718]
xor cl, 0x45
mov byte [eax + 0xc5485c], cl
inc eax
cmp eax, 0x28
jb 0xbc0448
mov eax, 0xc5485c
ret

Function at 0xbc0463
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bb8], 1
jne 0xbc04ca
or dword [0xc58bb8], 1
mov dword [0xc54740], 0x292c2403
mov dword [0xc54744], 0x31652120
mov dword [0xc54748], 0x2b2c652a
mov dword [0xc5474c], 0x202e2a33
mov dword [0xc54750], 0x31202865
mov dword [0xc54754], 0x65212a2d
mov dword [0xc54758], 0x29242662
mov dword [0xc5475c], 0x657f6229
mov byte [0xc54760], 0x45
xor eax, eax
mov cl, byte [eax + 0xc54740]
xor cl, 0x45
mov byte [eax + 0xc54884], cl
inc eax
cmp eax, 0x21
jb 0xbc04cc
mov eax, 0xc54884
ret
Function at 0xbc04e7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bb4], 1
jne 0xbc0547
or dword [0xc58bb4], 1
mov dword [0xc54764], 0x2a37154f
mov dword [0xc54768], 0x29272427
mov dword [0xc5476c], 0x3021653c
mov dword [0xc54770], 0x2a316520
mov dword [0xc54774], 0x37263665
mov dword [0xc54778], 0x6531352c
mov dword [0xc5477c], 0x2a373720
mov dword [0xc54780], 0x45657f37
xor eax, eax
mov cl, byte [eax + 0xc54764]
xor cl, 0x45
mov byte [eax + 0xc548a8], cl
inc eax
cmp eax, 0x20
jb 0xbc0549
mov eax, 0xc548a8
ret

Function at 0xbc0b24
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 0xbc0c69
mov ebx, dword [ebp + 8]
push 4
sub ebx, edi
pop esi
test byte [0xc58bb0], 1
jne 0xbc0b86
or dword [0xc58bb0], 1
mov eax, 0x7836
mov word [0xc54784], ax
add eax, 0xffffffea
mov word [0xc54786], ax
mov eax, 0x782b
mov word [0xc54788], ax
add eax, 0xfffffff6
mov word [0xc5478a], ax
mov eax, 0x7845
mov word [0xc5478c], ax
xor eax, eax
mov ecx, 0x7845
xor cx, word [eax + 0xc54784]
add eax, 2
mov word [eax + 0xc548c6], cx
cmp eax, 0xa
jb 0xbc0b88
mov eax, dword [ebx + edi]
mov ecx, 0xc548c8
mov dx, word [eax]
cmp dx, word [ecx]
jne 0xbc0bcf
test dx, dx
je 0xbc0bcb
mov dx, word [eax + 2]
cmp dx, word [ecx + 2]
jne 0xbc0bcf
add eax, esi
add ecx, esi
test dx, dx
jne 0xbc0bab
xor eax, eax
jmp 0xbc0bd4
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xbc0be0
mov dword [edi], 0x385
jmp 0xbc0c58
call fcn.00bc0c79
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xbc0c0c
test dx, dx
je 0xbc0c08
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xbc0c0c
add ecx, esi
add eax, esi
test dx, dx
jne 0xbc0be8
xor eax, eax
jmp 0xbc0c11
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xbc0c1d
mov dword [edi], 0x386
jmp 0xbc0c58
call fcn.00bc0d4c
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xbc0c49
test dx, dx
je 0xbc0c45
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xbc0c49
add ecx, esi
add eax, esi
test dx, dx
jne 0xbc0c25
xor eax, eax
jmp 0xbc0c4e
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xbc0c72
mov dword [edi], 0x387
inc dword [ebp - 4]
mov eax, dword [ebp - 4]
add edi, esi
cmp eax, dword [ebp + 0xc]
jb 0xbc0b43
xor eax, eax
pop edi
pop esi
pop ebx
leave
ret 8
mov eax, 0x80020006
jmp 0xbc0c6b
Function at 0xbc0c79
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58bac], 1
jne 0xbc0d29
or dword [0xc58bac], 1
mov eax, 0x7824
mov word [0xc54790], ax
add eax, 0xfffffffd
mov ecx, eax
mov word [0xc54794], ax
mov eax, 0x7800
mov word [0xc54796], ax
add eax, 0x33
mov word [0xc54798], ax
mov eax, 0x7820
mov word [0xc54792], cx
mov ecx, eax
lea edx, [eax + 0xb]
mov word [0xc5479a], cx
mov ecx, edx
push edi
mov word [0xc5479c], cx
add ecx, 6
mov edi, ecx
mov word [0xc5479e], di
lea edi, [eax - 0x17]
mov word [0xc547a0], di
add edi, 0x23
mov ecx, eax
add eax, 0x17
mov word [0xc547ae], ax
lea eax, [ecx + 0x25]
mov word [0xc547a2], di
mov dword [0xc547a4], 0x78317836
mov word [0xc547a8], cx
mov dword [0xc547aa], 0x7820782b
mov word [0xc547b0], ax
pop edi
xor eax, eax
mov ecx, 0x7845
xor cx, word [eax + 0xc54790]
add eax, 2
mov word [eax + 0xc548d2], cx
cmp eax, 0x22
jb 0xbc0d2b
mov eax, 0xc548d4
ret

Function at 0xbc0d4c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58ba8], 1
mov ecx, 0x7845
jne 0xbc0da6
or dword [0xc58ba8], 1
lea eax, [ecx - 0x12]
mov word [0xc547b4], ax
add eax, 0xffffffed
mov word [0xc547b6], ax
lea eax, [ecx - 0xe]
mov word [0xc547b8], ax
dec eax
mov word [0xc547ba], ax
lea eax, [ecx - 0x19]
mov word [0xc547bc], ax
add eax, 0xfffffffe
mov word [0xc547be], ax
lea eax, [ecx - 0x1a]
mov word [0xc547c0], ax
mov eax, ecx
mov word [0xc547c2], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xc547b4]
add eax, 2
mov word [eax + 0xc548f6], dx
cmp eax, 0x10
jb 0xbc0da8
mov eax, 0xc548f8
ret

Function at 0xbc1765
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58ba4], 1
mov edx, 0x7845
jne 0xbc17c8
or dword [0xc58ba4], 1
lea ecx, [edx - 0x25]
mov eax, ecx
mov word [0xc547c4], ax
add eax, 0x17
push esi
mov esi, eax
lea eax, [edx - 0x3c]
mov word [0xc547ce], ax
add eax, 0x23
mov word [0xc547d0], ax
mov eax, edx
mov word [0xc547c6], si
mov word [0xc547c8], si
mov dword [0xc547ca], 0x7837782a
mov dword [0xc547d2], 0x7820782b
mov word [0xc547d6], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xc547c4]
add eax, 2
mov word [eax + 0xc54906], cx
cmp eax, 0x14
jb 0xbc17ca
mov eax, 0xc54908
ret

Function at 0xbc17e8
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58ba0], 1
jne 0xbc1884
or dword [0xc58ba0], 1
mov edx, 0x7820
mov eax, edx
mov word [0xc547d8], ax
add eax, 0x17
mov ecx, eax
mov word [0xc547da], cx
mov word [0xc547dc], cx
lea ecx, [edx + 0xa]
mov word [0xc547de], cx
mov ecx, eax
mov word [0xc547e0], cx
lea ecx, [edx - 0x1a]
mov word [0xc547e2], cx
add ecx, 0x27
mov word [0xc547e4], cx
lea ecx, [edx + 4]
push edi
mov edi, ecx
mov word [0xc547e6], di
mov edi, eax
mov word [0xc547ea], cx
mov word [0xc547f2], ax
add ecx, 2
lea eax, [edx + 0x25]
mov word [0xc547e8], di
mov word [0xc547ec], cx
mov dword [0xc547ee], 0x78207831
mov word [0xc547f4], ax
pop edi
xor eax, eax
mov ecx, 0x7845
xor cx, word [eax + 0xc547d8]
add eax, 2
mov word [eax + 0xc5491a], cx
cmp eax, 0x1e
jb 0xbc1886
mov eax, 0xc5491c
ret
Function at 0xbc18a7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b9c], 1
jne 0xbc1908
or dword [0xc58b9c], 1
mov edx, 0x7820
mov eax, edx
mov word [0xc547f8], ax
add eax, 0x17
mov ecx, eax
mov word [0xc547fa], cx
mov word [0xc547fc], cx
push edi
lea ecx, [edx + 0xa]
mov edi, ecx
mov word [0xc54800], ax
lea eax, [edx + 0x25]
mov word [0xc547fe], di
mov dword [0xc54802], 0x782a7806
mov dword [0xc54806], 0x78207821
mov word [0xc5480a], ax
pop edi
xor eax, eax
mov ecx, 0x7845
xor cx, word [eax + 0xc547f8]
add eax, 2
mov word [eax + 0xc5493a], cx
cmp eax, 0x14
jb 0xbc190a
mov eax, 0xc5493c
ret

Function at 0xbc192b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b98], 1
mov edx, 0x7845
jne 0xbc19a8
or dword [0xc58b98], 1
lea ecx, [edx - 0x25]
mov eax, ecx
mov word [0xc5480c], ax
add eax, 0x17
push esi
mov esi, eax
lea eax, [edx - 0x3d]
mov word [0xc54816], ax
mov eax, ecx
mov word [0xc54818], ax
add eax, 0x16
mov word [0xc5480e], si
mov word [0xc54810], si
mov esi, eax
mov word [0xc5481c], ax
lea eax, [edx - 0x21]
mov word [0xc5481e], ax
mov eax, edx
mov word [0xc5481a], si
mov dword [0xc54812], 0x7837782a
mov dword [0xc54820], 0x78207822
mov word [0xc54824], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xc5480c]
add eax, 2
mov word [eax + 0xc5494e], cx
cmp eax, 0x1a
jb 0xbc19aa
mov eax, 0xc54950
ret

Function at 0xbc19c8
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b94], 1
mov ecx, 0x7845
jne 0xbc1a27
or dword [0xc58b94], 1
lea eax, [ecx - 0x25]
mov word [0xc54828], ax
add eax, 0x17
mov edx, eax
mov word [0xc5482a], dx
mov word [0xc5482c], dx
lea edx, [ecx - 0x1b]
mov word [0xc5482e], dx
mov edx, eax
lea eax, [ecx - 0x1c]
mov word [0xc54836], ax
mov eax, ecx
mov word [0xc54830], dx
mov dword [0xc54832], 0x78377810
mov word [0xc54838], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xc54828]
add eax, 2
mov word [eax + 0xc5496a], dx
cmp eax, 0x12
jb 0xbc1a29
mov eax, 0xc5496c
ret

Function at 0xbc20cc
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b90], 1
jne 0xbc20f6
or dword [0xc58b90], 1
mov dword [0xc5483c], 0x29302b79
mov word [0xc54840], 0x7b29
mov byte [0xc54842], 0x45
xor eax, eax
mov cl, byte [eax + 0xc5483c]
xor cl, 0x45
mov byte [eax + 0xc54980], cl
inc eax
cmp eax, 7
jb 0xbc20f8
mov eax, 0xc54980
ret

Function at 0xbc2113
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b8c], 1
jne 0xbc213d
or dword [0xc58b8c], 1
mov dword [0xc54844], 0x29302b79
mov word [0xc54848], 0x7b29
mov byte [0xc5484a], 0x45
xor eax, eax
mov cl, byte [eax + 0xc54844]
xor cl, 0x45
mov byte [eax + 0xc54988], cl
inc eax
cmp eax, 7
jb 0xbc213f
mov eax, 0xc54988
ret

Function at 0xbc215a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b84], 1
jne 0xbc217e
or dword [0xc58b84], 1
mov dword [0xc54850], 0x2a261e65
mov dword [0xc54854], 0x45782021
xor eax, eax
mov cl, byte [eax + 0xc54850]
xor cl, 0x45
mov byte [eax + 0xc54994], cl
inc eax
cmp eax, 8
jb 0xbc2180
mov eax, 0xc54994
ret
Function at 0xbc2e8b
Capabilities:
Encode data using xor

Disassembly:
push esi
push edi
push 0x31
pop ecx
mov esi, 0xc2aab8
mov edi, 0xc58f40
push 0xc2ab7c
rep movsd dword es:[edi], dword [esi]
call fcn.00be26b0
pop ecx
pop edi
pop esi
cmp eax, 0xffffffff
jne 0xbc2eb1
xor al, al
ret
push 0xc2abe8
call fcn.00be2600
pop ecx
cmp eax, 0xffffffff
je 0xbc2eae
push 0xc2acf0
call fcn.00be1070
pop ecx
cmp eax, 0xffffffff
je 0xbc2eae
test byte [0xc58b78], 1
jne 0xbc2ef2
or dword [0xc58b78], 1
mov dword [0xc549b4], 0x77272e35
mov byte [0xc549b8], 0x46
xor eax, eax
mov cl, byte [eax + 0xc549b4]
xor cl, 0x46
mov byte [eax + 0xc54a80], cl
inc eax
cmp eax, 5
jb 0xbc2ef4
push 0xc54a80
call fcn.00be2720
pop ecx
mov dword [0xc4e928], eax
test eax, eax
js 0xbc2eae
call fcn.00bc2f7d
push eax
call fcn.00be10e0
pop ecx
mov dword [0xc4e92c], eax
test eax, eax
js 0xbc2eae
test byte [0xc58b70], 1
jne 0xbc2f50
or dword [0xc58b70], 1
mov dword [0xc549c4], 0x46352327
xor eax, eax
mov cl, byte [eax + 0xc549c4]
xor cl, 0x46
mov byte [eax + 0xc54a90], cl
inc eax
cmp eax, 4
jb 0xbc2f52
push 0xc54a90
call fcn.00be2670
test eax, eax
mov dword [0xc4e930], eax
pop ecx
setns al
ret

Function at 0xbc2f7d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b74], 1
jne 0xbc2fa1
or dword [0xc58b74], 1
mov dword [0xc549bc], 0x32342920
mov dword [0xc549c0], 0x46272833
xor eax, eax
mov cl, byte [eax + 0xc549bc]
xor cl, 0x46
mov byte [eax + 0xc54a88], cl
inc eax
cmp eax, 8
jb 0xbc2fa3
mov eax, 0xc54a88
ret

Function at 0xbc3221
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b6c], 1
jne 0xbc325f
or dword [0xc58b6c], 1
mov dword [0xc549c8], 0x2f66362b
mov dword [0xc549cc], 0x66322f28
mov dword [0xc549d0], 0x2a2f2720
mov word [0xc549d4], 0x2223
mov byte [0xc549d6], 0x46
xor eax, eax
mov cl, byte [eax + 0xc549c8]
xor cl, 0x46
mov byte [eax + 0xc54a94], cl
inc eax
cmp eax, 0xf
jb 0xbc3261
mov eax, 0xc54a94
ret

Function at 0xbc327c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b68], 1
jne 0xbc32ba
or dword [0xc58b68], 1
mov dword [0xc549d8], 0x2f66362b
mov dword [0xc549dc], 0x66322f28
mov dword [0xc549e0], 0x2a2f2720
mov word [0xc549e4], 0x2223
mov byte [0xc549e6], 0x46
xor eax, eax
mov cl, byte [eax + 0xc549d8]
xor cl, 0x46
mov byte [eax + 0xc54aa4], cl
inc eax
cmp eax, 0xf
jb 0xbc32bc
mov eax, 0xc54aa4
ret

Function at 0xbc32d7
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b64], 1
jne 0xbc3315
or dword [0xc58b64], 1
mov dword [0xc549e8], 0x19322335
mov dword [0xc549ec], 0x6632282f
mov dword [0xc549f0], 0x2a2f2720
mov word [0xc549f4], 0x2223
mov byte [0xc549f6], 0x46
xor eax, eax
mov cl, byte [eax + 0xc549e8]
xor cl, 0x46
mov byte [eax + 0xc54ab4], cl
inc eax
cmp eax, 0xf
jb 0xbc3317
mov eax, 0xc54ab4
ret
Function at 0xbc3332
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b60], 1
jne 0xbc337b
or dword [0xc58b60], 1
mov dword [0xc549f8], 0x2f352833
mov dword [0xc549fc], 0x22232821
mov dword [0xc54a00], 0x27233419
mov dword [0xc54a04], 0x27206622
mov dword [0xc54a08], 0x22232a2f
mov byte [0xc54a0c], 0x46
xor eax, eax
mov cl, byte [eax + 0xc549f8]
xor cl, 0x46
mov byte [eax + 0xc54ac4], cl
inc eax
cmp eax, 0x15
jb 0xbc337d
mov eax, 0xc54ac4
ret

Function at 0xbc3398
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b5c], 1
jne 0xbc33d7
or dword [0xc58b5c], 1
mov dword [0xc54a10], 0x21283436
mov dword [0xc54a14], 0x2d272b66
mov dword [0xc54a18], 0x27206623
mov dword [0xc54a1c], 0x22232a2f
mov byte [0xc54a20], 0x46
xor eax, eax
mov cl, byte [eax + 0xc54a10]
xor cl, 0x46
mov byte [eax + 0xc54adc], cl
inc eax
cmp eax, 0x11
jb 0xbc33d9
mov eax, 0xc54adc
ret

Function at 0xbc33f4
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b58], 1
jne 0xbc3436
or dword [0xc58b58], 1
mov dword [0xc54a24], 0x32342920
mov dword [0xc54a28], 0x19272833
mov dword [0xc54a2c], 0x22272334
mov dword [0xc54a30], 0x2f272066
mov dword [0xc54a34], 0x4622232a
xor eax, eax
mov cl, byte [eax + 0xc54a24]
xor cl, 0x46
mov byte [eax + 0xc54af0], cl
inc eax
cmp eax, 0x14
jb 0xbc3438
mov eax, 0xc54af0
ret

Function at 0xbc3453
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b54], 1
jne 0xbc349b
or dword [0xc58b54], 1
mov dword [0xc54a38], 0x363f3425
mov dword [0xc54a3c], 0x2f662932
mov dword [0xc54a40], 0x66322f28
mov dword [0xc54a44], 0x2a2f2720
mov word [0xc54a48], 0x2223
mov byte [0xc54a4a], 0x46
xor eax, eax
mov cl, byte [eax + 0xc54a38]
xor cl, 0x46
mov byte [eax + 0xc54b04], cl
inc eax
cmp eax, 0x13
jb 0xbc349d
mov eax, 0xc54b04
ret

Function at 0xbc36b0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b50], 1
jne 0xbc36d3
or dword [0xc58b50], 1
mov dword [0xc54a4c], 0x2235352f
mov word [0xc54a50], 0x462d
xor eax, eax
mov cl, byte [eax + 0xc54a4c]
xor cl, 0x46
mov byte [eax + 0xc54b18], cl
inc eax
cmp eax, 6
jb 0xbc36d5
mov eax, 0xc54b18
ret

Function at 0xbc36f0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b4c], 1
jne 0xbc371d
or dword [0xc58b4c], 1
mov dword [0xc54a54], 0x2434332e
mov dword [0xc54a58], 0x34332227
mov word [0xc54a5c], 0x4634
xor eax, eax
mov cl, byte [eax + 0xc54a54]
xor cl, 0x46
mov byte [eax + 0xc54b20], cl
inc eax
cmp eax, 0xa
jb 0xbc371f
mov eax, 0xc54b20
ret

Function at 0xbc37fd
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b48], 1
jne 0xbc382a
or dword [0xc58b48], 1
mov dword [0xc54a60], 0x2434332e
mov dword [0xc54a64], 0x34332227
mov word [0xc54a68], 0x4634
xor eax, eax
mov cl, byte [eax + 0xc54a60]
xor cl, 0x46
mov byte [eax + 0xc54b2c], cl
inc eax
cmp eax, 0xa
jb 0xbc382c
mov eax, 0xc54b2c
ret
Function at 0xbc3f16
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b44], 1
jne 0xbc3f5e
or dword [0xc58b44], 1
mov dword [0xc54b38], 0x373e3524
mov dword [0xc54b3c], 0x2e672833
mov dword [0xc54b40], 0x67332e29
mov dword [0xc54b44], 0x2b2e2621
mov word [0xc54b48], 0x2322
mov byte [0xc54b4a], 0x47
xor eax, eax
mov cl, byte [eax + 0xc54b38]
xor cl, 0x47
mov byte [eax + 0xc54c4c], cl
inc eax
cmp eax, 0x13
jb 0xbc3f60
mov eax, 0xc54c4c
ret

Function at 0xbc3f7b
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b40], 1
jne 0xbc3fc3
or dword [0xc58b40], 1
mov dword [0xc54b4c], 0x373e3524
mov dword [0xc54b50], 0x2e672833
mov dword [0xc54b54], 0x67332e29
mov dword [0xc54b58], 0x2b2e2621
mov word [0xc54b5c], 0x2322
mov byte [0xc54b5e], 0x47
xor eax, eax
mov cl, byte [eax + 0xc54b4c]
xor cl, 0x47
mov byte [eax + 0xc54c60], cl
inc eax
cmp eax, 0x13
jb 0xbc3fc5
mov eax, 0xc54c60
ret

Function at 0xbc3fe0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b38], 1
jne 0xbc4028
or dword [0xc58b38], 1
mov dword [0xc54b68], 0x373e3524
mov dword [0xc54b6c], 0x2e672833
mov dword [0xc54b70], 0x67332e29
mov dword [0xc54b74], 0x2b2e2621
mov word [0xc54b78], 0x2322
mov byte [0xc54b7a], 0x47
xor eax, eax
mov cl, byte [eax + 0xc54b68]
xor cl, 0x47
mov byte [eax + 0xc54c7c], cl
inc eax
cmp eax, 0x13
jb 0xbc402a
mov eax, 0xc54c7c
ret

Function at 0xbc4045
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b30], 1
jne 0xbc408d
or dword [0xc58b30], 1
mov dword [0xc54b80], 0x373e3524
mov dword [0xc54b84], 0x2e672833
mov dword [0xc54b88], 0x67332e29
mov dword [0xc54b8c], 0x2b2e2621
mov word [0xc54b90], 0x2322
mov byte [0xc54b92], 0x47
xor eax, eax
mov cl, byte [eax + 0xc54b80]
xor cl, 0x47
mov byte [eax + 0xc54c94], cl
inc eax
cmp eax, 0x13
jb 0xbc408f
mov eax, 0xc54c94
ret

Function at 0xbc40aa
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b2c], 1
jne 0xbc40e1
or dword [0xc58b2c], 1
mov dword [0xc54b94], 0x373e3524
mov dword [0xc54b98], 0x21672833
mov dword [0xc54b9c], 0x222b2e26
mov word [0xc54ba0], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54b94]
xor cl, 0x47
mov byte [eax + 0xc54ca8], cl
inc eax
cmp eax, 0xe
jb 0xbc40e3
mov eax, 0xc54ca8
ret

Function at 0xbc40fe
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b28], 1
jne 0xbc4135
or dword [0xc58b28], 1
mov dword [0xc54ba4], 0x373e3524
mov dword [0xc54ba8], 0x21672833
mov dword [0xc54bac], 0x222b2e26
mov word [0xc54bb0], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54ba4]
xor cl, 0x47
mov byte [eax + 0xc54cb8], cl
inc eax
cmp eax, 0xe
jb 0xbc4137
mov eax, 0xc54cb8
ret

Function at 0xbc4152
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b24], 1
jne 0xbc417f
or dword [0xc58b24], 1
mov dword [0xc54bb4], 0x3735222f
mov dword [0xc54bb8], 0x3522236c
mov word [0xc54bbc], 0x4737
xor eax, eax
mov cl, byte [eax + 0xc54bb4]
xor cl, 0x47
mov byte [eax + 0xc54cc8], cl
inc eax
cmp eax, 0xa
jb 0xbc4181
mov eax, 0xc54cc8
ret
Function at 0xbc419c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b20], 1
jne 0xbc41d3
or dword [0xc58b20], 1
mov dword [0xc54bc0], 0x373e3524
mov dword [0xc54bc4], 0x21672833
mov dword [0xc54bc8], 0x222b2e26
mov word [0xc54bcc], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54bc0]
xor cl, 0x47
mov byte [eax + 0xc54cd4], cl
inc eax
cmp eax, 0xe
jb 0xbc41d5
mov eax, 0xc54cd4
ret

Function at 0xbc41f0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b1c], 1
jne 0xbc4227
or dword [0xc58b1c], 1
mov dword [0xc54bd0], 0x373e3524
mov dword [0xc54bd4], 0x21672833
mov dword [0xc54bd8], 0x222b2e26
mov word [0xc54bdc], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54bd0]
xor cl, 0x47
mov byte [eax + 0xc54ce4], cl
inc eax
cmp eax, 0xe
jb 0xbc4229
mov eax, 0xc54ce4
ret

Function at 0xbc42f5
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b18], 1
jne 0xbc432c
or dword [0xc58b18], 1
mov dword [0xc54be0], 0x373e3524
mov dword [0xc54be4], 0x21672833
mov dword [0xc54be8], 0x222b2e26
mov word [0xc54bec], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54be0]
xor cl, 0x47
mov byte [eax + 0xc54cf4], cl
inc eax
cmp eax, 0xe
jb 0xbc432e
mov eax, 0xc54cf4
ret

Function at 0xbc44db
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b14], 1
jne 0xbc4512
or dword [0xc58b14], 1
mov dword [0xc54bf0], 0x373e3524
mov dword [0xc54bf4], 0x21672833
mov dword [0xc54bf8], 0x222b2e26
mov word [0xc54bfc], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54bf0]
xor cl, 0x47
mov byte [eax + 0xc54d04], cl
inc eax
cmp eax, 0xe
jb 0xbc4514
mov eax, 0xc54d04
ret

Function at 0xbc452f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xc58b10], 1
jne 0xbc4566
or dword [0xc58b10], 1
mov dword [0xc54c00], 0x373e3524
mov dword [0xc54c04], 0x21672833
mov dword [0xc54c08], 0x222b2e26
mov word [0xc54c0c], 0x4723
xor eax, eax
mov cl, byte [eax + 0xc54c00]
xor cl, 0x47
mov byte [eax + 0xc54d14], cl
inc eax
cmp eax, 0xe
jb 0xbc4568
mov eax, 0xc54d14
ret