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

Disassembly:
test byte [0x1b2bac], 1
jne 0x101a6b
or dword [0x1b2bac], 1
mov edx, 0x83fa
mov eax, edx
mov word [0x1ae804], ax
add eax, 0xfffffff3
mov ecx, eax
mov word [0x1ae806], cx
mov word [0x1ae808], cx
push edi
lea ecx, [edx - 0xa]
mov edi, ecx
mov word [0x1ae80c], ax
lea eax, [edx - 0x5b]
mov word [0x1ae80a], di
mov dword [0x1ae80e], 0x83f083dc
mov dword [0x1ae812], 0x83fa83fb
mov word [0x1ae816], ax
pop edi
xor eax, eax
mov ecx, 0x839f
xor cx, word [eax + 0x1ae804]
add eax, 2
mov word [eax + 0x1ae946], cx
cmp eax, 0x14
jb 0x101a6d
mov eax, 0x1ae948
ret

Function at 0x101a8e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2ba8], 1
mov edx, 0x839f
jne 0x101b0b
or dword [0x1b2ba8], 1
lea ecx, [edx + 0x5b]
mov eax, ecx
mov word [0x1ae818], ax
add eax, 0xfffffff3
push esi
mov esi, eax
lea eax, [edx + 0x33]
mov word [0x1ae822], ax
mov eax, ecx
mov word [0x1ae824], ax
add eax, 0xfffffff2
mov word [0x1ae81a], si
mov word [0x1ae81c], si
mov esi, eax
mov word [0x1ae828], ax
lea eax, [edx + 0x5f]
mov word [0x1ae82a], ax
mov eax, edx
mov word [0x1ae826], si
mov dword [0x1ae81e], 0x83ed83f0
mov dword [0x1ae82c], 0x83fa83f8
mov word [0x1ae830], ax
pop esi
xor eax, eax
mov ecx, edx
xor cx, word [eax + 0x1ae818]
add eax, 2
mov word [eax + 0x1ae95a], cx
cmp eax, 0x1a
jb 0x101b0d
mov eax, 0x1ae95c
ret

Function at 0x101b2b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2ba4], 1
mov ecx, 0x839f
jne 0x101b8a
or dword [0x1b2ba4], 1
lea eax, [ecx + 0x5b]
mov word [0x1ae834], ax
add eax, 0xfffffff3
mov edx, eax
mov word [0x1ae836], dx
mov word [0x1ae838], dx
lea edx, [ecx + 0x51]
mov word [0x1ae83a], dx
mov edx, eax
lea eax, [ecx + 0x54]
mov word [0x1ae842], ax
mov eax, ecx
mov word [0x1ae83c], dx
mov dword [0x1ae83e], 0x83ed83ca
mov word [0x1ae844], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x1ae834]
add eax, 2
mov word [eax + 0x1ae976], dx
cmp eax, 0x12
jb 0x101b8c
mov eax, 0x1ae978
ret

Function at 0x10222f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2ba0], 1
jne 0x102259
or dword [0x1b2ba0], 1
mov dword [0x1ae848], 0xf3eaf1a3
mov word [0x1ae84c], 0xa1f3
mov byte [0x1ae84e], 0x9f
xor eax, eax
mov cl, byte [eax + 0x1ae848]
xor cl, 0x9f
mov byte [eax + 0x1ae98c], cl
inc eax
cmp eax, 7
jb 0x10225b
mov eax, 0x1ae98c
ret

Function at 0x102276
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b9c], 1
jne 0x1022a0
or dword [0x1b2b9c], 1
mov dword [0x1ae850], 0xf3eaf1a3
mov word [0x1ae854], 0xa1f3
mov byte [0x1ae856], 0x9f
xor eax, eax
mov cl, byte [eax + 0x1ae850]
xor cl, 0x9f
mov byte [eax + 0x1ae994], cl
inc eax
cmp eax, 7
jb 0x1022a2
mov eax, 0x1ae994
ret

Function at 0x1022bd
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b94], 1
jne 0x1022e1
or dword [0x1b2b94], 1
mov dword [0x1ae85c], 0xf0fcc4bf
mov dword [0x1ae860], 0x9fa2fafb
xor eax, eax
mov cl, byte [eax + 0x1ae85c]
xor cl, 0x9f
mov byte [eax + 0x1ae9a0], cl
inc eax
cmp eax, 8
jb 0x1022e3
mov eax, 0x1ae9a0
ret
Function at 0x102fe4
Capabilities:
Encode data using xor

Disassembly:
push esi
push edi
push 0x31
pop ecx
mov esi, 0x182ac8
mov edi, 0x1b2f40
push 0x182b8c
rep movsd dword es:[edi], dword [esi]
call fcn.0013a740
pop ecx
pop edi
pop esi
cmp eax, 0xffffffff
jne 0x10300a
xor al, al
ret
push 0x182bf8
call fcn.0013a690
pop ecx
cmp eax, 0xffffffff
je 0x103007
push 0x182d00
call fcn.00139100
pop ecx
cmp eax, 0xffffffff
je 0x103007
test byte [0x1b2b88], 1
jne 0x10304b
or dword [0x1b2b88], 1
mov dword [0x1ae9c0], 0x93c3cad1
mov byte [0x1ae9c4], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1ae9c0]
xor cl, 0xa2
mov byte [eax + 0x1aea8c], cl
inc eax
cmp eax, 5
jb 0x10304d
push 0x1aea8c
call fcn.0013a7b0
pop ecx
mov dword [0x1a8928], eax
test eax, eax
js 0x103007
call fcn.001030d6
push eax
call fcn.00139170
pop ecx
mov dword [0x1a892c], eax
test eax, eax
js 0x103007
test byte [0x1b2b80], 1
jne 0x1030a9
or dword [0x1b2b80], 1
mov dword [0x1ae9d0], 0xa2d1c7c3
xor eax, eax
mov cl, byte [eax + 0x1ae9d0]
xor cl, 0xa2
mov byte [eax + 0x1aea9c], cl
inc eax
cmp eax, 4
jb 0x1030ab
push 0x1aea9c
call fcn.0013a700
test eax, eax
mov dword [0x1a8930], eax
pop ecx
setns al
ret

Function at 0x1030d6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b84], 1
jne 0x1030fa
or dword [0x1b2b84], 1
mov dword [0x1ae9c8], 0xd6d0cdc4
mov dword [0x1ae9cc], 0xa2c3ccd7
xor eax, eax
mov cl, byte [eax + 0x1ae9c8]
xor cl, 0xa2
mov byte [eax + 0x1aea94], cl
inc eax
cmp eax, 8
jb 0x1030fc
mov eax, 0x1aea94
ret

Function at 0x10337a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b7c], 1
jne 0x1033b8
or dword [0x1b2b7c], 1
mov dword [0x1ae9d4], 0xcb82d2cf
mov dword [0x1ae9d8], 0x82d6cbcc
mov dword [0x1ae9dc], 0xcecbc3c4
mov word [0x1ae9e0], 0xc6c7
mov byte [0x1ae9e2], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1ae9d4]
xor cl, 0xa2
mov byte [eax + 0x1aeaa0], cl
inc eax
cmp eax, 0xf
jb 0x1033ba
mov eax, 0x1aeaa0
ret

Function at 0x1033d5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b78], 1
jne 0x103413
or dword [0x1b2b78], 1
mov dword [0x1ae9e4], 0xcb82d2cf
mov dword [0x1ae9e8], 0x82d6cbcc
mov dword [0x1ae9ec], 0xcecbc3c4
mov word [0x1ae9f0], 0xc6c7
mov byte [0x1ae9f2], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1ae9e4]
xor cl, 0xa2
mov byte [eax + 0x1aeab0], cl
inc eax
cmp eax, 0xf
jb 0x103415
mov eax, 0x1aeab0
ret

Function at 0x103430
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b74], 1
jne 0x10346e
or dword [0x1b2b74], 1
mov dword [0x1ae9f4], 0xfdd6c7d1
mov dword [0x1ae9f8], 0x82d6cccb
mov dword [0x1ae9fc], 0xcecbc3c4
mov word [0x1aea00], 0xc6c7
mov byte [0x1aea02], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1ae9f4]
xor cl, 0xa2
mov byte [eax + 0x1aeac0], cl
inc eax
cmp eax, 0xf
jb 0x103470
mov eax, 0x1aeac0
ret
Function at 0x10348b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b70], 1
jne 0x1034d4
or dword [0x1b2b70], 1
mov dword [0x1aea04], 0xcbd1ccd7
mov dword [0x1aea08], 0xc6c7ccc5
mov dword [0x1aea0c], 0xc3c7d0fd
mov dword [0x1aea10], 0xc3c482c6
mov dword [0x1aea14], 0xc6c7cecb
mov byte [0x1aea18], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1aea04]
xor cl, 0xa2
mov byte [eax + 0x1aead0], cl
inc eax
cmp eax, 0x15
jb 0x1034d6
mov eax, 0x1aead0
ret

Function at 0x1034f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b6c], 1
jne 0x103530
or dword [0x1b2b6c], 1
mov dword [0x1aea1c], 0xc5ccd0d2
mov dword [0x1aea20], 0xc9c3cf82
mov dword [0x1aea24], 0xc3c482c7
mov dword [0x1aea28], 0xc6c7cecb
mov byte [0x1aea2c], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1aea1c]
xor cl, 0xa2
mov byte [eax + 0x1aeae8], cl
inc eax
cmp eax, 0x11
jb 0x103532
mov eax, 0x1aeae8
ret

Function at 0x10354d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b68], 1
jne 0x10358f
or dword [0x1b2b68], 1
mov dword [0x1aea30], 0xd6d0cdc4
mov dword [0x1aea34], 0xfdc3ccd7
mov dword [0x1aea38], 0xc6c3c7d0
mov dword [0x1aea3c], 0xcbc3c482
mov dword [0x1aea40], 0xa2c6c7ce
xor eax, eax
mov cl, byte [eax + 0x1aea30]
xor cl, 0xa2
mov byte [eax + 0x1aeafc], cl
inc eax
cmp eax, 0x14
jb 0x103591
mov eax, 0x1aeafc
ret

Function at 0x1035ac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b64], 1
jne 0x1035f4
or dword [0x1b2b64], 1
mov dword [0x1aea44], 0xd2dbd0c1
mov dword [0x1aea48], 0xcb82cdd6
mov dword [0x1aea4c], 0x82d6cbcc
mov dword [0x1aea50], 0xcecbc3c4
mov word [0x1aea54], 0xc6c7
mov byte [0x1aea56], 0xa2
xor eax, eax
mov cl, byte [eax + 0x1aea44]
xor cl, 0xa2
mov byte [eax + 0x1aeb10], cl
inc eax
cmp eax, 0x13
jb 0x1035f6
mov eax, 0x1aeb10
ret

Function at 0x103809
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b60], 1
jne 0x10382c
or dword [0x1b2b60], 1
mov dword [0x1aea58], 0xc6d1d1cb
mov word [0x1aea5c], 0xa2c9
xor eax, eax
mov cl, byte [eax + 0x1aea58]
xor cl, 0xa2
mov byte [eax + 0x1aeb24], cl
inc eax
cmp eax, 6
jb 0x10382e
mov eax, 0x1aeb24
ret

Function at 0x103849
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b5c], 1
jne 0x103876
or dword [0x1b2b5c], 1
mov dword [0x1aea60], 0xc0d0d7ca
mov dword [0x1aea64], 0xd0d7c6c3
mov word [0x1aea68], 0xa2d0
xor eax, eax
mov cl, byte [eax + 0x1aea60]
xor cl, 0xa2
mov byte [eax + 0x1aeb2c], cl
inc eax
cmp eax, 0xa
jb 0x103878
mov eax, 0x1aeb2c
ret

Function at 0x103956
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b58], 1
jne 0x103983
or dword [0x1b2b58], 1
mov dword [0x1aea6c], 0xc0d0d7ca
mov dword [0x1aea70], 0xd0d7c6c3
mov word [0x1aea74], 0xa2d0
xor eax, eax
mov cl, byte [eax + 0x1aea6c]
xor cl, 0xa2
mov byte [eax + 0x1aeb38], cl
inc eax
cmp eax, 0xa
jb 0x103985
mov eax, 0x1aeb38
ret
Function at 0x104070
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b54], 1
jne 0x1040b8
or dword [0x1b2b54], 1
mov dword [0x1aeb44], 0xd4ddd6c7
mov dword [0x1aeb48], 0xcd84cbd0
mov dword [0x1aeb4c], 0x84d0cdca
mov dword [0x1aeb50], 0xc8cdc5c2
mov word [0x1aeb54], 0xc0c1
mov byte [0x1aeb56], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aeb44]
xor cl, 0xa4
mov byte [eax + 0x1aec58], cl
inc eax
cmp eax, 0x13
jb 0x1040ba
mov eax, 0x1aec58
ret

Function at 0x1040d5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b50], 1
jne 0x10411d
or dword [0x1b2b50], 1
mov dword [0x1aeb58], 0xd4ddd6c7
mov dword [0x1aeb5c], 0xcd84cbd0
mov dword [0x1aeb60], 0x84d0cdca
mov dword [0x1aeb64], 0xc8cdc5c2
mov word [0x1aeb68], 0xc0c1
mov byte [0x1aeb6a], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aeb58]
xor cl, 0xa4
mov byte [eax + 0x1aec6c], cl
inc eax
cmp eax, 0x13
jb 0x10411f
mov eax, 0x1aec6c
ret

Function at 0x10413a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b48], 1
jne 0x104182
or dword [0x1b2b48], 1
mov dword [0x1aeb74], 0xd4ddd6c7
mov dword [0x1aeb78], 0xcd84cbd0
mov dword [0x1aeb7c], 0x84d0cdca
mov dword [0x1aeb80], 0xc8cdc5c2
mov word [0x1aeb84], 0xc0c1
mov byte [0x1aeb86], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aeb74]
xor cl, 0xa4
mov byte [eax + 0x1aec88], cl
inc eax
cmp eax, 0x13
jb 0x104184
mov eax, 0x1aec88
ret

Function at 0x10419f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b40], 1
jne 0x1041e7
or dword [0x1b2b40], 1
mov dword [0x1aeb8c], 0xd4ddd6c7
mov dword [0x1aeb90], 0xcd84cbd0
mov dword [0x1aeb94], 0x84d0cdca
mov dword [0x1aeb98], 0xc8cdc5c2
mov word [0x1aeb9c], 0xc0c1
mov byte [0x1aeb9e], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aeb8c]
xor cl, 0xa4
mov byte [eax + 0x1aeca0], cl
inc eax
cmp eax, 0x13
jb 0x1041e9
mov eax, 0x1aeca0
ret

Function at 0x104204
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b3c], 1
jne 0x10423b
or dword [0x1b2b3c], 1
mov dword [0x1aeba0], 0xd4ddd6c7
mov dword [0x1aeba4], 0xc284cbd0
mov dword [0x1aeba8], 0xc1c8cdc5
mov word [0x1aebac], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aeba0]
xor cl, 0xa4
mov byte [eax + 0x1aecb4], cl
inc eax
cmp eax, 0xe
jb 0x10423d
mov eax, 0x1aecb4
ret

Function at 0x104258
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b38], 1
jne 0x10428f
or dword [0x1b2b38], 1
mov dword [0x1aebb0], 0xd4ddd6c7
mov dword [0x1aebb4], 0xc284cbd0
mov dword [0x1aebb8], 0xc1c8cdc5
mov word [0x1aebbc], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aebb0]
xor cl, 0xa4
mov byte [eax + 0x1aecc4], cl
inc eax
cmp eax, 0xe
jb 0x104291
mov eax, 0x1aecc4
ret

Function at 0x1042ac
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b34], 1
jne 0x1042d9
or dword [0x1b2b34], 1
mov dword [0x1aebc0], 0xd4d6c1cc
mov dword [0x1aebc4], 0xd6c1c08f
mov word [0x1aebc8], 0xa4d4
xor eax, eax
mov cl, byte [eax + 0x1aebc0]
xor cl, 0xa4
mov byte [eax + 0x1aecd4], cl
inc eax
cmp eax, 0xa
jb 0x1042db
mov eax, 0x1aecd4
ret
Function at 0x1042f6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b30], 1
jne 0x10432d
or dword [0x1b2b30], 1
mov dword [0x1aebcc], 0xd4ddd6c7
mov dword [0x1aebd0], 0xc284cbd0
mov dword [0x1aebd4], 0xc1c8cdc5
mov word [0x1aebd8], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aebcc]
xor cl, 0xa4
mov byte [eax + 0x1aece0], cl
inc eax
cmp eax, 0xe
jb 0x10432f
mov eax, 0x1aece0
ret

Function at 0x10434a
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b2c], 1
jne 0x104381
or dword [0x1b2b2c], 1
mov dword [0x1aebdc], 0xd4ddd6c7
mov dword [0x1aebe0], 0xc284cbd0
mov dword [0x1aebe4], 0xc1c8cdc5
mov word [0x1aebe8], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aebdc]
xor cl, 0xa4
mov byte [eax + 0x1aecf0], cl
inc eax
cmp eax, 0xe
jb 0x104383
mov eax, 0x1aecf0
ret

Function at 0x10444f
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b28], 1
jne 0x104486
or dword [0x1b2b28], 1
mov dword [0x1aebec], 0xd4ddd6c7
mov dword [0x1aebf0], 0xc284cbd0
mov dword [0x1aebf4], 0xc1c8cdc5
mov word [0x1aebf8], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aebec]
xor cl, 0xa4
mov byte [eax + 0x1aed00], cl
inc eax
cmp eax, 0xe
jb 0x104488
mov eax, 0x1aed00
ret

Function at 0x104635
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b24], 1
jne 0x10466c
or dword [0x1b2b24], 1
mov dword [0x1aebfc], 0xd4ddd6c7
mov dword [0x1aec00], 0xc284cbd0
mov dword [0x1aec04], 0xc1c8cdc5
mov word [0x1aec08], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aebfc]
xor cl, 0xa4
mov byte [eax + 0x1aed10], cl
inc eax
cmp eax, 0xe
jb 0x10466e
mov eax, 0x1aed10
ret

Function at 0x104689
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b20], 1
jne 0x1046c0
or dword [0x1b2b20], 1
mov dword [0x1aec0c], 0xd4ddd6c7
mov dword [0x1aec10], 0xc284cbd0
mov dword [0x1aec14], 0xc1c8cdc5
mov word [0x1aec18], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aec0c]
xor cl, 0xa4
mov byte [eax + 0x1aed20], cl
inc eax
cmp eax, 0xe
jb 0x1046c2
mov eax, 0x1aed20
ret
Function at 0x1046dd
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x17a5d9
call fcn.00179dc8
sub esp, 0x10
push ebx
push esi
mov esi, 0x110
push esi
call fcn.00154540
mov ebx, eax
pop ecx
test ebx, ebx
je 0x10470e
push esi
push 0
push ebx
call fcn.001570a0
add esp, 0xc
mov esi, ebx
jmp 0x104710
xor esi, esi
mov dword [ebp - 0x10], esi
and dword [ebp - 4], 0
mov eax, dword [edi + 4]
mov dword [esi + 0x100], eax
mov eax, dword [edi + 8]
sub eax, 0x14
test byte [0x1b2b18], 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 0x10475f
or dword [0x1b2b18], 1
mov dword [0x1aec30], 0xc6cbc8c6
mov byte [0x1aec34], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aec30]
xor cl, 0xa4
mov byte [eax + 0x1aed30], cl
inc eax
cmp eax, 5
jb 0x104761
push 0
push 0x1aed30
push esi
push 0x10439e
push dword [edi]
call fcn.00141387
add esp, 0x14
test eax, eax
je 0x1047c9
push 0
call fcn.001048b9
push eax
push 0xffffffffffffffff
push dword [edi]
call fcn.0014002f
mov dword [ebp + 8], eax
add esp, 0x10
lea eax, [ebp + 8]
push eax
lea ecx, [ebp - 0x1c]
call fcn.00153ae5
push 0x19ec28
lea eax, [ebp - 0x1c]
push eax
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
call fcn.0015da05
push esi
call fcn.00154403
pop ecx
mov ecx, dword [ebp - 0xc]
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret 4

Function at 0x1047e0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x10
test byte [0x1b2b10], 1
jne 0x10481d
or dword [0x1b2b10], 1
mov dword [0x1aec48], 0xd4ddd6c7
mov dword [0x1aec4c], 0xc284cbd0
mov dword [0x1aec50], 0xc1c8cdc5
mov word [0x1aec54], 0xa4c0
xor eax, eax
mov cl, byte [eax + 0x1aec48]
xor cl, 0xa4
mov byte [eax + 0x1aed48], cl
inc eax
cmp eax, 0xe
jb 0x10481f
lea eax, [ebp - 4]
push eax
lea ecx, [ebp - 0x10]
mov dword [ebp - 4], 0x1aed48
call fcn.00153ae5
push 0x19ec28
lea eax, [ebp - 0x10]
push eax
mov dword [ebp - 0x10], vtable.std::runtime_error.0
call fcn.0015da05
int3

Function at 0x10485d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b1c], 1
jne 0x10489c
or dword [0x1b2b1c], 1
mov dword [0x1aec1c], 0xfbc5d1c8
mov dword [0x1aec20], 0xc8c5c7d4
mov dword [0x1aec24], 0xc5c284c8
mov dword [0x1aec28], 0xc0c1c8cd
mov byte [0x1aec2c], 0xa4
xor eax, eax
mov cl, byte [eax + 0x1aec1c]
xor cl, 0xa4
mov byte [eax + 0x1aed58], cl
inc eax
cmp eax, 0x11
jb 0x10489e
mov eax, 0x1aed58
ret

Function at 0x1048b9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2b14], 1
jne 0x1048f1
or dword [0x1b2b14], 1
mov dword [0x1aec38], 0xfbc5d1c8
mov dword [0x1aec3c], 0xc0c5cbc8
mov dword [0x1aec40], 0xcdc5c284
mov dword [0x1aec44], 0xa4c0c1c8
xor eax, eax
mov cl, byte [eax + 0x1aec38]
xor cl, 0xa4
mov byte [eax + 0x1aed38], cl
inc eax
cmp eax, 0x10
jb 0x1048f3
mov eax, 0x1aed38
ret
Function at 0x105018
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2af8], 1
jne 0x105061
or dword [0x1b2af8], 1
mov dword [0x1aedfc], 0xc2d4c6c5
mov dword [0x1aee00], 0xc2879391
mov dword [0x1aee04], 0xc3c8c4c9
mov dword [0x1aee08], 0xc6c187c2
mov dword [0x1aee0c], 0xc3c2cbce
mov byte [0x1aee10], 0xa7
xor eax, eax
mov cl, byte [eax + 0x1aedfc]
xor cl, 0xa7
mov byte [eax + 0x1aee60], cl
inc eax
cmp eax, 0x15
jb 0x105063
mov eax, 0x1aee60
ret

Function at 0x1051a9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2af4], 1
jne 0x1051f2
or dword [0x1b2af4], 1
mov dword [0x1aee14], 0xc2d4c6c5
mov dword [0x1aee18], 0xc3879391
mov dword [0x1aee1c], 0xc3c8c4c2
mov dword [0x1aee20], 0xc6c187c2
mov dword [0x1aee24], 0xc3c2cbce
mov byte [0x1aee28], 0xa7
xor eax, eax
mov cl, byte [eax + 0x1aee14]
xor cl, 0xa7
mov byte [eax + 0x1aee78], cl
inc eax
cmp eax, 0x15
jb 0x1051f4
mov eax, 0x1aee78
ret

Function at 0x107cf2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a54], 1
jne 0x107d9c
or dword [0x1b2a54], 1
mov dword [0x1af250], 0xdecfc2e9
mov dword [0x1af254], 0xc5d8dcd5
mov dword [0x1af258], 0xde8cc2c3
mov dword [0x1af25c], 0xc9d9ddc9
mov dword [0x1af260], 0xc8c9d8df
mov dword [0x1af264], 0xd8d9ce8c
mov dword [0x1af268], 0xc5c4d88c
mov dword [0x1af26c], 0xc4d88cdf
mov dword [0x1af270], 0xc8cdc9de
mov dword [0x1af274], 0xdfcdc48c
mov dword [0x1af278], 0x8cc3c28c
mov dword [0x1af27c], 0xdcd5decf
mov dword [0x1af280], 0xc58cc3d8
mov dword [0x1af284], 0xcdd8dfc2
mov dword [0x1af288], 0xacc9cfc2
xor eax, eax
mov cl, byte [eax + 0x1af250]
xor cl, 0xac
mov byte [eax + 0x1af374], cl
inc eax
cmp eax, 0x3c
jb 0x107d9e
mov eax, 0x1af374
ret

Function at 0x107db9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a50], 1
jne 0x107e0f
or dword [0x1b2a50], 1
mov dword [0x1af28c], 0xc0c5cdea
mov dword [0x1af290], 0xd88cc8c9
mov dword [0x1af294], 0xc2c98cc3
mov dword [0x1af298], 0xdcd5decf
mov dword [0x1af29c], 0xc3dc8cd8
mov dword [0x1af2a0], 0xce8cd8df
mov dword [0x1af2a4], 0xacd5c8c3
xor eax, eax
mov cl, byte [eax + 0x1af28c]
xor cl, 0xac
mov byte [eax + 0x1af3b0], cl
inc eax
cmp eax, 0x1c
jb 0x107e11
mov eax, 0x1af3b0
ret

Function at 0x107e2c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a4c], 1
jne 0x107e95
or dword [0x1b2a4c], 1
mov dword [0x1af2a8], 0xc0c5cdea
mov dword [0x1af2ac], 0xd88cc8c9
mov dword [0x1af2b0], 0xc9c88cc3
mov dword [0x1af2b4], 0xdcd5decf
mov dword [0x1af2b8], 0xc9df8cd8
mov dword [0x1af2bc], 0xdec9dade
mov dword [0x1af2c0], 0xdfc9de8c
mov dword [0x1af2c4], 0xdfc2c3dc
mov word [0x1af2c8], 0xacc9
xor eax, eax
mov cl, byte [eax + 0x1af2a8]
xor cl, 0xac
mov byte [eax + 0x1af3cc], cl
inc eax
cmp eax, 0x22
jb 0x107e97
mov eax, 0x1af3cc
ret
Function at 0x108203
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a48], 1
jne 0x108262
or dword [0x1b2a48], 1
mov dword [0x1af2cc], 0xe8e0fef9
mov dword [0x1af2d0], 0xc0c2dbc3
mov dword [0x1af2d4], 0xf8c8cdc3
mov dword [0x1af2d8], 0xc0c5eac3
mov dword [0x1af2dc], 0xcdca8cc9
mov dword [0x1af2e0], 0xc8c9c0c5
mov dword [0x1af2e4], 0xdec48c96
mov word [0x1af2e8], 0xac91
xor eax, eax
mov cl, byte [eax + 0x1af2cc]
xor cl, 0xac
mov byte [eax + 0x1af3f0], cl
inc eax
cmp eax, 0x1e
jb 0x108264
mov eax, 0x1af3f0
ret

Function at 0x108edf
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a30], 1
jne 0x108f2b
or dword [0x1b2a30], 1
mov dword [0x1af46c], 0xe1d9c8ea
mov dword [0x1af470], 0xe4d9decc
mov dword [0x1af474], 0xd9d8ddc3
mov dword [0x1af478], 0xc2cbc3e4
mov dword [0x1af47c], 0xc4cccb8d
mov dword [0x1af480], 0xadc9c8c1
xor eax, eax
mov cl, byte [eax + 0x1af46c]
xor cl, 0xad
mov byte [eax + 0x1af4f8], cl
inc eax
cmp eax, 0x18
jb 0x108f2d
mov eax, 0x1af4f8
ret

Function at 0x1090c0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a2c], 1
jne 0x10911f
or dword [0x1b2a2c], 1
mov dword [0x1af484], 0xd8cec8ff
mov dword [0x1af488], 0xc2c4dedf
mov dword [0x1af48c], 0xc08ddec3
mov dword [0x1af490], 0x8dd9ded8
mov dword [0x1af494], 0xcc8dc8cf
mov dword [0x1af498], 0xc8c18dd9
mov dword [0x1af49c], 0x8dd9decc
mov word [0x1af4a0], 0xad9c
xor eax, eax
mov cl, byte [eax + 0x1af484]
xor cl, 0xad
mov byte [eax + 0x1af510], cl
inc eax
cmp eax, 0x1e
jb 0x109121
mov eax, 0x1af510
ret

Function at 0x10913c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a24], 1
jne 0x109191
or dword [0x1b2a24], 1
mov dword [0x1af4b0], 0xf2d9c8ca
mov dword [0x1af4b4], 0xc8c0c4d9
mov dword [0x1af4b8], 0xc3c4def2
mov dword [0x1af4bc], 0xc1f2c8ce
mov dword [0x1af4c0], 0xf2d9decc
mov dword [0x1af4c4], 0xd8ddc3c4
mov word [0x1af4c8], 0xadd9
xor eax, eax
mov cl, byte [eax + 0x1af4b0]
xor cl, 0xad
mov byte [eax + 0x1af53c], cl
inc eax
cmp eax, 0x1a
jb 0x109193
mov eax, 0x1af53c
ret

Function at 0x1091ae
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a20], 1
jne 0x109201
or dword [0x1b2a20], 1
mov dword [0x1af4cc], 0xf2d9c8ca
mov dword [0x1af4d0], 0xc8cec3cc
mov dword [0x1af4d4], 0xdfc2d9de
mov dword [0x1af4d8], 0xc9c2c0f2
mov dword [0x1af4dc], 0xf2c8c1d8
mov dword [0x1af4e0], 0xc5d9ccdd
mov byte [0x1af4e4], 0xad
xor eax, eax
mov cl, byte [eax + 0x1af4cc]
xor cl, 0xad
mov byte [eax + 0x1af558], cl
inc eax
cmp eax, 0x19
jb 0x109203
mov eax, 0x1af558
ret

Function at 0x109484
Capabilities:
Encode data using xor

Disassembly:
test byte [0x1b2a18], 1
jne 0x1094ea
or dword [0x1b2a18], 1
mov dword [0x1af584], 0xccc3d7fd
mov dword [0x1af588], 0xcd8ec2c1
mov dword [0x1af58c], 0xcac2dbc1
mov dword [0x1af590], 0xdac1c08e
mov dword [0x1af594], 0x8ecbcc8e
mov dword [0x1af598], 0xc1ddcbdc
mov dword [0x1af59c], 0xcacbd8c2
mov word [0x1af5a0], 0x8e94
mov byte [0x1af5a2], 0xae
xor eax, eax
mov cl, byte [eax + 0x1af584]
xor cl, 0xae
mov byte [eax + 0x1af5c4], cl
inc eax
cmp eax, 0x1f
jb 0x1094ec
mov eax, 0x1af5c4
ret