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

Disassembly:
test byte [0xbb2bc4], 1
jne 0xb00565
or dword [0xbb2bc4], 1
mov dword [0xbae770], 0x5183a60
mov dword [0xbae774], 0x6080b08
mov dword [0xbae778], 0x1f0e4a13
mov dword [0xbae77c], 0x51e4a0f
mov dword [0xbae780], 0x1809194a
mov dword [0xbae784], 0x4a1e1a03
mov dword [0xbae788], 0x518180f
mov dword [0xbae78c], 0x6a4a5018
xor eax, eax
mov cl, byte [eax + 0xbae770]
xor cl, 0x6a
mov byte [eax + 0xbae8b4], cl
inc eax
cmp eax, 0x20
jb 0xb00567
mov eax, 0xbae8b4
ret

Function at 0xb00b2d
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 0xb00c72
mov ebx, dword [ebp + 8]
push 4
sub ebx, edi
pop esi
test byte [0xbb2bc0], 1
jne 0xb00b8f
or dword [0xbb2bc0], 1
mov eax, 0xd819
mov word [0xbae790], ax
add eax, 0xfffffff6
mov word [0xbae792], ax
mov eax, 0xd804
mov word [0xbae794], ax
add eax, 0xa
mov word [0xbae796], ax
mov eax, 0xd86a
mov word [0xbae798], ax
xor eax, eax
mov ecx, 0xd86a
xor cx, word [eax + 0xbae790]
add eax, 2
mov word [eax + 0xbae8d2], cx
cmp eax, 0xa
jb 0xb00b91
mov eax, dword [ebx + edi]
mov ecx, 0xbae8d4
mov dx, word [eax]
cmp dx, word [ecx]
jne 0xb00bd8
test dx, dx
je 0xb00bd4
mov dx, word [eax + 2]
cmp dx, word [ecx + 2]
jne 0xb00bd8
add eax, esi
add ecx, esi
test dx, dx
jne 0xb00bb4
xor eax, eax
jmp 0xb00bdd
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xb00be9
mov dword [edi], 0x385
jmp 0xb00c61
call fcn.00b00c82
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xb00c15
test dx, dx
je 0xb00c11
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xb00c15
add ecx, esi
add eax, esi
test dx, dx
jne 0xb00bf1
xor eax, eax
jmp 0xb00c1a
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xb00c26
mov dword [edi], 0x386
jmp 0xb00c61
call fcn.00b00d55
mov ecx, dword [ebx + edi]
mov dx, word [ecx]
cmp dx, word [eax]
jne 0xb00c52
test dx, dx
je 0xb00c4e
mov dx, word [ecx + 2]
cmp dx, word [eax + 2]
jne 0xb00c52
add ecx, esi
add eax, esi
test dx, dx
jne 0xb00c2e
xor eax, eax
jmp 0xb00c57
sbb eax, eax
sbb eax, 0xffffffff
test eax, eax
jne 0xb00c7b
mov dword [edi], 0x387
inc dword [ebp - 4]
mov eax, dword [ebp - 4]
add edi, esi
cmp eax, dword [ebp + 0xc]
jb 0xb00b4c
xor eax, eax
pop edi
pop esi
pop ebx
leave
ret 8
mov eax, 0x80020006
jmp 0xb00c74
Function at 0xb00c82
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2bbc], 1
jne 0xb00d32
or dword [0xbb2bbc], 1
mov eax, 0xd80b
mov word [0xbae79c], ax
add eax, 3
mov ecx, eax
mov word [0xbae7a0], ax
mov eax, 0xd82f
mov word [0xbae7a2], ax
add eax, 0xffffffed
mov word [0xbae7a4], ax
mov eax, 0xd80f
mov word [0xbae79e], cx
mov ecx, eax
lea edx, [eax - 0xb]
mov word [0xbae7a6], cx
mov ecx, edx
push edi
mov word [0xbae7a8], cx
add ecx, 0x1a
mov edi, ecx
mov word [0xbae7aa], di
lea edi, [eax + 0x17]
mov word [0xbae7ac], di
add edi, 0xffffffdd
mov ecx, eax
add eax, 9
mov word [0xbae7ba], ax
lea eax, [ecx + 0x5b]
mov word [0xbae7ae], di
mov dword [0xbae7b0], 0xd81ed819
mov word [0xbae7b4], cx
mov dword [0xbae7b6], 0xd80fd804
mov word [0xbae7bc], ax
pop edi
xor eax, eax
mov ecx, 0xd86a
xor cx, word [eax + 0xbae79c]
add eax, 2
mov word [eax + 0xbae8de], cx
cmp eax, 0x22
jb 0xb00d34
mov eax, 0xbae8e0
ret

Function at 0xb00d55
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2bb8], 1
mov ecx, 0xd86a
jne 0xb00daf
or dword [0xbb2bb8], 1
lea eax, [ecx - 0x4e]
mov word [0xbae7c0], ax
add eax, 0xfffffff3
mov word [0xbae7c2], ax
lea eax, [ecx - 0x52]
mov word [0xbae7c4], ax
inc eax
mov word [0xbae7c6], ax
lea eax, [ecx - 0x67]
mov word [0xbae7c8], ax
add eax, 2
mov word [0xbae7ca], ax
lea eax, [ecx - 0x66]
mov word [0xbae7cc], ax
mov eax, ecx
mov word [0xbae7ce], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xbae7c0]
add eax, 2
mov word [eax + 0xbae902], dx
cmp eax, 0x10
jb 0xb00db1
mov eax, 0xbae904
ret

Function at 0xb0176e
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2bb4], 1
mov edx, 0xd86a
jne 0xb017d1
or dword [0xbb2bb4], 1
lea ecx, [edx - 0x5b]
mov eax, ecx
mov word [0xbae7d0], ax
add eax, 9
push esi
mov esi, eax
lea eax, [edx - 0x44]
mov word [0xbae7da], ax
add eax, 0xffffffdd
mov word [0xbae7dc], ax
mov eax, edx
mov word [0xbae7d2], si
mov word [0xbae7d4], si
mov dword [0xbae7d6], 0xd818d805
mov dword [0xbae7de], 0xd80fd804
mov word [0xbae7e2], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xbae7d0]
add eax, 2
mov word [eax + 0xbae912], cx
cmp eax, 0x14
jb 0xb017d3
mov eax, 0xbae914
ret

Function at 0xb017f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2bb0], 1
jne 0xb0188d
or dword [0xbb2bb0], 1
mov edx, 0xd80f
mov eax, edx
mov word [0xbae7e4], ax
add eax, 9
mov ecx, eax
mov word [0xbae7e6], cx
mov word [0xbae7e8], cx
lea ecx, [edx - 0xa]
mov word [0xbae7ea], cx
mov ecx, eax
mov word [0xbae7ec], cx
lea ecx, [edx + 0x1a]
mov word [0xbae7ee], cx
add ecx, 0xffffffd9
mov word [0xbae7f0], cx
lea ecx, [edx - 4]
push edi
mov edi, ecx
mov word [0xbae7f2], di
mov edi, eax
mov word [0xbae7f6], cx
mov word [0xbae7fe], ax
add ecx, 0xfffffffe
lea eax, [edx + 0x5b]
mov word [0xbae7f4], di
mov word [0xbae7f8], cx
mov dword [0xbae7fa], 0xd80fd81e
mov word [0xbae800], ax
pop edi
xor eax, eax
mov ecx, 0xd86a
xor cx, word [eax + 0xbae7e4]
add eax, 2
mov word [eax + 0xbae926], cx
cmp eax, 0x1e
jb 0xb0188f
mov eax, 0xbae928
ret
Function at 0xb018b0
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2bac], 1
jne 0xb01911
or dword [0xbb2bac], 1
mov edx, 0xd80f
mov eax, edx
mov word [0xbae804], ax
add eax, 9
mov ecx, eax
mov word [0xbae806], cx
mov word [0xbae808], cx
push edi
lea ecx, [edx - 0xa]
mov edi, ecx
mov word [0xbae80c], ax
lea eax, [edx + 0x5b]
mov word [0xbae80a], di
mov dword [0xbae80e], 0xd805d829
mov dword [0xbae812], 0xd80fd80e
mov word [0xbae816], ax
pop edi
xor eax, eax
mov ecx, 0xd86a
xor cx, word [eax + 0xbae804]
add eax, 2
mov word [eax + 0xbae946], cx
cmp eax, 0x14
jb 0xb01913
mov eax, 0xbae948
ret

Function at 0xb01934
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2ba8], 1
mov edx, 0xd86a
jne 0xb019b1
or dword [0xbb2ba8], 1
lea ecx, [edx - 0x5b]
mov eax, ecx
mov word [0xbae818], ax
add eax, 9
push esi
mov esi, eax
lea eax, [edx - 0x43]
mov word [0xbae822], ax
mov eax, ecx
mov word [0xbae824], ax
add eax, 0xa
mov word [0xbae81a], si
mov word [0xbae81c], si
mov esi, eax
mov word [0xbae828], ax
lea eax, [edx - 0x5f]
mov word [0xbae82a], ax
mov eax, edx
mov word [0xbae826], si
mov dword [0xbae81e], 0xd818d805
mov dword [0xbae82c], 0xd80fd80d
mov word [0xbae830], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0xbae818]
add eax, 2
mov word [eax + 0xbae95a], cx
cmp eax, 0x1a
jb 0xb019b3
mov eax, 0xbae95c
ret

Function at 0xb019d1
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2ba4], 1
mov ecx, 0xd86a
jne 0xb01a30
or dword [0xbb2ba4], 1
lea eax, [ecx - 0x5b]
mov word [0xbae834], ax
add eax, 9
mov edx, eax
mov word [0xbae836], dx
mov word [0xbae838], dx
lea edx, [ecx - 0x65]
mov word [0xbae83a], dx
mov edx, eax
lea eax, [ecx - 0x64]
mov word [0xbae842], ax
mov eax, ecx
mov word [0xbae83c], dx
mov dword [0xbae83e], 0xd818d83f
mov word [0xbae844], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0xbae834]
add eax, 2
mov word [eax + 0xbae976], dx
cmp eax, 0x12
jb 0xb01a32
mov eax, 0xbae978
ret

Function at 0xb020d5
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2ba0], 1
jne 0xb020ff
or dword [0xbb2ba0], 1
mov dword [0xbae848], 0x61f0456
mov word [0xbae84c], 0x5406
mov byte [0xbae84e], 0x6a
xor eax, eax
mov cl, byte [eax + 0xbae848]
xor cl, 0x6a
mov byte [eax + 0xbae98c], cl
inc eax
cmp eax, 7
jb 0xb02101
mov eax, 0xbae98c
ret

Function at 0xb0211c
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b9c], 1
jne 0xb02146
or dword [0xbb2b9c], 1
mov dword [0xbae850], 0x61f0456
mov word [0xbae854], 0x5406
mov byte [0xbae856], 0x6a
xor eax, eax
mov cl, byte [eax + 0xbae850]
xor cl, 0x6a
mov byte [eax + 0xbae994], cl
inc eax
cmp eax, 7
jb 0xb02148
mov eax, 0xbae994
ret

Function at 0xb02163
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b94], 1
jne 0xb02187
or dword [0xbb2b94], 1
mov dword [0xbae85c], 0x509314a
mov dword [0xbae860], 0x6a570f0e
xor eax, eax
mov cl, byte [eax + 0xbae85c]
xor cl, 0x6a
mov byte [eax + 0xbae9a0], cl
inc eax
cmp eax, 8
jb 0xb02189
mov eax, 0xbae9a0
ret
Function at 0xb02ec8
Capabilities:
Encode data using xor

Disassembly:
push esi
push edi
push 0x31
pop ecx
mov esi, 0xb82ac8
mov edi, 0xbb2f40
push 0xb82b8c
rep movsd dword es:[edi], dword [esi]
call fcn.00b3a630
pop ecx
pop edi
pop esi
cmp eax, 0xffffffff
jne 0xb02eee
xor al, al
ret
push 0xb82bf8
call fcn.00b3a580
pop ecx
cmp eax, 0xffffffff
je 0xb02eeb
push 0xb82d00
call fcn.00b38ff0
pop ecx
cmp eax, 0xffffffff
je 0xb02eeb
test byte [0xbb2b88], 1
jne 0xb02f2f
or dword [0xbb2b88], 1
mov dword [0xbae9c0], 0x5a0a0318
mov byte [0xbae9c4], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbae9c0]
xor cl, 0x6b
mov byte [eax + 0xbaea8c], cl
inc eax
cmp eax, 5
jb 0xb02f31
push 0xbaea8c
call fcn.00b3a6a0
pop ecx
mov dword [0xba8928], eax
test eax, eax
js 0xb02eeb
call fcn.00b02fba
push eax
call fcn.00b39060
pop ecx
mov dword [0xba892c], eax
test eax, eax
js 0xb02eeb
test byte [0xbb2b80], 1
jne 0xb02f8d
or dword [0xbb2b80], 1
mov dword [0xbae9d0], 0x6b180e0a
xor eax, eax
mov cl, byte [eax + 0xbae9d0]
xor cl, 0x6b
mov byte [eax + 0xbaea9c], cl
inc eax
cmp eax, 4
jb 0xb02f8f
push 0xbaea9c
call fcn.00b3a5f0
test eax, eax
mov dword [0xba8930], eax
pop ecx
setns al
ret

Function at 0xb02fba
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b84], 1
jne 0xb02fde
or dword [0xbb2b84], 1
mov dword [0xbae9c8], 0x1f19040d
mov dword [0xbae9cc], 0x6b0a051e
xor eax, eax
mov cl, byte [eax + 0xbae9c8]
xor cl, 0x6b
mov byte [eax + 0xbaea94], cl
inc eax
cmp eax, 8
jb 0xb02fe0
mov eax, 0xbaea94
ret

Function at 0xb0325e
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b7c], 1
jne 0xb0329c
or dword [0xbb2b7c], 1
mov dword [0xbae9d4], 0x24b1b06
mov dword [0xbae9d8], 0x4b1f0205
mov dword [0xbae9dc], 0x7020a0d
mov word [0xbae9e0], 0xf0e
mov byte [0xbae9e2], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbae9d4]
xor cl, 0x6b
mov byte [eax + 0xbaeaa0], cl
inc eax
cmp eax, 0xf
jb 0xb0329e
mov eax, 0xbaeaa0
ret

Function at 0xb032b9
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b78], 1
jne 0xb032f7
or dword [0xbb2b78], 1
mov dword [0xbae9e4], 0x24b1b06
mov dword [0xbae9e8], 0x4b1f0205
mov dword [0xbae9ec], 0x7020a0d
mov word [0xbae9f0], 0xf0e
mov byte [0xbae9f2], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbae9e4]
xor cl, 0x6b
mov byte [eax + 0xbaeab0], cl
inc eax
cmp eax, 0xf
jb 0xb032f9
mov eax, 0xbaeab0
ret

Function at 0xb03314
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b74], 1
jne 0xb03352
or dword [0xbb2b74], 1
mov dword [0xbae9f4], 0x341f0e18
mov dword [0xbae9f8], 0x4b1f0502
mov dword [0xbae9fc], 0x7020a0d
mov word [0xbaea00], 0xf0e
mov byte [0xbaea02], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbae9f4]
xor cl, 0x6b
mov byte [eax + 0xbaeac0], cl
inc eax
cmp eax, 0xf
jb 0xb03354
mov eax, 0xbaeac0
ret
Function at 0xb0336f
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b70], 1
jne 0xb033b8
or dword [0xbb2b70], 1
mov dword [0xbaea04], 0x218051e
mov dword [0xbaea08], 0xf0e050c
mov dword [0xbaea0c], 0xa0e1934
mov dword [0xbaea10], 0xa0d4b0f
mov dword [0xbaea14], 0xf0e0702
mov byte [0xbaea18], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbaea04]
xor cl, 0x6b
mov byte [eax + 0xbaead0], cl
inc eax
cmp eax, 0x15
jb 0xb033ba
mov eax, 0xbaead0
ret

Function at 0xb033d5
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b6c], 1
jne 0xb03416
or dword [0xbb2b6c], 1
mov dword [0xbaea1c], 0xc05191b
mov dword [0xbaea20], 0xa064b
mov dword [0xbaea24], 0xa0d4b0e
mov dword [0xbaea28], 0xf0e0702
mov byte [0xbaea2c], 0x6b
mov cl, byte [eax + 0xbaea1c]
xor cl, 0x6b
mov byte [eax + 0xbaeae8], cl
inc eax
cmp eax, 0x11
jb 0xb03416
mov eax, 0xbaeae8
ret

Function at 0xb03431
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b68], 1
jne 0xb03473
or dword [0xbb2b68], 1
mov dword [0xbaea30], 0x1f19040d
mov dword [0xbaea34], 0x340a051e
mov dword [0xbaea38], 0xf0a0e19
mov dword [0xbaea3c], 0x20a0d4b
mov dword [0xbaea40], 0x6b0f0e07
xor eax, eax
mov cl, byte [eax + 0xbaea30]
xor cl, 0x6b
mov byte [eax + 0xbaeafc], cl
inc eax
cmp eax, 0x14
jb 0xb03475
mov eax, 0xbaeafc
ret

Function at 0xb03490
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b64], 1
jne 0xb034d8
or dword [0xbb2b64], 1
mov dword [0xbaea44], 0x1b121908
mov dword [0xbaea48], 0x24b041f
mov dword [0xbaea4c], 0x4b1f0205
mov dword [0xbaea50], 0x7020a0d
mov word [0xbaea54], 0xf0e
mov byte [0xbaea56], 0x6b
xor eax, eax
mov cl, byte [eax + 0xbaea44]
xor cl, 0x6b
mov byte [eax + 0xbaeb10], cl
inc eax
cmp eax, 0x13
jb 0xb034da
mov eax, 0xbaeb10
ret

Function at 0xb036ed
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b60], 1
jne 0xb03712
or dword [0xbb2b60], 1
mov dword [0xbaea58], 0xf181802
mov word [0xbaea5c], 0x6b00
mov cl, byte [eax + 0xbaea58]
xor cl, 0x6b
mov byte [eax + 0xbaeb24], cl
inc eax
cmp eax, 6
jb 0xb03712
mov eax, 0xbaeb24
ret

Function at 0xb0372d
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b5c], 1
jne 0xb0375a
or dword [0xbb2b5c], 1
mov dword [0xbaea60], 0x9191e03
mov dword [0xbaea64], 0x191e0f0a
mov word [0xbaea68], 0x6b19
xor eax, eax
mov cl, byte [eax + 0xbaea60]
xor cl, 0x6b
mov byte [eax + 0xbaeb2c], cl
inc eax
cmp eax, 0xa
jb 0xb0375c
mov eax, 0xbaeb2c
ret

Function at 0xb0383a
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b58], 1
jne 0xb03867
or dword [0xbb2b58], 1
mov dword [0xbaea6c], 0x9191e03
mov dword [0xbaea70], 0x191e0f0a
mov word [0xbaea74], 0x6b19
xor eax, eax
mov cl, byte [eax + 0xbaea6c]
xor cl, 0x6b
mov byte [eax + 0xbaeb38], cl
inc eax
cmp eax, 0xa
jb 0xb03869
mov eax, 0xbaeb38
ret
Function at 0xb03f53
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b54], 1
jne 0xb03f9d
or dword [0xbb2b54], 1
mov dword [0xbaeb44], 0x1c151e0f
mov dword [0xbaeb48], 0x54c0318
mov dword [0xbaeb4c], 0x4c180502
mov dword [0xbaeb50], 0x50d0a
mov word [0xbaeb54], 0x809
mov byte [0xbaeb56], 0x6c
mov cl, byte [eax + 0xbaeb44]
xor cl, 0x6c
mov byte [eax + 0xbaec58], cl
inc eax
cmp eax, 0x13
jb 0xb03f9d
mov eax, 0xbaec58
ret

Function at 0xb03fbb
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b50], 1
jne 0xb04005
or dword [0xbb2b50], 1
mov dword [0xbaeb58], 0x1c151e0f
mov dword [0xbaeb5c], 0x54c0318
mov dword [0xbaeb60], 0x4c180502
mov dword [0xbaeb64], 0x50d0a
mov word [0xbaeb68], 0x809
mov byte [0xbaeb6a], 0x6c
mov cl, byte [eax + 0xbaeb58]
xor cl, 0x6c
mov byte [eax + 0xbaec6c], cl
inc eax
cmp eax, 0x13
jb 0xb04005
mov eax, 0xbaec6c
ret

Function at 0xb04020
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b48], 1
jne 0xb0406a
or dword [0xbb2b48], 1
mov dword [0xbaeb74], 0x1c151e0f
mov dword [0xbaeb78], 0x54c0318
mov dword [0xbaeb7c], 0x4c180502
mov dword [0xbaeb80], 0x50d0a
mov word [0xbaeb84], 0x809
mov byte [0xbaeb86], 0x6c
mov cl, byte [eax + 0xbaeb74]
xor cl, 0x6c
mov byte [eax + 0xbaec88], cl
inc eax
cmp eax, 0x13
jb 0xb0406a
mov eax, 0xbaec88
ret

Function at 0xb04085
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b40], 1
jne 0xb040cf
or dword [0xbb2b40], 1
mov dword [0xbaeb8c], 0x1c151e0f
mov dword [0xbaeb90], 0x54c0318
mov dword [0xbaeb94], 0x4c180502
mov dword [0xbaeb98], 0x50d0a
mov word [0xbaeb9c], 0x809
mov byte [0xbaeb9e], 0x6c
mov cl, byte [eax + 0xbaeb8c]
xor cl, 0x6c
mov byte [eax + 0xbaeca0], cl
inc eax
cmp eax, 0x13
jb 0xb040cf
mov eax, 0xbaeca0
ret

Function at 0xb040ea
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b3c], 1
jne 0xb04123
or dword [0xbb2b3c], 1
mov dword [0xbaeba0], 0x1c151e0f
mov dword [0xbaeba4], 0xa4c0318
mov dword [0xbaeba8], 0x900050d
mov word [0xbaebac], 0x6c08
mov cl, byte [eax + 0xbaeba0]
xor cl, 0x6c
mov byte [eax + 0xbaecb4], cl
inc eax
cmp eax, 0xe
jb 0xb04123
mov eax, 0xbaecb4
ret

Function at 0xb0413e
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b38], 1
jne 0xb04177
or dword [0xbb2b38], 1
mov dword [0xbaebb0], 0x1c151e0f
mov dword [0xbaebb4], 0xa4c0318
mov dword [0xbaebb8], 0x900050d
mov word [0xbaebbc], 0x6c08
mov cl, byte [eax + 0xbaebb0]
xor cl, 0x6c
mov byte [eax + 0xbaecc4], cl
inc eax
cmp eax, 0xe
jb 0xb04177
mov eax, 0xbaecc4
ret

Function at 0xb04192
Capabilities:
Encode data using xor

Disassembly:
test byte [0xbb2b34], 1
jne 0xb041bf
or dword [0xbb2b34], 1
mov dword [0xbaebc0], 0x1c1e0904
mov dword [0xbaebc4], 0x1e090847
mov word [0xbaebc8], 0x6c1c
xor eax, eax
mov cl, byte [eax + 0xbaebc0]
xor cl, 0x6c
mov byte [eax + 0xbaecd4], cl
inc eax
cmp eax, 0xa
jb 0xb041c1
mov eax, 0xbaecd4
ret
Function at 0xb041dc
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b30], 1
jne 0xb04215
or dword [0xbb2b30], 1
mov dword [0xbaebcc], 0x1c151e0f
mov dword [0xbaebd0], 0xa4c0318
mov dword [0xbaebd4], 0x900050d
mov word [0xbaebd8], 0x6c08
mov cl, byte [eax + 0xbaebcc]
xor cl, 0x6c
mov byte [eax + 0xbaece0], cl
inc eax
cmp eax, 0xe
jb 0xb04215
mov eax, 0xbaece0
ret

Function at 0xb04230
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b2c], 1
jne 0xb04269
or dword [0xbb2b2c], 1
mov dword [0xbaebdc], 0x1c151e0f
mov dword [0xbaebe0], 0xa4c0318
mov dword [0xbaebe4], 0x900050d
mov word [0xbaebe8], 0x6c08
mov cl, byte [eax + 0xbaebdc]
xor cl, 0x6c
mov byte [eax + 0xbaecf0], cl
inc eax
cmp eax, 0xe
jb 0xb04269
mov eax, 0xbaecf0
ret

Function at 0xb04335
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b28], 1
jne 0xb0436e
or dword [0xbb2b28], 1
mov dword [0xbaebec], 0x1c151e0f
mov dword [0xbaebf0], 0xa4c0318
mov dword [0xbaebf4], 0x900050d
mov word [0xbaebf8], 0x6c08
mov cl, byte [eax + 0xbaebec]
xor cl, 0x6c
mov byte [eax + 0xbaed00], cl
inc eax
cmp eax, 0xe
jb 0xb0436e
mov eax, 0xbaed00
ret

Function at 0xb0451b
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b24], 1
jne 0xb04554
or dword [0xbb2b24], 1
mov dword [0xbaebfc], 0x1c151e0f
mov dword [0xbaec00], 0xa4c0318
mov dword [0xbaec04], 0x900050d
mov word [0xbaec08], 0x6c08
mov cl, byte [eax + 0xbaebfc]
xor cl, 0x6c
mov byte [eax + 0xbaed10], cl
inc eax
cmp eax, 0xe
jb 0xb04554
mov eax, 0xbaed10
ret

Function at 0xb0456f
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b20], 1
jne 0xb045a8
or dword [0xbb2b20], 1
mov dword [0xbaec0c], 0x1c151e0f
mov dword [0xbaec10], 0xa4c0318
mov dword [0xbaec14], 0x900050d
mov word [0xbaec18], 0x6c08
mov cl, byte [eax + 0xbaec0c]
xor cl, 0x6c
mov byte [eax + 0xbaed20], cl
inc eax
cmp eax, 0xe
jb 0xb045a8
mov eax, 0xbaed20
ret
Function at 0xb045c3
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0xb7a499
call fcn.00b79c88
sub esp, 0x10
push ebx
push esi
mov esi, 0x110
push esi
call fcn.00b54410
xor ebx, ebx
pop ecx
mov dword [ebp - 0x10], eax
cmp eax, ebx
je 0xb045f7
push esi
push ebx
push eax
call fcn.00b56f70
mov esi, dword [ebp - 0x10]
add esp, 0xc
jmp 0xb045f9
xor esi, esi
mov dword [ebp - 0x10], esi
mov dword [ebp - 4], ebx
mov eax, dword [edi + 4]
mov dword [esi + 0x100], eax
mov eax, dword [edi + 8]
sub eax, 0x14
test byte [0xbb2b18], 1
mov dword [esi + 0x104], eax
mov eax, dword [edi + 0xc]
mov dword [esi + 0x108], eax
mov eax, dword [ebp + 8]
mov dword [esi + 0x10c], eax
jne 0xb04647
or dword [0xbb2b18], 1
mov dword [0xbaec30], 0xe03000e
mov byte [0xbaec34], 0x6c
xor eax, eax
mov cl, byte [eax + 0xbaec30]
xor cl, 0x6c
mov byte [eax + 0xbaed30], cl
inc eax
cmp eax, 5
jb 0xb04649
push ebx
push 0xbaed30
push esi
push 0xb04284
push dword [edi]
call fcn.00b41267
add esp, 0x14
test eax, eax
je 0xb046af
push ebx
call fcn.00b0479f
push eax
push 0xffffffffffffffff
push dword [edi]
call fcn.00b3ff0f
mov dword [ebp + 8], eax
add esp, 0x10
lea eax, [ebp + 8]
push eax
lea ecx, [ebp - 0x1c]
call fcn.00b539b5
push 0xb9ec40
lea eax, [ebp - 0x1c]
push eax
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
call fcn.00b5d8c5
push esi
call fcn.00b542d3
pop ecx
mov ecx, dword [ebp - 0xc]
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret 4

Function at 0xb046c6
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x10
xor eax, eax
test byte [0xbb2b10], 1
jne 0xb04705
or dword [0xbb2b10], 1
mov dword [0xbaec48], 0x1c151e0f
mov dword [0xbaec4c], 0xa4c0318
mov dword [0xbaec50], 0x900050d
mov word [0xbaec54], 0x6c08
mov cl, byte [eax + 0xbaec48]
xor cl, 0x6c
mov byte [eax + 0xbaed48], cl
inc eax
cmp eax, 0xe
jb 0xb04705
lea eax, [ebp - 4]
push eax
lea ecx, [ebp - 0x10]
mov dword [ebp - 4], 0xbaed48
call fcn.00b539b5
push 0xb9ec40
lea eax, [ebp - 0x10]
push eax
mov dword [ebp - 0x10], vtable.std::runtime_error.0
call fcn.00b5d8c5
int3

Function at 0xb04743
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b1c], 1
jne 0xb04784
or dword [0xbb2b1c], 1
mov dword [0xbaec1c], 0x330d1900
mov dword [0xbaec20], 0xd0f1c
mov dword [0xbaec24], 0xd0a4c00
mov dword [0xbaec28], 0x8090005
mov byte [0xbaec2c], 0x6c
mov cl, byte [eax + 0xbaec1c]
xor cl, 0x6c
mov byte [eax + 0xbaed58], cl
inc eax
cmp eax, 0x11
jb 0xb04784
mov eax, 0xbaed58
ret

Function at 0xb0479f
Capabilities:
Encode data using xor

Disassembly:
xor eax, eax
test byte [0xbb2b14], 1
jne 0xb047d9
or dword [0xbb2b14], 1
mov dword [0xbaec38], 0x330d1900
mov dword [0xbaec3c], 0x80d0300
mov dword [0xbaec40], 0x50d0a4c
mov dword [0xbaec44], 0x6c080900
mov cl, byte [eax + 0xbaec38]
xor cl, 0x6c
mov byte [eax + 0xbaed38], cl
inc eax
cmp eax, 0x10
jb 0xb047d9
mov eax, 0xbaed38
ret