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

Disassembly:
test byte [0x11d2778], 1
jne 0x1133828
or dword [0x11d2778], 1
mov dword [0x11d0ed8], 0xb99f98a6
mov dword [0x11d0edc], 0xa2818585
mov dword [0x11d0ee0], 0x81be8594
mov dword [0x11d0ee4], 0x9f9e9885
mov dword [0x11d0ee8], 0xbfb8a6d9
mov dword [0x11d0eec], 0xa1a5a5b9
mov dword [0x11d0ef0], 0xa5a1beae
mov dword [0x11d0ef4], 0xaebfbeb8
mov dword [0x11d0ef8], 0xb5bfb4a2
mov dword [0x11d0efc], 0xbcb8a5ae
mov dword [0x11d0f00], 0xa5a4beb4
mov dword [0x11d0f04], 0x9f9ed1d8
mov dword [0x11d0f08], 0x809483d1
mov dword [0x11d0f0c], 0x85829484
mov dword [0x11d0f10], 0x9f9099d1
mov dword [0x11d0f14], 0xd1949d95
mov dword [0x11d0f18], 0x9d989097
mov word [0x11d0f1c], 0x9594
mov byte [0x11d0f1e], 0xf1
xor eax, eax
mov cl, byte [eax + 0x11d0ed8]
xor cl, 0xf1
mov byte [eax + 0x11d1190], cl
inc eax
cmp eax, 0x47
jb 0x113382a
mov eax, 0x11d1190
ret

Function at 0x1133845
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2774], 1
jne 0x11338ae
or dword [0x11d2774], 1
mov dword [0x11d0f20], 0xb99f98a6
mov dword [0x11d0f24], 0xb0818585
mov dword [0x11d0f28], 0x94a39595
mov dword [0x11d0f2c], 0x82948480
mov dword [0x11d0f30], 0x9094b985
mov dword [0x11d0f34], 0x82839495
mov dword [0x11d0f38], 0x97d1d8d9
mov dword [0x11d0f3c], 0x949d9890
mov word [0x11d0f40], 0xf195
xor eax, eax
mov cl, byte [eax + 0x11d0f20]
xor cl, 0xf1
mov byte [eax + 0x11d11d8], cl
inc eax
cmp eax, 0x22
jb 0x11338b0
mov eax, 0x11d11d8
ret

Function at 0x11338cb
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2770], 1
jne 0x113391e
or dword [0x11d2770], 1
mov dword [0x11d0f44], 0x818585b9
mov dword [0x11d0f48], 0x959f94a2
mov dword [0x11d0f4c], 0x848094a3
mov dword [0x11d0f50], 0xd9858294
mov dword [0x11d0f54], 0x9097d1d8
mov dword [0x11d0f58], 0x95949d98
mov byte [0x11d0f5c], 0xf1
xor eax, eax
mov cl, byte [eax + 0x11d0f44]
xor cl, 0xf1
mov byte [eax + 0x11d11fc], cl
inc eax
cmp eax, 0x19
jb 0x1133920
mov eax, 0x11d11fc
ret

Function at 0x113393b
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d276c], 1
jne 0x113398d
or dword [0x11d276c], 1
mov dword [0x11d0f60], 0x818585b9
mov dword [0x11d0f64], 0x839484a0
mov dword [0x11d0f68], 0x979fb888
mov dword [0x11d0f6c], 0xd1d8d99e
mov dword [0x11d0f70], 0x9d989097
mov word [0x11d0f74], 0x9594
mov byte [0x11d0f76], 0xf1
xor eax, eax
mov cl, byte [eax + 0x11d0f60]
xor cl, 0xf1
mov byte [eax + 0x11d1218], cl
inc eax
cmp eax, 0x17
jb 0x113398f
mov eax, 0x11d1218
ret
Function at 0x113416d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2764], 1
jne 0x11341dd
or dword [0x11d2764], 1
mov dword [0x11d0f7c], 0xb99f98a6
mov dword [0x11d0f80], 0xa0818585
mov dword [0x11d0f84], 0x88839484
mov dword [0x11d0f88], 0x908590b5
mov dword [0x11d0f8c], 0x989087b0
mov dword [0x11d0f90], 0x9d93909d
mov dword [0x11d0f94], 0xd1d8d994
mov dword [0x11d0f98], 0x9d989097
mov word [0x11d0f9c], 0x9594
mov byte [0x11d0f9e], 0xf1
xor eax, eax
mov cl, byte [eax + 0x11d0f7c]
xor cl, 0xf1
mov byte [eax + 0x11d1234], cl
inc eax
cmp eax, 0x23
jb 0x11341df
mov eax, 0x11d1234
ret

Function at 0x11341fa
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2760], 1
jne 0x113424f
or dword [0x11d2760], 1
mov dword [0x11d0fa0], 0x94859fb8
mov dword [0x11d0fa4], 0x85949f83
mov dword [0x11d0fa8], 0x959094a3
mov dword [0x11d0fac], 0x949d98b7
mov dword [0x11d0fb0], 0x97d1d8d9
mov dword [0x11d0fb4], 0x949d9890
mov word [0x11d0fb8], 0xf195
xor eax, eax
mov cl, byte [eax + 0x11d0fa0]
xor cl, 0xf1
mov byte [eax + 0x11d1258], cl
inc eax
cmp eax, 0x1a
jb 0x1134251
mov eax, 0x11d1258
ret

Function at 0x1135037
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2744], 1
jne 0x11350be
or dword [0x11d2744], 1
mov dword [0x11d1290], 0x87d29cb3
mov dword [0x11d1294], 0x9197809c
mov dword [0x11d1298], 0x9b9c959d
mov dword [0x11d129c], 0xd2969788
mov dword [0x11d12a0], 0x97999d86
mov dword [0x11d12a4], 0x9385d29c
mov dword [0x11d12a8], 0x9d94d281
mov dword [0x11d12ac], 0xd2969c87
mov dword [0x11d12b0], 0x91d28693
mov dword [0x11d12b4], 0x9380939a
mov dword [0x11d12b8], 0x80978691
mov word [0x11d12bc], 0xf2d2
xor eax, eax
mov cl, byte [eax + 0x11d1290]
xor cl, 0xf2
mov byte [eax + 0x11d13e0], cl
inc eax
cmp eax, 0x2e
jb 0x11350c0
mov eax, 0x11d13e0
ret
Function at 0x1135504
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2740], 1
jne 0x1135560
or dword [0x11d2740], 1
mov dword [0x11d12c0], 0x81819bbf
mov dword [0x11d12c4], 0xd2959c9b
mov dword [0x11d12c8], 0x979ed293
mov dword [0x11d12cc], 0x82d28694
mov dword [0x11d12d0], 0x9c978093
mov dword [0x11d12d4], 0x81979a86
mov word [0x11d12d8], 0x819b
mov byte [0x11d12da], 0xf2
xor eax, eax
mov cl, byte [eax + 0x11d12c0]
xor cl, 0xf2
mov byte [eax + 0x11d1410], cl
inc eax
cmp eax, 0x1b
jb 0x1135562
mov eax, 0x11d1410
ret

Function at 0x113557d
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d273c], 1
jne 0x11355e6
or dword [0x11d273c], 1
mov dword [0x11d12dc], 0xd2869dbc
mov dword [0x11d12e0], 0x879d9c97
mov dword [0x11d12e4], 0x9dd29a95
mov dword [0x11d12e8], 0x93809782
mov dword [0x11d12ec], 0xd281969c
mov dword [0x11d12f0], 0x97d29c9b
mov dword [0x11d12f4], 0x9780828a
mov dword [0x11d12f8], 0x9d9b8181
mov word [0x11d12fc], 0xf29c
xor eax, eax
mov cl, byte [eax + 0x11d12dc]
xor cl, 0xf2
mov byte [eax + 0x11d142c], cl
inc eax
cmp eax, 0x22
jb 0x11355e8
mov eax, 0x11d142c
ret

Function at 0x1135603
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2738], 1
jne 0x1135663
or dword [0x11d2738], 1
mov dword [0x11d1300], 0xd29d9da6
mov dword [0x11d1304], 0x8b9c939f
mov dword [0x11d1308], 0x97829dd2
mov dword [0x11d130c], 0x969c9380
mov dword [0x11d1310], 0x9c9bd281
mov dword [0x11d1314], 0x828a97d2
mov dword [0x11d1318], 0x81819780
mov dword [0x11d131c], 0xf29c9d9b
xor eax, eax
mov cl, byte [eax + 0x11d1300]
xor cl, 0xf2
mov byte [eax + 0x11d1450], cl
inc eax
cmp eax, 0x20
jb 0x1135665
mov eax, 0x11d1450
ret

Function at 0x1135680
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2734], 1
jne 0x11356d6
or dword [0x11d2734], 1
mov dword [0x11d1320], 0x81819bbf
mov dword [0x11d1324], 0xd2959c9b
mov dword [0x11d1328], 0x9b80d293
mov dword [0x11d132c], 0xd2869a95
mov dword [0x11d1330], 0x97809382
mov dword [0x11d1334], 0x979a869c
mov dword [0x11d1338], 0xf2819b81
xor eax, eax
mov cl, byte [eax + 0x11d1320]
xor cl, 0xf2
mov byte [eax + 0x11d1470], cl
inc eax
cmp eax, 0x1c
jb 0x11356d8
mov eax, 0x11d1470
ret

Function at 0x11356f3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2730], 1
jne 0x1135764
or dword [0x11d2730], 1
mov dword [0x11d133c], 0x80939ca7
mov dword [0x11d1340], 0x829dd28b
mov dword [0x11d1344], 0x86938097
mov dword [0x11d1348], 0x9fd2809d
mov dword [0x11d134c], 0xd2868187
mov dword [0x11d1350], 0x9784939a
mov dword [0x11d1354], 0x979c9dd2
mov dword [0x11d1358], 0x97829dd2
mov dword [0x11d135c], 0x969c9380
mov byte [0x11d1360], 0xf2
xor eax, eax
mov cl, byte [eax + 0x11d133c]
xor cl, 0xf2
mov byte [eax + 0x11d148c], cl
inc eax
cmp eax, 0x25
jb 0x1135766
mov eax, 0x11d148c
ret
Function at 0x1135781
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d272c], 1
jne 0x11357fb
or dword [0x11d272c], 1
mov dword [0x11d1364], 0x939c9bb0
mov dword [0x11d1368], 0x9dd28b80
mov dword [0x11d136c], 0x93809782
mov dword [0x11d1370], 0xd2809d86
mov dword [0x11d1374], 0x8681879f
mov dword [0x11d1378], 0x84939ad2
mov dword [0x11d137c], 0x8586d297
mov dword [0x11d1380], 0x829dd29d
mov dword [0x11d1384], 0x9c938097
mov word [0x11d1388], 0x8196
mov byte [0x11d138a], 0xf2
xor eax, eax
mov cl, byte [eax + 0x11d1364]
xor cl, 0xf2
mov byte [eax + 0x11d14b4], cl
inc eax
cmp eax, 0x27
jb 0x11357fd
mov eax, 0x11d14b4
ret

Function at 0x1135818
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2728], 1
jne 0x1135881
or dword [0x11d2728], 1
mov dword [0x11d138c], 0x939c9bb0
mov dword [0x11d1390], 0x9dd28b80
mov dword [0x11d1394], 0x93809782
mov dword [0x11d1398], 0xd2809d86
mov dword [0x11d139c], 0xd2869d9c
mov dword [0x11d13a0], 0x9e829f9b
mov dword [0x11d13a4], 0x9c979f97
mov dword [0x11d13a8], 0xc8969786
mov word [0x11d13ac], 0xf2d2
xor eax, eax
mov cl, byte [eax + 0x11d138c]
xor cl, 0xf2
mov byte [eax + 0x11d14dc], cl
inc eax
cmp eax, 0x22
jb 0x1135883
mov eax, 0x11d14dc
ret
Function at 0x1137233
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
or eax, 0xffffffff
cmp dword [ebp + 8], 0
je 0x1137275
push esi
mov cl, byte [edx]
dec dword [ebp + 8]
movzx ecx, cl
mov esi, ecx
xor esi, eax
and esi, 0xf
shr eax, 4
xor eax, dword [esi*4 + 0x11bbe18]
shr ecx, 4
mov esi, eax
and esi, 0xf
xor ecx, esi
shr eax, 4
xor eax, dword [ecx*4 + 0x11bbe18]
inc edx
cmp dword [ebp + 8], 0
jne 0x1137240
pop esi
not eax
pop ebp
ret

Function at 0x1138ec0
Capabilities:
Enumerate pe sections

Disassembly:
push ebx
xor ebx, ebx
push edi
cmp ecx, ebx
je 0x1138ee5
cmp dword [ecx + 0x38], ebx
je 0x1138ee5
cmp eax, dword [ecx + 0x10]
jae 0x1138ee5
cmp dword [ecx + 0x14], 1
jne 0x1138ee5
mov edx, dword [ecx + 0x38]
mov edi, dword [edx + 0x10]
mov edi, dword [edi + eax*4]
add edi, dword [edx]
jmp 0x1138ee7
xor edi, edi
cmp edi, ebx
je 0x1138fca
cmp esi, ebx
je 0x1138fca
mov dword [esi], eax
mov ecx, dword [ecx + 0x38]
mov ecx, dword [ecx + 0x10]
mov eax, dword [ecx + eax*4]
mov dword [esi + 4], eax
mov ax, word [edi + 4]
mov word [esi + 8], ax
mov ax, word [edi + 6]
mov word [esi + 0xa], ax
mov ax, word [edi + 8]
mov word [esi + 0xc], ax
mov ax, word [edi + 0xa]
mov word [esi + 0xe], ax
movzx eax, word [edi + 0xe]
movzx edx, word [edi + 0xc]
call fcn.01138669
mov dword [esi + 0x10], eax
mov dword [esi + 0x14], edx
mov eax, dword [edi + 0x10]
mov dword [esi + 0x18], eax
mov eax, dword [edi + 0x14]
mov dword [esi + 0x20], eax
mov dword [esi + 0x24], ebx
mov eax, dword [edi + 0x18]
mov dword [esi + 0x28], eax
mov dword [esi + 0x2c], ebx
mov ax, word [edi + 0x24]
mov word [esi + 0x30], ax
mov eax, dword [edi + 0x26]
mov dword [esi + 0x34], eax
mov eax, dword [edi + 0x2a]
mov dword [esi + 0x38], eax
mov dword [esi + 0x3c], ebx
movzx ebx, word [edi + 0x1c]
mov eax, 0x103
cmp ebx, eax
jb 0x1138f76
mov ebx, eax
push ebx
lea eax, [edi + 0x2e]
push eax
lea eax, [esi + 0x44]
push eax
call fcn.01177030
mov byte [ebx + esi + 0x44], 0
movzx ebx, word [edi + 0x20]
mov eax, 0xff
add esp, 0xc
cmp ebx, eax
jb 0x1138f9b
mov ebx, eax
mov dword [esi + 0x40], ebx
movzx eax, word [edi + 0x1e]
movzx ecx, word [edi + 0x1c]
add eax, edi
lea eax, [ecx + eax + 0x2e]
push ebx
push eax
lea eax, [esi + 0x148]
push eax
call fcn.01177030
xor eax, eax
add esp, 0xc
mov byte [ebx + esi + 0x148], 0
inc eax
jmp 0x1138fcc
xor eax, eax
pop edi
pop ebx
ret

Function at 0x11399fc
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d271c], 1
jne 0x1139a81
or dword [0x11d271c], 1
mov dword [0x11d1518], 0x989d95b2
mov dword [0x11d151c], 0x80d49091
mov dword [0x11d1520], 0x8697d49b
mov dword [0x11d1524], 0x91809591
mov dword [0x11d1528], 0x958198d4
mov dword [0x11d152c], 0x958087d4
mov dword [0x11d1530], 0xdcd49180
mov dword [0x11d1534], 0x9f869b83
mov dword [0x11d1538], 0x80d48691
mov dword [0x11d153c], 0x9591869c
mov dword [0x11d1540], 0xd4cedd90
mov byte [0x11d1544], 0xf4
xor eax, eax
mov cl, byte [eax + 0x11d1518]
xor cl, 0xf4
mov byte [eax + 0x11d15e0], cl
inc eax
cmp eax, 0x2d
jb 0x1139a83
mov eax, 0x11d15e0
ret
Function at 0x1139a9e
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d270c], 1
jne 0x1139b05
or dword [0x11d270c], 1
mov dword [0x11d1554], 0x91d49bba
mov dword [0x11d1558], 0x869b8686
mov dword [0x11d155c], 0x879199d4
mov dword [0x11d1560], 0x91939587
mov dword [0x11d1564], 0x809186d4
mov dword [0x11d1568], 0x919a8681
mov dword [0x11d156c], 0x8d96d490
mov dword [0x11d1570], 0x969b9ed4
mov byte [0x11d1574], 0xf4
xor eax, eax
mov cl, byte [eax + 0x11d1554]
xor cl, 0xf4
mov byte [eax + 0x11d161c], cl
inc eax
cmp eax, 0x21
jb 0x1139b07
mov eax, 0x11d161c
ret

Function at 0x1139b22
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d2700], 1
jne 0x1139b8b
or dword [0x11d2700], 1
mov dword [0x11d15a0], 0xd49581b8
mov dword [0x11d15a4], 0x9b868691
mov dword [0x11d15a8], 0x8186d486
mov dword [0x11d15ac], 0x9a9d9a9a
mov dword [0x11d15b0], 0x8691d493
mov dword [0x11d15b4], 0xd4869b86
mov dword [0x11d15b8], 0x909a959c
mov dword [0x11d15bc], 0xce869198
mov word [0x11d15c0], 0xf4d4
xor eax, eax
mov cl, byte [eax + 0x11d15a0]
xor cl, 0xf4
mov byte [eax + 0x11d1668], cl
inc eax
cmp eax, 0x22
jb 0x1139b8d
mov eax, 0x11d1668
ret

Function at 0x1139ba8
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26fc], 1
jne 0x1139bfa
or dword [0x11d26fc], 1
mov dword [0x11d15c4], 0xb8958198
mov dword [0x11d15c8], 0x959b98ab
mov dword [0x11d15cc], 0x86808790
mov dword [0x11d15d0], 0xd4939a9d
mov dword [0x11d15d4], 0x989d9592
mov word [0x11d15d8], 0x9091
mov byte [0x11d15da], 0xf4
xor eax, eax
mov cl, byte [eax + 0x11d15c4]
xor cl, 0xf4
mov byte [eax + 0x11d168c], cl
inc eax
cmp eax, 0x17
jb 0x1139bfc
mov eax, 0x11d168c
ret
Function at 0x113a918
Capabilities:
Encode data using xor

Disassembly:
mov eax, 0x119adac
call fcn.01199c88
sub esp, 0xb0
push ebx
push esi
push edi
xor ebx, ebx
push ebx
push ebx
lea eax, [ebp - 0x10]
push eax
push ebx
push dword [ebp + 0xc]
mov dword [ebp - 0x10], ebx
push ebx
push 0x1300
call dword [0x11a212c]
test eax, eax
jne 0x113a960
call fcn.0113aab9
mov ecx, dword [ebp + 8]
push eax
call fcn.01116aa3
mov eax, dword [ebp + 8]
jmp 0x113aaaa
test byte [0x11d26f0], 1
jne 0x113a981
or dword [0x11d26f0], 1
mov dword [0x11d16c8], 0xd6fcfbff
mov byte [0x11d16cc], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d16c8]
xor cl, 0xf6
mov byte [eax + 0x11d1e9c], cl
inc eax
cmp eax, 5
jb 0x113a983
push 0xf
mov esi, 0x11d1e9c
pop edi
mov eax, esi
mov dword [ebp - 0x34], edi
mov dword [ebp - 0x38], ebx
mov byte [ebp - 0x48], bl
lea ecx, [eax + 1]
mov dl, byte [eax]
inc eax
cmp dl, bl
jne 0x113a9ae
sub eax, ecx
push eax
push esi
lea ecx, [ebp - 0x48]
call fcn.01114c4f
mov dword [ebp - 4], ebx
push dword [ebp - 0x10]
lea ecx, [ebp - 0x2c]
mov dword [ebp - 0x18], edi
mov dword [ebp - 0x1c], ebx
mov byte [ebp - 0x2c], bl
call fcn.01114cc4
lea eax, [ebp - 0x2c]
push eax
lea edi, [ebp - 0x48]
lea eax, [ebp - 0x64]
mov byte [ebp - 4], 1
call fcn.0113fdd2
pop ecx
push ebx
push 1
lea ecx, [ebp - 0x2c]
call fcn.01114ce5
push ebx
push 1
mov ecx, edi
mov byte [ebp - 4], 4
call fcn.01114ce5
push dword [ebp - 0x10]
call dword [0x11a20e0]
push ebx
push dword [ebp + 0xc]
lea esi, [ebp - 0xb8]
call fcn.0113ae04
pop ecx
pop ecx
push eax
mov byte [ebp - 4], 5
call fcn.0113ab22
push eax
lea eax, [ebp - 0x80]
push eax
call fcn.01116ae0
add esp, 0xc
push 0x11bd290
push eax
lea eax, [ebp - 0x9c]
push eax
mov byte [ebp - 4], 6
call fcn.0111d6c1
add esp, 0xc
push 0xffffffffffffffff
push ebx
push eax
lea esi, [ebp - 0x64]
mov byte [ebp - 4], 7
call fcn.0111b5e6
push ebx
push 1
lea ecx, [ebp - 0x9c]
call fcn.01114ce5
push ebx
push 1
lea ecx, [ebp - 0x80]
call fcn.01114ce5
push ebx
push 1
lea ecx, [ebp - 0xb8]
mov byte [ebp - 4], 4
call fcn.01114ce5
mov edi, dword [ebp + 8]
mov dword [edi + 0x14], 0xf
mov dword [edi + 0x10], ebx
mov byte [edi], bl
call fcn.01114c05
push ebx
push 1
mov ecx, esi
call fcn.01114ce5
mov eax, edi
mov ecx, dword [ebp - 0xc]
pop edi
pop esi
mov dword fs:[0], ecx
pop ebx
leave
ret

Function at 0x113aab9
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26f4], 1
jne 0x113ab05
or dword [0x11d26f4], 1
mov dword [0x11d16b0], 0x938498a3
mov dword [0x11d16b4], 0x98919995
mov dword [0x11d16b8], 0x92938c9f
mov dword [0x11d16bc], 0x848493d6
mov dword [0x11d16c0], 0x95d68499
mov dword [0x11d16c4], 0xf6939299
xor eax, eax
mov cl, byte [eax + 0x11d16b0]
xor cl, 0xf6
mov byte [eax + 0x11d1e84], cl
inc eax
cmp eax, 0x18
jb 0x113ab07
mov eax, 0x11d1e84
ret
Function at 0x113ab22
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26ec], 1
jne 0x113ab60
or dword [0x11d26ec], 1
mov dword [0x11d16d0], 0x8493ded6
mov dword [0x11d16d4], 0xd6849984
mov dword [0x11d16d8], 0x93929995
mov word [0x11d16dc], 0xd6cc
mov byte [0x11d16de], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d16d0]
xor cl, 0xf6
mov byte [eax + 0x11d1ea4], cl
inc eax
cmp eax, 0xf
jb 0x113ab62
mov eax, 0x11d1ea4
ret

Function at 0x113ae04
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x48
and dword [ebp - 4], 0
test byte [0x11d26e8], 1
jne 0x113ae2f
or dword [0x11d26e8], 1
mov dword [0x11d16e0], 0x929a9ad3
mov byte [0x11d16e4], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d16e0]
xor cl, 0xf6
mov byte [eax + 0x11d1eb4], cl
inc eax
cmp eax, 5
jb 0x113ae31
push dword [ebp + 0xc]
lea eax, [ebp - 0x48]
push dword [ebp + 8]
push 0x11d1eb4
push eax
call fcn.0113fe2b
and dword [esi + 0x10], 0
add esp, 0x10
lea eax, [ebp - 0x48]
mov dword [esi + 0x14], 0xf
push eax
mov ecx, esi
mov byte [esi], 0
call fcn.01114cc4
mov eax, esi
leave
ret

Function at 0x113afd3
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26e4], 1
jne 0x113b02f
or dword [0x11d26e4], 1
mov dword [0x11d16e8], 0xbb8293b1
mov dword [0x11d16ec], 0x9a839299
mov dword [0x11d16f0], 0x9a9fb093
mov dword [0x11d16f4], 0x9b97b893
mov dword [0x11d16f8], 0x9790d693
mov dword [0x11d16fc], 0x92939a9f
mov word [0x11d1700], 0xd6cc
mov byte [0x11d1702], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d16e8]
xor cl, 0xf6
mov byte [eax + 0x11d1ebc], cl
inc eax
cmp eax, 0x1b
jb 0x113b031
mov eax, 0x11d1ebc
ret

Function at 0x113b04c
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26e0], 1
jne 0x113b0a9
or dword [0x11d26e0], 1
mov dword [0x11d1704], 0xb58293a5
mov dword [0x11d1708], 0x93848483
mov dword [0x11d170c], 0x9fb28298
mov dword [0x11d1710], 0x82959384
mov dword [0x11d1714], 0xd68f8499
mov dword [0x11d1718], 0x9a9f9790
mov dword [0x11d171c], 0xd6cc9293
mov byte [0x11d1720], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d1704]
xor cl, 0xf6
mov byte [eax + 0x11d1ed8], cl
inc eax
cmp eax, 0x1d
jb 0x113b0ab
mov eax, 0x11d1ed8
ret

Function at 0x113b1bd
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26dc], 1
jne 0x113b21a
or dword [0x11d26dc], 1
mov dword [0x11d1724], 0xb58293b1
mov dword [0x11d1728], 0x93848483
mov dword [0x11d172c], 0x9fb28298
mov dword [0x11d1730], 0x82959384
mov dword [0x11d1734], 0xd68f8499
mov dword [0x11d1738], 0x9a9f9790
mov dword [0x11d173c], 0xd6cc9293
mov byte [0x11d1740], 0xf6
xor eax, eax
mov cl, byte [eax + 0x11d1724]
xor cl, 0xf6
mov byte [eax + 0x11d1ef8], cl
inc eax
cmp eax, 0x1d
jb 0x113b21c
mov eax, 0x11d1ef8
ret
Function at 0x113b3d5
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26d8], 1
jne 0x113b544
mov eax, 0xcfaa
mov ecx, eax
mov word [0x11d1748], cx
mov word [0x11d174a], cx
add ecx, 0xfffffffb
mov word [0x11d174c], cx
lea ecx, [eax - 0x28]
mov word [0x11d174e], cx
add ecx, 2
lea edx, [eax - 0xb]
mov word [0x11d1750], cx
push ebx
mov ecx, edx
mov word [0x11d1752], cx
add ecx, 0xfffffff9
push esi
mov esi, ecx
lea ecx, [eax - 0x1a]
mov word [0x11d1754], si
lea esi, [eax - 0x19]
mov word [0x11d1756], si
mov word [0x11d1764], cx
add esi, 8
add edx, 0xfffffffb
mov ecx, esi
push edi
lea edi, [eax - 0x17]
mov word [0x11d1766], cx
mov ecx, eax
mov word [0x11d175c], dx
mov edx, edi
mov word [0x11d1768], cx
mov word [0x11d176a], cx
add ecx, 0x1c
mov word [0x11d175e], dx
mov edx, ecx
or dword [0x11d26d8], 1
mov word [0x11d176c], dx
lea edx, [eax + 0x18]
mov ebx, edx
mov word [0x11d176e], bx
mov ebx, ecx
mov word [0x11d1770], bx
lea ebx, [eax + 0x25]
mov word [0x11d177e], ax
mov word [0x11d1772], bx
mov ebx, ecx
mov ecx, eax
add eax, 0xfffffffc
mov word [0x11d1780], ax
lea eax, [ecx - 0x18]
mov word [0x11d1786], ax
add eax, 0xfffffff1
mov word [0x11d1788], ax
lea eax, [ecx - 0x15]
mov word [0x11d178a], ax
add eax, 0xffffffed
mov word [0x11d178c], ax
lea eax, [ecx + 0xe]
mov word [0x11d178e], ax
add eax, 0xffffffdf
pop edi
mov word [0x11d1790], ax
lea eax, [ecx + 0x4c]
pop esi
mov word [0x11d1774], bx
mov dword [0x11d1758], 0xcf9fcfb0
mov dword [0x11d1760], 0xcf98cfbf
mov word [0x11d1776], dx
mov dword [0x11d1778], 0xcfc6cfb4
mov word [0x11d177c], cx
mov dword [0x11d1782], 0xcf99cf84
mov dword [0x11d1792], 0xcf93cf9b
mov word [0x11d1796], ax
pop ebx
xor eax, eax
mov ecx, 0xcff6
xor cx, word [eax + 0x11d1748]
add eax, 2
mov word [eax + 0x11d1f16], cx
cmp eax, 0x50
jb 0x113b546
mov eax, 0x11d1f18
ret

Function at 0x113b567
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26d4], 1
jne 0x113b5bc
or dword [0x11d26d4], 1
mov dword [0x11d1798], 0x80d699b8
mov dword [0x11d179c], 0x9f858493
mov dword [0x11d17a0], 0x9fd69899
mov dword [0x11d17a4], 0xd6999098
mov dword [0x11d17a8], 0x9f978097
mov dword [0x11d17ac], 0x9a94979a
mov word [0x11d17b0], 0xf693
xor eax, eax
mov cl, byte [eax + 0x11d1798]
xor cl, 0xf6
mov byte [eax + 0x11d1f68], cl
inc eax
cmp eax, 0x1a
jb 0x113b5be
mov eax, 0x11d1f68
ret

Function at 0x113b7ab
Capabilities:
Encode data using xor

Disassembly:
test byte [0x11d26d0], 1
jne 0x113b800
or dword [0x11d26d0], 1
mov dword [0x11d17b4], 0x80d699b8
mov dword [0x11d17b8], 0x9f858493
mov dword [0x11d17bc], 0x9fd69899
mov dword [0x11d17c0], 0xd6999098
mov dword [0x11d17c4], 0x9f978097
mov dword [0x11d17c8], 0x9a94979a
mov word [0x11d17cc], 0xf693
xor eax, eax
mov cl, byte [eax + 0x11d17b4]
xor cl, 0xf6
mov byte [eax + 0x11d1f84], cl
inc eax
cmp eax, 0x1a
jb 0x113b802
mov eax, 0x11d1f84
ret