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

Disassembly:
test byte [0x9381f8], 1
jne 0x885799
or dword [0x9381f8], 1
mov dword [0x933d34], 0xc2d8c5de
mov dword [0x933d38], 0xcfcec5cc
mov dword [0x933d3c], 0xcaced9f4
mov dword [0x933d40], 0xcacd8bcf
mov dword [0x933d44], 0xcfcec7c2
mov byte [0x933d48], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d34]
xor cl, 0xab
mov byte [eax + 0x933e00], cl
inc eax
cmp eax, 0x15
jb 0x88579b
mov eax, 0x933e00
ret

Function at 0x8857b6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381f4], 1
jne 0x8857f5
or dword [0x9381f4], 1
mov dword [0x933d4c], 0xccc5d9db
mov dword [0x933d50], 0xc0cac68b
mov dword [0x933d54], 0xcacd8bce
mov dword [0x933d58], 0xcfcec7c2
mov byte [0x933d5c], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d4c]
xor cl, 0xab
mov byte [eax + 0x933e18], cl
inc eax
cmp eax, 0x11
jb 0x8857f7
mov eax, 0x933e18
ret

Function at 0x885812
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381f0], 1
jne 0x885854
or dword [0x9381f0], 1
mov dword [0x933d60], 0xdfd9c4cd
mov dword [0x933d64], 0xf4cac5de
mov dword [0x933d68], 0xcfcaced9
mov dword [0x933d6c], 0xc2cacd8b
mov dword [0x933d70], 0xabcfcec7
xor eax, eax
mov cl, byte [eax + 0x933d60]
xor cl, 0xab
mov byte [eax + 0x933e2c], cl
inc eax
cmp eax, 0x14
jb 0x885856
mov eax, 0x933e2c
ret

Function at 0x885871
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381ec], 1
jne 0x8858b9
or dword [0x9381ec], 1
mov dword [0x933d74], 0xdbd2d9c8
mov dword [0x933d78], 0xc28bc4df
mov dword [0x933d7c], 0x8bdfc2c5
mov dword [0x933d80], 0xc7c2cacd
mov word [0x933d84], 0xcfce
mov byte [0x933d86], 0xab
xor eax, eax
mov cl, byte [eax + 0x933d74]
xor cl, 0xab
mov byte [eax + 0x933e40], cl
inc eax
cmp eax, 0x13
jb 0x8858bb
mov eax, 0x933e40
ret

Function at 0x885ace
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381e8], 1
jne 0x885af1
or dword [0x9381e8], 1
mov dword [0x933d88], 0xcfd8d8c2
mov word [0x933d8c], 0xabc0
xor eax, eax
mov cl, byte [eax + 0x933d88]
xor cl, 0xab
mov byte [eax + 0x933e54], cl
inc eax
cmp eax, 6
jb 0x885af3
mov eax, 0x933e54
ret

Function at 0x885b0e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381e4], 1
jne 0x885b3b
or dword [0x9381e4], 1
mov dword [0x933d90], 0xc9d9dec3
mov dword [0x933d94], 0xd9decfca
mov word [0x933d98], 0xabd9
xor eax, eax
mov cl, byte [eax + 0x933d90]
xor cl, 0xab
mov byte [eax + 0x933e5c], cl
inc eax
cmp eax, 0xa
jb 0x885b3d
mov eax, 0x933e5c
ret

Function at 0x885c1b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381e0], 1
jne 0x885c48
or dword [0x9381e0], 1
mov dword [0x933d9c], 0xc9d9dec3
mov dword [0x933da0], 0xd9decfca
mov word [0x933da4], 0xabd9
xor eax, eax
mov cl, byte [eax + 0x933d9c]
xor cl, 0xab
mov byte [eax + 0x933e68], cl
inc eax
cmp eax, 0xa
jb 0x885c4a
mov eax, 0x933e68
ret
Function at 0x88632c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381dc], 1
jne 0x886374
or dword [0x9381dc], 1
mov dword [0x933e74], 0xddd4dfce
mov dword [0x933e78], 0xc48dc2d9
mov dword [0x933e7c], 0x8dd9c4c3
mov dword [0x933e80], 0xc1c4cccb
mov word [0x933e84], 0xc9c8
mov byte [0x933e86], 0xad
xor eax, eax
mov cl, byte [eax + 0x933e74]
xor cl, 0xad
mov byte [eax + 0x933f88], cl
inc eax
cmp eax, 0x13
jb 0x886376
mov eax, 0x933f88
ret

Function at 0x886391
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381d8], 1
jne 0x8863d9
or dword [0x9381d8], 1
mov dword [0x933e88], 0xddd4dfce
mov dword [0x933e8c], 0xc48dc2d9
mov dword [0x933e90], 0x8dd9c4c3
mov dword [0x933e94], 0xc1c4cccb
mov word [0x933e98], 0xc9c8
mov byte [0x933e9a], 0xad
xor eax, eax
mov cl, byte [eax + 0x933e88]
xor cl, 0xad
mov byte [eax + 0x933f9c], cl
inc eax
cmp eax, 0x13
jb 0x8863db
mov eax, 0x933f9c
ret

Function at 0x8863f6
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381d0], 1
jne 0x88643e
or dword [0x9381d0], 1
mov dword [0x933ea4], 0xddd4dfce
mov dword [0x933ea8], 0xc48dc2d9
mov dword [0x933eac], 0x8dd9c4c3
mov dword [0x933eb0], 0xc1c4cccb
mov word [0x933eb4], 0xc9c8
mov byte [0x933eb6], 0xad
xor eax, eax
mov cl, byte [eax + 0x933ea4]
xor cl, 0xad
mov byte [eax + 0x933fb8], cl
inc eax
cmp eax, 0x13
jb 0x886440
mov eax, 0x933fb8
ret

Function at 0x88645b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381c8], 1
jne 0x8864a3
or dword [0x9381c8], 1
mov dword [0x933ebc], 0xddd4dfce
mov dword [0x933ec0], 0xc48dc2d9
mov dword [0x933ec4], 0x8dd9c4c3
mov dword [0x933ec8], 0xc1c4cccb
mov word [0x933ecc], 0xc9c8
mov byte [0x933ece], 0xad
xor eax, eax
mov cl, byte [eax + 0x933ebc]
xor cl, 0xad
mov byte [eax + 0x933fd0], cl
inc eax
cmp eax, 0x13
jb 0x8864a5
mov eax, 0x933fd0
ret

Function at 0x8864c0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381c4], 1
jne 0x8864f7
or dword [0x9381c4], 1
mov dword [0x933ed0], 0xddd4dfce
mov dword [0x933ed4], 0xcb8dc2d9
mov dword [0x933ed8], 0xc8c1c4cc
mov word [0x933edc], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933ed0]
xor cl, 0xad
mov byte [eax + 0x933fe4], cl
inc eax
cmp eax, 0xe
jb 0x8864f9
mov eax, 0x933fe4
ret

Function at 0x886514
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381c0], 1
jne 0x88654b
or dword [0x9381c0], 1
mov dword [0x933ee0], 0xddd4dfce
mov dword [0x933ee4], 0xcb8dc2d9
mov dword [0x933ee8], 0xc8c1c4cc
mov word [0x933eec], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933ee0]
xor cl, 0xad
mov byte [eax + 0x933ff4], cl
inc eax
cmp eax, 0xe
jb 0x88654d
mov eax, 0x933ff4
ret

Function at 0x886568
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381bc], 1
jne 0x886595
or dword [0x9381bc], 1
mov dword [0x933ef0], 0xdddfc8c5
mov dword [0x933ef4], 0xdfc8c986
mov word [0x933ef8], 0xaddd
xor eax, eax
mov cl, byte [eax + 0x933ef0]
xor cl, 0xad
mov byte [eax + 0x934004], cl
inc eax
cmp eax, 0xa
jb 0x886597
mov eax, 0x934004
ret
Function at 0x8865b2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381b8], 1
jne 0x8865e9
or dword [0x9381b8], 1
mov dword [0x933efc], 0xddd4dfce
mov dword [0x933f00], 0xcb8dc2d9
mov dword [0x933f04], 0xc8c1c4cc
mov word [0x933f08], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933efc]
xor cl, 0xad
mov byte [eax + 0x934010], cl
inc eax
cmp eax, 0xe
jb 0x8865eb
mov eax, 0x934010
ret

Function at 0x886606
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381b4], 1
jne 0x88663d
or dword [0x9381b4], 1
mov dword [0x933f0c], 0xddd4dfce
mov dword [0x933f10], 0xcb8dc2d9
mov dword [0x933f14], 0xc8c1c4cc
mov word [0x933f18], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933f0c]
xor cl, 0xad
mov byte [eax + 0x934020], cl
inc eax
cmp eax, 0xe
jb 0x88663f
mov eax, 0x934020
ret

Function at 0x88670b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381b0], 1
jne 0x886742
or dword [0x9381b0], 1
mov dword [0x933f1c], 0xddd4dfce
mov dword [0x933f20], 0xcb8dc2d9
mov dword [0x933f24], 0xc8c1c4cc
mov word [0x933f28], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933f1c]
xor cl, 0xad
mov byte [eax + 0x934030], cl
inc eax
cmp eax, 0xe
jb 0x886744
mov eax, 0x934030
ret

Function at 0x8868f1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381ac], 1
jne 0x886928
or dword [0x9381ac], 1
mov dword [0x933f2c], 0xddd4dfce
mov dword [0x933f30], 0xcb8dc2d9
mov dword [0x933f34], 0xc8c1c4cc
mov word [0x933f38], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933f2c]
xor cl, 0xad
mov byte [eax + 0x934040], cl
inc eax
cmp eax, 0xe
jb 0x88692a
mov eax, 0x934040
ret

Function at 0x886945
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381a8], 1
jne 0x88697c
or dword [0x9381a8], 1
mov dword [0x933f3c], 0xddd4dfce
mov dword [0x933f40], 0xcb8dc2d9
mov dword [0x933f44], 0xc8c1c4cc
mov word [0x933f48], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933f3c]
xor cl, 0xad
mov byte [eax + 0x934050], cl
inc eax
cmp eax, 0xe
jb 0x88697e
mov eax, 0x934050
ret
Function at 0x886999
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x8fd469
call fcn.008fcc58
sub esp, 0x10
push ebx
push esi
mov esi, 0x110
push esi
call fcn.008d73e1
mov ebx, eax
pop ecx
test ebx, ebx
je 0x8869ca
push esi
push 0
push ebx
call fcn.008db890
add esp, 0xc
mov esi, ebx
jmp 0x8869cc
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 [0x9381a0], 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 0x886a1b
or dword [0x9381a0], 1
mov dword [0x933f60], 0xcfc2c1cf
mov byte [0x933f64], 0xad
xor eax, eax
mov cl, byte [eax + 0x933f60]
xor cl, 0xad
mov byte [eax + 0x934060], cl
inc eax
cmp eax, 5
jb 0x886a1d
push 0
push 0x934060
push esi
push 0x88665a
push dword [edi]
call fcn.008c4228
add esp, 0x14
test eax, eax
je 0x886a85
push 0
call fcn.00886b75
push eax
push 0xffffffffffffffff
push dword [edi]
call fcn.008c2ed0
mov dword [ebp + 8], eax
add esp, 0x10
lea eax, [ebp + 8]
push eax
lea ecx, [ebp - 0x1c]
call fcn.008d6985
push 0x922d30
lea eax, [ebp - 0x1c]
push eax
mov dword [ebp - 0x1c], vtable.std::runtime_error.0
call fcn.008e0895
push esi
call fcn.008d72a4
pop ecx
mov ecx, dword [ebp - 0xc]
pop esi
pop ebx
mov dword fs:[0], ecx
leave
ret 4

Function at 0x886a9c
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x10
test byte [0x938198], 1
jne 0x886ad9
or dword [0x938198], 1
mov dword [0x933f78], 0xddd4dfce
mov dword [0x933f7c], 0xcb8dc2d9
mov dword [0x933f80], 0xc8c1c4cc
mov word [0x933f84], 0xadc9
xor eax, eax
mov cl, byte [eax + 0x933f78]
xor cl, 0xad
mov byte [eax + 0x934078], cl
inc eax
cmp eax, 0xe
jb 0x886adb
lea eax, [ebp - 4]
push eax
lea ecx, [ebp - 0x10]
mov dword [ebp - 4], 0x934078
call fcn.008d6985
push 0x922d30
lea eax, [ebp - 0x10]
push eax
mov dword [ebp - 0x10], vtable.std::runtime_error.0
call fcn.008e0895
int3

Function at 0x886b19
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9381a4], 1
jne 0x886b58
or dword [0x9381a4], 1
mov dword [0x933f4c], 0xf2ccd8c1
mov dword [0x933f50], 0xc1cccedd
mov dword [0x933f54], 0xcccb8dc1
mov dword [0x933f58], 0xc9c8c1c4
mov byte [0x933f5c], 0xad
xor eax, eax
mov cl, byte [eax + 0x933f4c]
xor cl, 0xad
mov byte [eax + 0x934088], cl
inc eax
cmp eax, 0x11
jb 0x886b5a
mov eax, 0x934088
ret

Function at 0x886b75
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93819c], 1
jne 0x886bad
or dword [0x93819c], 1
mov dword [0x933f68], 0xf2ccd8c1
mov dword [0x933f6c], 0xc9ccc2c1
mov dword [0x933f70], 0xc4cccb8d
mov dword [0x933f74], 0xadc9c8c1
xor eax, eax
mov cl, byte [eax + 0x933f68]
xor cl, 0xad
mov byte [eax + 0x934068], cl
inc eax
cmp eax, 0x10
jb 0x886baf
mov eax, 0x934068
ret
Function at 0x88730c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938180], 1
jne 0x887355
or dword [0x938180], 1
mov dword [0x93412c], 0xcadccecd
mov dword [0x934130], 0xca8f9b99
mov dword [0x934134], 0xcbc0ccc1
mov dword [0x934138], 0xcec98fca
mov dword [0x93413c], 0xcbcac3c6
mov byte [0x934140], 0xaf
xor eax, eax
mov cl, byte [eax + 0x93412c]
xor cl, 0xaf
mov byte [eax + 0x934190], cl
inc eax
cmp eax, 0x15
jb 0x887357
mov eax, 0x934190
ret

Function at 0x88749d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93817c], 1
jne 0x8874e6
or dword [0x93817c], 1
mov dword [0x934144], 0xcadccecd
mov dword [0x934148], 0xcb8f9b99
mov dword [0x93414c], 0xcbc0ccca
mov dword [0x934150], 0xcec98fca
mov dword [0x934154], 0xcbcac3c6
mov byte [0x934158], 0xaf
xor eax, eax
mov cl, byte [eax + 0x934144]
xor cl, 0xaf
mov byte [eax + 0x9341a8], cl
inc eax
cmp eax, 0x15
jb 0x8874e8
mov eax, 0x9341a8
ret

Function at 0x889d00
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380dc], 1
jne 0x889daa
or dword [0x9380dc], 1
mov dword [0x934580], 0xc1d0ddf6
mov dword [0x934584], 0xdac7c3ca
mov dword [0x934588], 0xc193dddc
mov dword [0x93458c], 0xd6c6c2d6
mov dword [0x934590], 0xd7d6c7c0
mov dword [0x934594], 0xc7c6d193
mov dword [0x934598], 0xdadbc793
mov dword [0x93459c], 0xdbc793c0
mov dword [0x9345a0], 0xd7d2d6c1
mov dword [0x9345a4], 0xc0d2db93
mov dword [0x9345a8], 0x93dcdd93
mov dword [0x9345ac], 0xc3cac1d0
mov dword [0x9345b0], 0xda93dcc7
mov dword [0x9345b4], 0xd2c7c0dd
mov dword [0x9345b8], 0xb3d6d0dd
xor eax, eax
mov cl, byte [eax + 0x934580]
xor cl, 0xb3
mov byte [eax + 0x9346a4], cl
inc eax
cmp eax, 0x3c
jb 0x889dac
mov eax, 0x9346a4
ret

Function at 0x889dc7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380d8], 1
jne 0x889e1d
or dword [0x9380d8], 1
mov dword [0x9345bc], 0xdfdad2f5
mov dword [0x9345c0], 0xc793d7d6
mov dword [0x9345c4], 0xddd693dc
mov dword [0x9345c8], 0xc3cac1d0
mov dword [0x9345cc], 0xdcc393c7
mov dword [0x9345d0], 0xd193c7c0
mov dword [0x9345d4], 0xb3cad7dc
xor eax, eax
mov cl, byte [eax + 0x9345bc]
xor cl, 0xb3
mov byte [eax + 0x9346e0], cl
inc eax
cmp eax, 0x1c
jb 0x889e1f
mov eax, 0x9346e0
ret

Function at 0x889ec1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380d4], 1
jne 0x889f2a
or dword [0x9380d4], 1
mov dword [0x9345d8], 0xdfdad2f5
mov dword [0x9345dc], 0xc793d7d6
mov dword [0x9345e0], 0xd6d793dc
mov dword [0x9345e4], 0xc3cac1d0
mov dword [0x9345e8], 0xd6c093c7
mov dword [0x9345ec], 0xc1d6c5c1
mov dword [0x9345f0], 0xc0d6c193
mov dword [0x9345f4], 0xc0dddcc3
mov word [0x9345f8], 0xb3d6
xor eax, eax
mov cl, byte [eax + 0x9345d8]
xor cl, 0xb3
mov byte [eax + 0x9346fc], cl
inc eax
cmp eax, 0x22
jb 0x889f2c
mov eax, 0x9346fc
ret
Function at 0x88a2a0
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380d0], 1
jne 0x88a2ff
or dword [0x9380d0], 1
mov dword [0x9345fc], 0xf7ffe1e6
mov dword [0x934600], 0xdfddc4dc
mov dword [0x934604], 0xe7d7d2dc
mov dword [0x934608], 0xdfdaf5dc
mov dword [0x93460c], 0xd2d593d6
mov dword [0x934610], 0xd7d6dfda
mov dword [0x934614], 0xc1db9389
mov word [0x934618], 0xb38e
xor eax, eax
mov cl, byte [eax + 0x9345fc]
xor cl, 0xb3
mov byte [eax + 0x934720], cl
inc eax
cmp eax, 0x1e
jb 0x88a301
mov eax, 0x934720
ret

Function at 0x88ae44
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380b8], 1
jne 0x88ae90
or dword [0x9380b8], 1
mov dword [0x93479c], 0xf9c1d0f2
mov dword [0x9347a0], 0xfcc1c6d4
mov dword [0x9347a4], 0xc1c0c5db
mov dword [0x9347a8], 0xdad3dbfc
mov dword [0x9347ac], 0xdcd4d395
mov dword [0x9347b0], 0xb5d1d0d9
xor eax, eax
mov cl, byte [eax + 0x93479c]
xor cl, 0xb5
mov byte [eax + 0x934828], cl
inc eax
cmp eax, 0x18
jb 0x88ae92
mov eax, 0x934828
ret

Function at 0x88b025
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380b4], 1
jne 0x88b084
or dword [0x9380b4], 1
mov dword [0x9347b4], 0xc0d6d0e7
mov dword [0x9347b8], 0xdadcc6c7
mov dword [0x9347bc], 0xd895c6db
mov dword [0x9347c0], 0x95c1c6c0
mov dword [0x9347c4], 0xd495d0d7
mov dword [0x9347c8], 0xd0d995c1
mov dword [0x9347cc], 0x95c1c6d4
mov word [0x9347d0], 0xb584
xor eax, eax
mov cl, byte [eax + 0x9347b4]
xor cl, 0xb5
mov byte [eax + 0x934840], cl
inc eax
cmp eax, 0x1e
jb 0x88b086
mov eax, 0x934840
ret

Function at 0x88b0a1
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380ac], 1
jne 0x88b0f6
or dword [0x9380ac], 1
mov dword [0x9347e0], 0xeac1d0d2
mov dword [0x9347e4], 0xd0d8dcc1
mov dword [0x9347e8], 0xdbdcc6ea
mov dword [0x9347ec], 0xd9ead0d6
mov dword [0x9347f0], 0xeac1c6d4
mov dword [0x9347f4], 0xc0c5dbdc
mov word [0x9347f8], 0xb5c1
xor eax, eax
mov cl, byte [eax + 0x9347e0]
xor cl, 0xb5
mov byte [eax + 0x93486c], cl
inc eax
cmp eax, 0x1a
jb 0x88b0f8
mov eax, 0x93486c
ret

Function at 0x88b113
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380a8], 1
jne 0x88b166
or dword [0x9380a8], 1
mov dword [0x9347fc], 0xeac1d0d2
mov dword [0x934800], 0xd0d6dbd4
mov dword [0x934804], 0xc7dac1c6
mov dword [0x934808], 0xd1dad8ea
mov dword [0x93480c], 0xead0d9c0
mov dword [0x934810], 0xddc1d4c5
mov byte [0x934814], 0xb5
xor eax, eax
mov cl, byte [eax + 0x9347fc]
xor cl, 0xb5
mov byte [eax + 0x934888], cl
inc eax
cmp eax, 0x19
jb 0x88b168
mov eax, 0x934888
ret

Function at 0x88b3e9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x9380a0], 1
jne 0x88b44f
or dword [0x9380a0], 1
mov dword [0x9348b4], 0xd7d8cce6
mov dword [0x9348b8], 0xd695d9da
mov dword [0x9348bc], 0xd1d9c0da
mov dword [0x9348c0], 0xc1dadb95
mov dword [0x9348c4], 0x95d0d795
mov dword [0x9348c8], 0xdac6d0c7
mov dword [0x9348cc], 0xd1d0c3d9
mov word [0x9348d0], 0x958f
mov byte [0x9348d2], 0xb5
xor eax, eax
mov cl, byte [eax + 0x9348b4]
xor cl, 0xb5
mov byte [eax + 0x9348f4], cl
inc eax
cmp eax, 0x1f
jb 0x88b451
mov eax, 0x9348f4
ret
Function at 0x88b9d4
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938094], 1
jne 0x88ba30
or dword [0x938094], 1
mov dword [0x934934], 0xd7c0d8ff
mov dword [0x934938], 0x96d2dfda
mov dword [0x93493c], 0xdbc3d8d3
mov dword [0x934940], 0xc2d7c4d3
mov dword [0x934944], 0x96d8d9df
mov dword [0x934948], 0xd2d8d7de
mov word [0x93494c], 0xd3da
mov byte [0x93494e], 0xb6
xor eax, eax
mov cl, byte [eax + 0x934934]
xor cl, 0xb6
mov byte [eax + 0x934ae4], cl
inc eax
cmp eax, 0x1b
jb 0x88ba32
mov eax, 0x934ae4
ret

Function at 0x88bb32
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938090], 1
jne 0x88bb8e
or dword [0x938090], 1
mov dword [0x934950], 0xd7c0d8ff
mov dword [0x934954], 0x96d2dfda
mov dword [0x934958], 0xdbc3d8d3
mov dword [0x93495c], 0xc2d7c4d3
mov dword [0x934960], 0x96d8d9df
mov dword [0x934964], 0xd2d8d7de
mov word [0x934968], 0xd3da
mov byte [0x93496a], 0xb6
xor eax, eax
mov cl, byte [eax + 0x934950]
xor cl, 0xb6
mov byte [eax + 0x934b00], cl
inc eax
cmp eax, 0x1b
jb 0x88bb90
mov eax, 0x934b00
ret

Function at 0x88bde2
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93808c], 1
jne 0x88be3e
or dword [0x93808c], 1
mov dword [0x93496c], 0xd7c0d8ff
mov dword [0x934970], 0x96d2dfda
mov dword [0x934974], 0xdbc3d8d3
mov dword [0x934978], 0xc2d7c4d3
mov dword [0x93497c], 0x96d8d9df
mov dword [0x934980], 0xd2d8d7de
mov word [0x934984], 0xd3da
mov byte [0x934986], 0xb6
xor eax, eax
mov cl, byte [eax + 0x93496c]
xor cl, 0xb6
mov byte [eax + 0x934b1c], cl
inc eax
cmp eax, 0x1b
jb 0x88be40
mov eax, 0x934b1c
ret

Function at 0x88bf40
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938088], 1
jne 0x88bf9c
or dword [0x938088], 1
mov dword [0x934988], 0xd7c0d8ff
mov dword [0x93498c], 0x96d2dfda
mov dword [0x934990], 0xdbc3d8d3
mov dword [0x934994], 0xc2d7c4d3
mov dword [0x934998], 0x96d8d9df
mov dword [0x93499c], 0xd2d8d7de
mov word [0x9349a0], 0xd3da
mov byte [0x9349a2], 0xb6
xor eax, eax
mov cl, byte [eax + 0x934988]
xor cl, 0xb6
mov byte [eax + 0x934b38], cl
inc eax
cmp eax, 0x1b
jb 0x88bf9e
mov eax, 0x934b38
ret

Function at 0x88c18d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938084], 1
jne 0x88c1f6
or dword [0x938084], 1
mov dword [0x9349a4], 0xd7c0d8ff
mov dword [0x9349a8], 0x96d2dfda
mov dword [0x9349ac], 0xd7c2d7d2
mov dword [0x9349b0], 0xccdfc596
mov dword [0x9349b4], 0xd9d096d3
mov dword [0x9349b8], 0xdfc196c4
mov dword [0x9349bc], 0xe496d3d2
mov dword [0x9349c0], 0xe5e9f1f3
mov word [0x9349c4], 0xb6ec
xor eax, eax
mov cl, byte [eax + 0x9349a4]
xor cl, 0xb6
mov byte [eax + 0x934b54], cl
inc eax
cmp eax, 0x22
jb 0x88c1f8
mov eax, 0x934b54
ret
Function at 0x88c213
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938080], 1
jne 0x88c273
or dword [0x938080], 1
mov dword [0x9349c8], 0xd7c0d8ff
mov dword [0x9349cc], 0x96d2dfda
mov dword [0x9349d0], 0xd7c2d7d2
mov dword [0x9349d4], 0xccdfc596
mov dword [0x9349d8], 0xd9d096d3
mov dword [0x9349dc], 0xf3e496c4
mov dword [0x9349e0], 0xe1f2e9f1
mov dword [0x9349e4], 0xb6f2e4f9
xor eax, eax
mov cl, byte [eax + 0x9349c8]
xor cl, 0xb6
mov byte [eax + 0x934b78], cl
inc eax
cmp eax, 0x20
jb 0x88c275
mov eax, 0x934b78
ret

Function at 0x88c417
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93807c], 1
jne 0x88c462
or dword [0x93807c], 1
mov dword [0x9349e8], 0xc3c5d8e3
mov dword [0x9349ec], 0xc4d9c6c6
mov dword [0x9349f0], 0x96d2d3c2
mov dword [0x9349f4], 0xd7c2d7d2
mov dword [0x9349f8], 0xc6cfc296
mov word [0x9349fc], 0xb6d3
xor eax, eax
mov cl, byte [eax + 0x9349e8]
xor cl, 0xb6
mov byte [eax + 0x934b98], cl
inc eax
cmp eax, 0x16
jb 0x88c464
mov eax, 0x934b98
ret

Function at 0x88c61d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93806c], 1
jne 0x88c66f
or dword [0x93806c], 1
mov dword [0x934a2c], 0xdbc3d8d3
mov dword [0x934a30], 0xc2d7c4d3
mov dword [0x934a34], 0xc3c5e9d3
mov dword [0x934a38], 0xcfd3ddd4
mov dword [0x934a3c], 0xd3d8e9c5
mov word [0x934a40], 0xc2ce
mov byte [0x934a42], 0xb6
xor eax, eax
mov cl, byte [eax + 0x934a2c]
xor cl, 0xb6
mov byte [eax + 0x934bdc], cl
inc eax
cmp eax, 0x17
jb 0x88c671
mov eax, 0x934bdc
ret

Function at 0x88c68c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93805c], 1
jne 0x88c6de
or dword [0x93805c], 1
mov dword [0x934a88], 0xdbc3d8d3
mov dword [0x934a8c], 0xc2d7c4d3
mov dword [0x934a90], 0xd7c0e9d3
mov dword [0x934a94], 0xc5d3c3da
mov dword [0x934a98], 0xd9dad5e9
mov word [0x934a9c], 0xd3c5
mov byte [0x934a9e], 0xb6
xor eax, eax
mov cl, byte [eax + 0x934a88]
xor cl, 0xb6
mov byte [eax + 0x934c38], cl
inc eax
cmp eax, 0x17
jb 0x88c6e0
mov eax, 0x934c38
ret

Function at 0x88cf86
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938028], 1
jne 0x88cfaa
or dword [0x938028], 1
mov dword [0x934cd8], 0xcbcbddd5
mov dword [0x934cdc], 0xb8dddfd9
xor eax, eax
mov cl, byte [eax + 0x934cd8]
xor cl, 0xb8
mov byte [eax + 0x935038], cl
inc eax
cmp eax, 8
jb 0x88cfac
mov eax, 0x935038
ret

Function at 0x88cfc7
Capabilities:
Encode data using xor

Disassembly:
test byte [0x938024], 1
jne 0x88cfeb
or dword [0x938024], 1
mov dword [0x934ce0], 0xcbcbddd5
mov dword [0x934ce4], 0xb8dddfd9
xor eax, eax
mov cl, byte [eax + 0x934ce0]
xor cl, 0xb8
mov byte [eax + 0x935040], cl
inc eax
cmp eax, 8
jb 0x88cfed
mov eax, 0x935040
ret

Function at 0x88db39
Capabilities:
Encode data using xor

Disassembly:
test byte [0x93801c], 1
mov ecx, 0xdcb8
jne 0x88db7a
or dword [0x93801c], 1
lea eax, [ecx - 0x22]
mov word [0x934cf0], ax
add eax, 0x3e
mov word [0x934cf2], ax
lea eax, [ecx + 0x1e]
mov word [0x934cf4], ax
add eax, 0xfffffffd
mov word [0x934cf6], ax
mov eax, ecx
mov word [0x934cf8], ax
xor eax, eax
mov edx, ecx
xor dx, word [eax + 0x934cf0]
add eax, 2
mov word [eax + 0x93504e], dx
cmp eax, 0xa
jb 0x88db7c
mov eax, 0x935050
ret