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

Disassembly:
test byte [0x9383a0], 1
jne 0x876814
or dword [0x9383a0], 1
mov dword [0x932928], 0xe39697ef
mov dword [0x93292c], 0xd6f4d0c1
mov dword [0x932930], 0xd7c1c7cb
mov dword [0x932934], 0xc5c9edd7
mov dword [0x932938], 0xcde2c1c3
mov dword [0x93293c], 0xc5eac1c8
mov dword [0x932940], 0xa4e5c1c9
xor eax, eax
mov cl, byte [eax + 0x932928]
xor cl, 0xa4
mov byte [eax + 0x932b28], cl
inc eax
cmp eax, 0x1c
jb 0x876816
mov eax, 0x932b28
ret

Function at 0x876831
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93839c], 1
jne 0x87685e
or dword [0x93839c], 1
mov dword [0x932944], 0xd4c5d7d4
mov dword [0x932948], 0xc8c08acd
mov word [0x93294c], 0xa4c8
xor eax, eax
mov cl, byte [eax + 0x932944]
xor cl, 0xa4
mov byte [eax + 0x932b44], cl
inc eax
cmp eax, 0xa
jb 0x876860
mov eax, 0x932b44
ret

Function at 0x87687b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938398], 1
jne 0x8768d8
or dword [0x938398], 1
mov dword [0x932950], 0xc0c5cbe8
mov dword [0x932954], 0xd6c6cde8
mov dword [0x932958], 0x84ddd6c5
mov dword [0x93295c], 0xc8cdc5c2
mov dword [0x932960], 0x8c84c0c1
mov dword [0x932964], 0xd4c5d7d4
mov dword [0x932968], 0x849e8dcd
mov byte [0x93296c], 0xa4
xor eax, eax
mov cl, byte [eax + 0x932950]
xor cl, 0xa4
mov byte [eax + 0x932b50], cl
inc eax
cmp eax, 0x1d
jb 0x8768da
mov eax, 0x932b50
ret

Function at 0x8768f5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938394], 1
jne 0x876948
or dword [0x938394], 1
mov dword [0x932970], 0xf4d0c1e3
mov dword [0x932974], 0xc1c7cbd6
mov dword [0x932978], 0xc9edd7d7
mov dword [0x93297c], 0xe2c1c3c5
mov dword [0x932980], 0xeac1c8cd
mov dword [0x932984], 0xe5c1c9c5
mov byte [0x932988], 0xa4
xor eax, eax
mov cl, byte [eax + 0x932970]
xor cl, 0xa4
mov byte [eax + 0x932b70], cl
inc eax
cmp eax, 0x19
jb 0x87694a
mov eax, 0x932b70
ret

Function at 0x876965
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938390], 1
jne 0x876a01
or dword [0x938390], 1
mov dword [0x93298c], 0xf4d0c1e3
mov dword [0x932990], 0xe5c7cbd6
mov dword [0x932994], 0xc1d6c0c0
mov dword [0x932998], 0xc284d7d7
mov dword [0x93299c], 0xc1c8cdc5
mov dword [0x9329a0], 0xe38c84c0
mov dword [0x9329a4], 0xd6f4d0c1
mov dword [0x9329a8], 0xd7c1c7cb
mov dword [0x9329ac], 0xc5c9edd7
mov dword [0x9329b0], 0xcde2c1c3
mov dword [0x9329b4], 0xc5eac1c8
mov dword [0x9329b8], 0x8de5c1c9
mov word [0x9329bc], 0x849e
mov byte [0x9329be], 0xa4
xor eax, eax
mov cl, byte [eax + 0x93298c]
xor cl, 0xa4
mov byte [eax + 0x932b8c], cl
inc eax
cmp eax, 0x33
jb 0x876a03
mov eax, 0x932b8c
ret

Function at 0x876a1e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93838c], 1
jne 0x876a85
or dword [0x93838c], 1
mov dword [0x9329c0], 0xf4d0c1e3
mov dword [0x9329c4], 0xc1c7cbd6
mov dword [0x9329c8], 0xc9edd7d7
mov dword [0x9329cc], 0xe2c1c3c5
mov dword [0x9329d0], 0xcac1c8cd
mov dword [0x9329d4], 0x84c1c9c5
mov dword [0x9329d8], 0xc8cdc5c2
mov dword [0x9329dc], 0x849ec0c1
mov byte [0x9329e0], 0xa4
xor eax, eax
mov cl, byte [eax + 0x9329c0]
xor cl, 0xa4
mov byte [eax + 0x932bc0], cl
inc eax
cmp eax, 0x21
jb 0x876a87
mov eax, 0x932bc0
ret
Function at 0x877641
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938388], 1
jne 0x877827
or dword [0x938388], 1
mov dword [0x932be8], 0xd588c9cf
mov dword [0x932bec], 0xd3c9c2d2
mov dword [0x932bf0], 0xc3d59cd2
mov dword [0x932bf4], 0xd3c4d0d2
mov dword [0x932bf8], 0xc8818ec0
mov dword [0x932bfc], 0xac8f81c9
mov dword [0x932c00], 0xcdc5c7d6
mov dword [0x932c04], 0x88c3c1c7
mov dword [0x932c08], 0xced2c7d6
mov dword [0x932c0c], 0x81869b86
mov dword [0x932c10], 0xc3d4ac81
mov dword [0x932c14], 0xd4cfd3d7
mov dword [0x932c18], 0xd5818ec3
mov dword [0x932c1c], 0xc5cfd4d2
mov dword [0x932c20], 0xac8f81d2
mov dword [0x932c24], 0xc7c5c9ca
mov dword [0x932c28], 0x8ad586ca
mov dword [0x932c2c], 0x9b86d486
mov dword [0x932c30], 0xc5d6de86
mov dword [0x932c34], 0x8ecacac7
mov dword [0x932c38], 0xc5c8d3c0
mov dword [0x932c3c], 0xc8c9cfd2
mov dword [0x932c40], 0xd4868f8e
mov dword [0x932c44], 0xd4d3d2c3
mov dword [0x932c48], 0xc3d486c8
mov dword [0x932c4c], 0xd4cfd3d7
mov dword [0x932c50], 0x83818ec3
mov dword [0x932c54], 0x888f81eb
mov dword [0x932c58], 0xc8cfc7cb
mov dword [0x932c5c], 0xc7f9f98e
mov dword [0x932c60], 0x8fd5c1d4
mov dword [0x932c64], 0xc2c8c386
mov dword [0x932c68], 0xc3c2868a
mov dword [0x932c6c], 0x88c1d3c4
mov dword [0x932c70], 0xc5c7d4d2
mov dword [0x932c74], 0xc5c7c4c3
mov dword [0x932c78], 0xcfac8fcd
mov dword [0x932c7c], 0xc9c886c0
mov dword [0x932c80], 0x86d586d2
mov dword [0x932c84], 0xc8c3ced2
mov dword [0x932c88], 0xd4d4c386
mov dword [0x932c8c], 0xd48ed4c9
mov dword [0x932c90], 0xc8c3868f
mov dword [0x932c94], 0xc3d4acc2
mov dword [0x932c98], 0xc8d4d3d2
mov word [0x932c9c], 0xd486
mov byte [0x932c9e], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932be8]
xor cl, 0xa6
mov byte [eax + 0x933318], cl
inc eax
cmp eax, 0xb7
jb 0x877829
mov eax, 0x933318
ret
Function at 0x877846
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938384], 1
jne 0x877acc
or dword [0x938384], 1
mov dword [0x932ca0], 0xd588c9cf
mov dword [0x932ca4], 0xd3c9c2d2
mov dword [0x932ca8], 0xc3d59cd2
mov dword [0x932cac], 0xd3c4d0d2
mov dword [0x932cb0], 0xc8818ec0
mov dword [0x932cb4], 0xac8f81c9
mov dword [0x932cb8], 0xcdc5c7d6
mov dword [0x932cbc], 0x88c3c1c7
mov dword [0x932cc0], 0xced2c7d6
mov dword [0x932cc4], 0xac81819b
mov dword [0x932cc8], 0xd3d7c3d4
mov dword [0x932ccc], 0x8ec3d4cf
mov dword [0x932cd0], 0xd4d2d581
mov dword [0x932cd4], 0x81d2c5cf
mov dword [0x932cd8], 0xc9caac8f
mov dword [0x932cdc], 0x86cac7c5
mov dword [0x932ce0], 0x9b86cacb
mov dword [0x932ce4], 0xd7c3d486
mov dword [0x932ce8], 0xc3d4cfd3
mov dword [0x932cec], 0xcacb818e
mov dword [0x932cf0], 0xcaac8f81
mov dword [0x932cf4], 0xcac7c5c9
mov dword [0x932cf8], 0xd48ad586
mov dword [0x932cfc], 0x9b86c38a
mov dword [0x932d00], 0xc5d6de86
mov dword [0x932d04], 0x8ecacac7
mov dword [0x932d08], 0xc5c8d3c0
mov dword [0x932d0c], 0xc8c9cfd2
mov dword [0x932d10], 0xd4868f8e
mov dword [0x932d14], 0xd4d3d2c3
mov dword [0x932d18], 0xc3d486c8
mov dword [0x932d1c], 0xd4cfd3d7
mov dword [0x932d20], 0x83818ec3
mov dword [0x932d24], 0x888f81eb
mov dword [0x932d28], 0x838ee083
mov dword [0x932d2c], 0xc3868fe7
mov dword [0x932d30], 0x868ac2c8
mov dword [0x932d34], 0xd3c4c3c2
mov dword [0x932d38], 0xd4d288c1
mov dword [0x932d3c], 0xc4c3c5c7
mov dword [0x932d40], 0x8fcdc5c7
mov dword [0x932d44], 0x86c0cfac
mov dword [0x932d48], 0x86d2c9c8
mov dword [0x932d4c], 0xced286d5
mov dword [0x932d50], 0xd486c8c3
mov dword [0x932d54], 0xd4d3d2c3
mov dword [0x932d58], 0xcfc886c8
mov dword [0x932d5c], 0xd4868aca
mov dword [0x932d60], 0xc2c8c386
mov dword [0x932d64], 0x86c0cfac
mov dword [0x932d68], 0x9bd886d4
mov dword [0x932d6c], 0xcacfc886
mov dword [0x932d70], 0xc3ced286
mov dword [0x932d74], 0x86d486c8
mov dword [0x932d78], 0xcacb869b
mov dword [0x932d7c], 0xd2d5d288
mov dword [0x932d80], 0xc1c8cfd4
mov dword [0x932d84], 0x868fd48e
mov dword [0x932d88], 0xacc2c8c3
mov dword [0x932d8c], 0xd3d2c3d4
mov dword [0x932d90], 0xd486c8d4
mov word [0x932d94], 0xc38a
mov byte [0x932d96], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932ca0]
xor cl, 0xa6
mov byte [eax + 0x9333d0], cl
inc eax
cmp eax, 0xf7
jb 0x877ace
mov eax, 0x9333d0
ret
Function at 0x877aeb
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
test byte [0x938344], 1
jne 0x877b12
or dword [0x938344], 1
mov dword [0x932e8c], 0xcdc5c7d6
mov dword [0x932e90], 0xa6c3c1c7
xor eax, eax
mov cl, byte [eax + 0x932e8c]
xor cl, 0xa6
mov byte [eax + 0x9335bc], cl
inc eax
cmp eax, 8
jb 0x877b14
push 0x9335bc
push dword [ebp + 8]
call fcn.008c3bc6
test byte [0x938340], 1
pop ecx
pop ecx
jne 0x877b5c
or dword [0x938340], 1
mov dword [0x932e94], 0xcac3d4d6
mov dword [0x932e98], 0xa6c2c7c9
xor eax, eax
mov cl, byte [eax + 0x932e94]
xor cl, 0xa6
mov byte [eax + 0x9335c4], cl
inc eax
cmp eax, 8
jb 0x877b5e
push esi
push 0x9335c4
push 0xffffffffffffffff
push dword [ebp + 8]
call fcn.008c3c3a
add esp, 0xc
cmp dword [0x92dc20], 0
mov esi, 0x92dc20
je 0x877bbe
push edi
mov edi, esi
push 0
push dword [esi + 4]
push dword [ebp + 8]
call fcn.008c3ae6
push dword [esi]
push 0xfffffffffffffffe
push dword [ebp + 8]
call fcn.008c3e67
add edi, 8
add esp, 0x18
cmp dword [edi], 0
mov esi, edi
jne 0x877b97
pop edi
push 0xfffffffffffffffd
push dword [ebp + 8]
call fcn.008c333b
pop ecx
pop ecx
pop esi
pop ebp
ret
Function at 0x877e38
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x8fdb62
call fcn.008fcc58
sub esp, 0x64
test byte [0x93832c], 1
jne 0x877e65
or dword [0x93832c], 1
mov word [0x932ec4], 0xeb83
mov byte [0x932ec6], 0xa6
push ebx
push esi
xor ebx, ebx
push edi
xor eax, eax
mov cl, byte [eax + 0x932ec4]
xor cl, 0xa6
mov byte [eax + 0x9335f4], cl
inc eax
cmp eax, 3
jb 0x877e6c
mov esi, 0x9335f4
mov eax, esi
mov dword [ebp - 0x40], 0xf
mov dword [ebp - 0x44], ebx
mov byte [ebp - 0x54], bl
lea edi, [eax + 1]
mov cl, byte [eax]
inc eax
cmp cl, bl
jne 0x877e98
sub eax, edi
push eax
push esi
lea ecx, [ebp - 0x54]
call fcn.00874e34
push dword [ebp + 0x10]
lea eax, [ebp - 0x54]
push eax
push dword [ebp + 0xc]
lea eax, [ebp - 0x70]
push eax
mov dword [ebp - 4], ebx
call fcn.0087e969
add esp, 0x10
push ebx
push 1
lea ecx, [ebp - 0x54]
mov byte [ebp - 4], 2
call fcn.00874c70
cmp dword [ebp - 0x5c], 0x10
mov eax, dword [ebp - 0x70]
jae 0x877edf
lea eax, [ebp - 0x70]
mov esi, dword [ebp + 8]
push eax
push esi
call fcn.008c2739
pop ecx
pop ecx
cmp eax, ebx
je 0x877f30
cmp eax, 3
jne 0x877f1d
call fcn.00878037
mov dword [ebp - 0x10], eax
lea eax, [ebp - 0x10]
push eax
lea ecx, [ebp - 0x1c]
call fcn.008d6985
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
push 0x922d30
lea eax, [ebp - 0x1c]
push eax
call fcn.008e0895
cmp eax, 4
jne 0x877f29
call fcn.008780ea
jmp 0x877ef9
call fcn.0087819d
jmp 0x877ef9
push ebx
push ebx
push ebx
push 1
push ebx
push esi
call fcn.008c416f
mov edi, eax
add esp, 0x18
cmp edi, ebx
je 0x877fe7
push ebx
call fcn.00878221
push eax
push 0xffffffffffffffff
push esi
call fcn.008c2ed0
add esp, 0x10
push eax
lea ecx, [ebp - 0x38]
mov dword [ebp - 0x24], 0xf
mov dword [ebp - 0x28], ebx
mov byte [ebp - 0x38], bl
call fcn.00874c4f
mov byte [ebp - 4], 3
cmp edi, 2
jne 0x877f9f
call fcn.00878268
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.0087e9da
pop ecx
pop ecx
mov byte [ebp - 4], 4
lea esi, [ebp - 0x1c]
call fcn.00875bc7
jmp 0x877f0f
cmp edi, 4
jne 0x877fbe
call fcn.008782c7
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.0087e9da
pop ecx
pop ecx
mov byte [ebp - 4], 5
jmp 0x877f92
cmp edi, 6
jne 0x877fdd
call fcn.0087832c
push eax
lea eax, [ebp - 0x54]
push eax
lea edi, [ebp - 0x38]
call fcn.0087e9da
pop ecx
pop ecx
mov byte [ebp - 4], 6
jmp 0x877f92
call fcn.008783b0
jmp 0x877ef9
or edi, 0xffffffff
push edi
push esi
mov dword [ebp - 0x10], edi
call fcn.008c352b
pop ecx
pop ecx
test eax, eax
je 0x878008
push ebx
push edi
push esi
call fcn.008c36ef
add esp, 0xc
mov dword [ebp - 0x10], eax
push esi
call fcn.008c3325
sub edi, eax
push edi
push esi
call fcn.008c333b
add esp, 0xc
push ebx
push 1
lea ecx, [ebp - 0x70]
call fcn.00874c70
mov ecx, dword [ebp - 0xc]
mov eax, dword [ebp - 0x10]
pop edi
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret
Function at 0x878037
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938328], 1
jne 0x8780cd
or dword [0x938328], 1
mov dword [0x932ec8], 0xcacfc7e0
mov dword [0x932ecc], 0xd286c2c3
mov dword [0x932ed0], 0xd0c386c9
mov dword [0x932ed4], 0xc7d3cac7
mov dword [0x932ed8], 0xc486c3d2
mov dword [0x932edc], 0xd5d2c9c9
mov dword [0x932ee0], 0xd6c7d4d2
mov dword [0x932ee4], 0xc7d4c086
mov dword [0x932ee8], 0xc8c3cbc1
mov dword [0x932eec], 0xd5868ad2
mov dword [0x932ef0], 0xc7d2c8df
mov dword [0x932ef4], 0xd4c386de
mov dword [0x932ef8], 0xa6d4c9d4
xor eax, eax
mov cl, byte [eax + 0x932ec8]
xor cl, 0xa6
mov byte [eax + 0x9335f8], cl
inc eax
cmp eax, 0x34
jb 0x8780cf
mov eax, 0x9335f8
ret

Function at 0x8780ea
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938324], 1
jne 0x878180
or dword [0x938324], 1
mov dword [0x932efc], 0xcacfc7e0
mov dword [0x932f00], 0xd286c2c3
mov dword [0x932f04], 0xd0c386c9
mov dword [0x932f08], 0xc7d3cac7
mov dword [0x932f0c], 0xc486c3d2
mov dword [0x932f10], 0xd5d2c9c9
mov dword [0x932f14], 0xd6c7d4d2
mov dword [0x932f18], 0xc7d4c086
mov dword [0x932f1c], 0xc8c3cbc1
mov dword [0x932f20], 0xcb868ad2
mov dword [0x932f24], 0xd4c9cbc3
mov dword [0x932f28], 0xd4c386df
mov dword [0x932f2c], 0xa6d4c9d4
xor eax, eax
mov cl, byte [eax + 0x932efc]
xor cl, 0xa6
mov byte [eax + 0x93362c], cl
inc eax
cmp eax, 0x34
jb 0x878182
mov eax, 0x93362c
ret

Function at 0x87819d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938320], 1
jne 0x878204
or dword [0x938320], 1
mov dword [0x932f30], 0xc8cdc8f3
mov dword [0x932f34], 0x86c8d1c9
mov dword [0x932f38], 0xc9d4d4c3
mov dword [0x932f3c], 0xc8cf86d4
mov dword [0x932f40], 0xc7d3ca86
mov dword [0x932f44], 0xc9caf9ea
mov dword [0x932f48], 0xd2d5c2c7
mov dword [0x932f4c], 0xc1c8cfd4
mov byte [0x932f50], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932f30]
xor cl, 0xa6
mov byte [eax + 0x933660], cl
inc eax
cmp eax, 0x21
jb 0x878206
mov eax, 0x933660
ret

Function at 0x878221
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93831c], 1
jne 0x87824b
or dword [0x93831c], 1
mov dword [0x932f54], 0xc8c9c89a
mov word [0x932f58], 0x98c3
mov byte [0x932f5a], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932f54]
xor cl, 0xa6
mov byte [eax + 0x933684], cl
inc eax
cmp eax, 7
jb 0x87824d
mov eax, 0x933684
ret

Function at 0x878268
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938318], 1
jne 0x8782aa
or dword [0x938318], 1
mov dword [0x932f5c], 0x86c7d3ea
mov dword [0x932f60], 0xd2c8d3d4
mov dword [0x932f64], 0x86c3cbcf
mov dword [0x932f68], 0xc9d4d4c3
mov dword [0x932f6c], 0xa6869cd4
xor eax, eax
mov cl, byte [eax + 0x932f5c]
xor cl, 0xa6
mov byte [eax + 0x93368c], cl
inc eax
cmp eax, 0x14
jb 0x8782ac
mov eax, 0x93368c
ret
Function at 0x8782c7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938314], 1
jne 0x87830f
or dword [0x938314], 1
mov dword [0x932f70], 0x86c7d3ea
mov dword [0x932f74], 0xc9cbc3cb
mov dword [0x932f78], 0xc386dfd4
mov dword [0x932f7c], 0xd4c9d4d4
mov word [0x932f80], 0x869c
mov byte [0x932f82], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932f70]
xor cl, 0xa6
mov byte [eax + 0x9336a0], cl
inc eax
cmp eax, 0x13
jb 0x878311
mov eax, 0x9336a0
ret

Function at 0x87832c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938310], 1
jne 0x878393
or dword [0x938310], 1
mov dword [0x932f84], 0x86c7d3ea
mov dword [0x932f88], 0xc9d4d4c3
mov dword [0x932f8c], 0xc8cf86d4
mov dword [0x932f90], 0xc3c2cfd5
mov dword [0x932f94], 0xd4d4c386
mov dword [0x932f98], 0xce86d4c9
mov dword [0x932f9c], 0xcac2c8c7
mov dword [0x932fa0], 0x869cd4c3
mov byte [0x932fa4], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932f84]
xor cl, 0xa6
mov byte [eax + 0x9336b4], cl
inc eax
cmp eax, 0x21
jb 0x878395
mov eax, 0x9336b4
ret

Function at 0x8783b0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93830c], 1
jne 0x87840c
or dword [0x93830c], 1
mov dword [0x932fa8], 0xc8cdc8f3
mov dword [0x932fac], 0x86c8d1c9
mov dword [0x932fb0], 0xc9d4d4c3
mov dword [0x932fb4], 0xc8cf86d4
mov dword [0x932fb8], 0xc7d3ca86
mov dword [0x932fbc], 0xc7c5d6f9
mov word [0x932fc0], 0xcaca
mov byte [0x932fc2], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932fa8]
xor cl, 0xa6
mov byte [eax + 0x9336d8], cl
inc eax
cmp eax, 0x1b
jb 0x87840e
mov eax, 0x9336d8
ret

Function at 0x87864a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938308], 1
jne 0x878693
or dword [0x938308], 1
mov dword [0x932fc4], 0xc3d5c7e4
mov dword [0x932fc8], 0xc2869290
mov dword [0x932fcc], 0xc2c9c5c3
mov dword [0x932fd0], 0xc7c086c3
mov dword [0x932fd4], 0xc2c3cacf
mov byte [0x932fd8], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932fc4]
xor cl, 0xa6
mov byte [eax + 0x9336f4], cl
inc eax
cmp eax, 0x15
jb 0x878695
mov eax, 0x9336f4
ret
Function at 0x8786b0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
push 0xffffffffffffffff
push 0x8ff2cc
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
sub esp, 0x50
push ebx
push esi
push edi
push dword [ebp + 0xc]
lea eax, [esp + 0x24]
xor ebx, ebx
push eax
mov dword [esp + 0x18], ebx
call fcn.0089fa8b
lea ecx, [esp + 0x44]
push ecx
mov ecx, eax
mov dword [esp + 0x70], ebx
call fcn.0089de7e
add esp, 0xc
push 1
xor edi, edi
lea esi, [esp + 0x24]
call fcn.00874dae
mov dword [esp + 0x20], ebx
mov dword [esp + 0x24], ebx
mov dword [esp + 0x28], ebx
mov byte [esp + 0x64], 3
mov esi, dword [esp + 0x4c]
lea eax, [esp + 0x20]
call fcn.0087bd0b
mov eax, dword [esp + 0x24]
sub eax, dword [esp + 0x20]
cmp dword [esp + 0x50], 0x10
mov dword [esp + 0xc], eax
mov eax, dword [esp + 0x3c]
jae 0x87873d
lea eax, [esp + 0x3c]
lea ecx, [esp + 0xc]
push ecx
push dword [esp + 0x24]
push esi
push eax
call fcn.008a206a
add esp, 0x10
test al, al
jne 0x878782
call fcn.008787f9
mov dword [esp + 0xc], eax
lea eax, [esp + 0xc]
push eax
lea ecx, [esp + 0x18]
call fcn.008d6985
push 0x922d30
lea eax, [esp + 0x18]
push eax
mov dword [esp + 0x1c], vtable.std::runtime_error.0
call fcn.008e0895
mov esi, dword [esp + 0xc]
lea eax, [esp + 0x20]
call fcn.0087bd0b
mov ecx, dword [esp + 0x24]
mov eax, dword [esp + 0x20]
xor esi, esi
sub ecx, eax
mov dword [esp + 0xc], ecx
je 0x8787c2
mov eax, dword [ebp + 0x10]
mov ecx, dword [eax]
mov edi, dword [eax + 4]
sub edi, ecx
xor edx, edx
mov eax, esi
div edi
mov eax, dword [esp + 0x20]
mov cl, byte [edx + ecx]
xor byte [eax + esi], cl
inc esi
cmp esi, dword [esp + 0xc]
jb 0x8787a1
push dword [esp + 0xc]
mov esi, dword [ebp + 8]
push eax
call fcn.0087b034
lea esi, [esp + 0x20]
call fcn.0087bcf2
push ebx
push 1
lea ecx, [esp + 0x44]
call fcn.00874c70
mov ecx, dword [esp + 0x5c]
mov eax, dword [ebp + 8]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
mov esp, ebp
pop ebp
ret

Function at 0x8787f9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938304], 1
jne 0x878842
or dword [0x938304], 1
mov dword [0x932fdc], 0xc3d5c7e4
mov dword [0x932fe0], 0xc2869290
mov dword [0x932fe4], 0xc2c9c5c3
mov dword [0x932fe8], 0xc7c086c3
mov dword [0x932fec], 0xc2c3cacf
mov byte [0x932ff0], 0xa6
xor eax, eax
mov cl, byte [eax + 0x932fdc]
xor cl, 0xa6
mov byte [eax + 0x93370c], cl
inc eax
cmp eax, 0x15
jb 0x878844
mov eax, 0x93370c
ret

Function at 0x878f05
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938300], 1
jne 0x878f5a
or dword [0x938300], 1
mov dword [0x932ff4], 0xcad3c9e5
mov dword [0x932ff8], 0xc9c886c2
mov dword [0x932ffc], 0xd6c986d2
mov dword [0x933000], 0xc586c8c3
mov dword [0x933004], 0xced5c7d4
mov dword [0x933008], 0xcbd3c286
mov word [0x93300c], 0xa6d6
xor eax, eax
mov cl, byte [eax + 0x932ff4]
xor cl, 0xa6
mov byte [eax + 0x933724], cl
inc eax
cmp eax, 0x1a
jb 0x878f5c
mov eax, 0x933724
ret
Function at 0x878f77
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382f8], 1
jne 0x878f9a
or dword [0x9382f8], 1
mov dword [0x933014], 0xc1c9ca89
mov word [0x933018], 0xa689
xor eax, eax
mov cl, byte [eax + 0x933014]
xor cl, 0xa6
mov byte [eax + 0x933744], cl
inc eax
cmp eax, 6
jb 0x878f9c
mov eax, 0x933744
ret

Function at 0x878fb7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382f4], 1
jne 0x879032
or dword [0x9382f4], 1
mov dword [0x93301c], 0xd6d2d2ce
mov dword [0x933020], 0xc789899c
mov dword [0x933024], 0xdfcac7c8
mov dword [0x933028], 0xd5c5cfd2
mov dword [0x93302c], 0xd2c3c188
mov dword [0x933030], 0xc8d1c9c2
mov dword [0x933034], 0xd2d5c3d2
mov dword [0x933038], 0xcbc9c588
mov dword [0x93303c], 0x8994d089
mov dword [0x933040], 0x89c1c9ca
mov byte [0x933044], 0xa6
xor eax, eax
mov cl, byte [eax + 0x93301c]
xor cl, 0xa6
mov byte [eax + 0x93374c], cl
inc eax
cmp eax, 0x29
jb 0x879034
mov eax, 0x93374c
ret

Function at 0x87904f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382f0], 1
jne 0x87907a
or dword [0x9382f0], 1
mov dword [0x933048], 0xd5809bc5
mov dword [0x93304c], 0x9bd2809b
mov byte [0x933050], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933048]
xor cl, 0xa6
mov byte [eax + 0x933778], cl
inc eax
cmp eax, 9
jb 0x87907c
mov eax, 0x933778
ret

Function at 0x879097
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382e0], 1
jne 0x87911f
or dword [0x9382e0], 1
mov dword [0x933064], 0xd2c8c9e5
mov dword [0x933068], 0x8bd2c8c3
mov dword [0x93306c], 0xc3d6dff2
mov dword [0x933070], 0xd6c7869c
mov dword [0x933074], 0xc5cfcad6
mov dword [0x933078], 0xc9cfd2c7
mov dword [0x93307c], 0x8bde89c8
mov dword [0x933080], 0x8bd1d1d1
mov dword [0x933084], 0xcbd4c9c0
mov dword [0x933088], 0xcad4d38b
mov dword [0x93308c], 0xc9c5c8c3
mov dword [0x933090], 0xa6c2c3c2
xor eax, eax
mov cl, byte [eax + 0x933064]
xor cl, 0xa6
mov byte [eax + 0x933794], cl
inc eax
cmp eax, 0x30
jb 0x879121
mov eax, 0x933794
ret

Function at 0x87913c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382dc], 1
jne 0x879167
or dword [0x9382dc], 1
mov dword [0x933094], 0xf2f5e9f6
mov dword [0x933098], 0x86c9d286
mov byte [0x93309c], 0xa6
xor eax, eax
mov cl, byte [eax + 0x933094]
xor cl, 0xa6
mov byte [eax + 0x9337c4], cl
inc eax
cmp eax, 9
jb 0x879169
mov eax, 0x9337c4
ret

Function at 0x879184
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9382d8], 1
jne 0x8791cd
or dword [0x9382d8], 1
mov dword [0x9330a0], 0xcfc7c086
mov dword [0x9330a4], 0x86c2c3ca
mov dword [0x9330a8], 0xced2cfd1
mov dword [0x9330ac], 0xc7d2d586
mov dword [0x9330b0], 0x86d5d3d2
mov byte [0x9330b4], 0xa6
xor eax, eax
mov cl, byte [eax + 0x9330a0]
xor cl, 0xa6
mov byte [eax + 0x9337d0], cl
inc eax
cmp eax, 0x15
jb 0x8791cf
mov eax, 0x9337d0
ret