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

Disassembly:
push ebp
mov ebp, esp
sub esp, 0x1c
mov dword [ebp - 0x19], 0xa7aca886
xor ecx, ecx
mov dword [ebp - 0x15], 0xa3a8ac93
mov dword [ebp - 0x11], 0x9dbea7
mov byte [ebp - 0xd], 1
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x19], al
inc ecx
cmp ecx, 0xb
jb 0x100464f1
mov byte [ebp - 0xd], 0
xor ecx, ecx
mov dword [ebp - 0xc], 0x91879295
mov dword [ebp - 8], 0xa3e8f7f7
mov dword [ebp - 4], 0x100a5a4
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0xc], al
inc ecx
cmp ecx, 0xa
jb 0x10046520
push 0
push edx
push 2
lea eax, [ebp - 0x19]
mov byte [ebp - 1], 0
push eax
lea eax, [ebp - 0xc]
push eax
call fcn.10009ac0
add esp, 0x14
mov esp, ebp
pop ebp
ret

Function at 0x10046550
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x66], 0
je 0x10046574
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x32
jb 0x10046560
mov byte [edx + 0x66], 0
mov eax, edx
ret

Function at 0x10046580
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x6a], 0
je 0x100465a4
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x34
jb 0x10046590
mov byte [edx + 0x6a], 0
mov eax, edx
ret

Function at 0x100465b0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
xor ecx, ecx
sub esp, 0x30
cmp dword [0x1017d948], ecx
jne 0x10046628
mov dword [ebp - 0x2e], 0x4ac049c
mov dword [ebp - 0x2a], 0x4a604ab
mov dword [ebp - 0x26], 0x48b04ec
mov dword [ebp - 0x22], 0x4bd04a1
mov dword [ebp - 0x1e], 0x4a304a4
mov dword [ebp - 0x1a], 0x4a004b7
mov dword [ebp - 0x16], 0x4f504a7
mov dword [ebp - 0x12], 0x4e4
mov byte [ebp - 0xe], 1
nop dword [eax]
lea eax, [ecx + 0x4c8]
xor word [ebp + ecx*2 - 0x2e], ax
inc ecx
cmp ecx, 0xf
jb 0x10046600
lea edx, [ebp - 0x2e]
mov byte [ebp - 0xe], 0
call fcn.100464d0
mov dword [0x1017d948], eax
xor al, al
mov esp, ebp
pop ebp
ret
movaps xmm0, xmmword [0x100f1310]
movups xmmword [ebp - 0x21], xmm0
mov dword [ebp - 0x11], 0xa5beb4
mov byte [ebp - 0xd], 1
nop
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x21], al
inc ecx
cmp ecx, 0x13
jb 0x10046640
mov byte [ebp - 0xd], 0
xor eax, eax
mov dword [ebp - 0xc], 0x91879295
mov dword [ebp - 8], 0xa3e8f7f7
mov dword [ebp - 4], 0x100a5a4
lea ecx, [eax - 0x40]
xor byte [ebp + eax - 0xc], cl
inc eax
cmp eax, 0xa
jb 0x10046668
push 0
lea eax, [ebp - 0x21]
mov byte [ebp - 1], 0
push eax
lea eax, [ebp - 0xc]
push eax
call fcn.10009ac0
add esp, 0xc
cmp eax, dword [0x1017d948]
sete al
mov esp, ebp
pop ebp
ret
Function at 0x100466a0
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push ebp
mov ebp, esp
and esp, 0xfffffff8
mov eax, 0x138c
call fcn.100d27c0
push ebx
push esi
push edi
mov edi, edx
mov ebx, ecx
call dword [sym.imp.MSVCP140.dll_unsigned_int___cdecl_std::_Random_device_void_]
mov dword [esp + 0x1394], 0xffffffff
mov esi, 1
mov dword [esp + 0x14], eax
mov ecx, eax
shr ecx, 0x1e
xor ecx, eax
imul eax, ecx, 0x6c078965
add eax, esi
mov dword [esp + esi*4 + 0x14], eax
inc esi
cmp esi, 0x270
jb 0x100466d1
cmp ebx, 0x80000000
mov dword [esp + 0x10], 0x270
lea eax, [ebx - 0x80000000]
lea ecx, [ebx - 0x80000000]
cmovae ecx, eax
lea esi, [edi - 0x80000000]
cmp edi, 0x80000000
mov dword [esp + 0xc], ecx
lea eax, [edi - 0x80000000]
cmovae esi, eax
sub esi, ecx
cmp esi, 0xffffffff
jne 0x10046737
lea ecx, [esp + 0x10]
call fcn.10057d50
mov edx, eax
jmp 0x10046772
lea ebx, [esi + 1]
nop word [eax + eax]
xor edi, edi
xor eax, eax
test esi, esi
je 0x10046756
lea ecx, [esp + 0x10]
call fcn.10057d50
mov edi, eax
or eax, 0xffffffff
xor edx, edx
div ebx
mov ecx, eax
mov ebx, edx
mov eax, edi
xor edx, edx
lea edi, [esi + 1]
div edi
cmp eax, ecx
jb 0x10046772
cmp ebx, esi
lea ebx, [esi + 1]
jne 0x10046740
mov ecx, dword [esp + 0xc]
add ecx, edx
pop edi
cmp ecx, 0x80000000
pop esi
lea edx, [ecx - 0x80000000]
lea eax, [ecx - 0x80000000]
cmovae eax, edx
pop ebx
mov esp, ebp
pop ebp
ret
Function at 0x10056d50
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 8], 0
je 0x10056d74
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 3
jb 0x10056d60
mov byte [edx + 8], 0
mov eax, edx
ret

Function at 0x10056d80
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x5c], 0
je 0x10056da4
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x2d
jb 0x10056d90
mov byte [edx + 0x5c], 0
mov eax, edx
ret

Function at 0x10056db0
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0xa2], 0
je 0x10056dd7
xor eax, eax
nop dword [eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x50
jb 0x10056dc0
mov byte [edx + 0xa2], 0
mov eax, edx
ret

Function at 0x10056de0
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x78], 0
je 0x10056e04
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x3b
jb 0x10056df0
mov byte [edx + 0x78], 0
mov eax, edx
ret

Function at 0x10056e10
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 6], 0
je 0x10056e34
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 2
jb 0x10056e20
mov byte [edx + 6], 0
mov eax, edx
ret

Function at 0x10056e40
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x56], 0
je 0x10056e64
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x2a
jb 0x10056e50
mov byte [edx + 0x56], 0
mov eax, edx
ret

Function at 0x10056e70
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x72], 0
je 0x10056e94
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x38
jb 0x10056e80
mov byte [edx + 0x72], 0
mov eax, edx
ret

Function at 0x10056ef0
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 0x5c], 0
je 0x10056f14
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 0x2d
jb 0x10056f00
mov byte [edx + 0x5c], 0
ret

Function at 0x10056f40
Capabilities:
Encode data using xor

Disassembly:
mov edx, ecx
cmp byte [edx + 8], 0
je 0x10056f64
xor eax, eax
nop word [eax + eax]
lea ecx, [eax + 0x4c8]
xor word [edx + eax*2], cx
inc eax
cmp eax, 3
jb 0x10056f50
mov byte [edx + 8], 0
ret
Function at 0x10057d50
Capabilities:
Encode data using xor
Generate random numbers using a mersenne twister

Disassembly:
push ebp
mov ebp, esp
push ecx
push esi
push edi
mov edi, ecx
mov dword [ebp - 4], edi
mov eax, dword [edi]
cmp eax, 0x270
jne 0x10057dae
lea edx, [edi + 8]
mov esi, eax
nop dword [eax]
mov ecx, dword [edx - 4]
lea edx, [edx + 4]
xor ecx, dword [edx - 4]
and ecx, 0x7fffffff
xor ecx, dword [edx - 8]
mov eax, ecx
and al, 1
movzx eax, al
neg eax
sbb eax, eax
shr ecx, 1
and eax, 0x9908b0df
xor eax, dword [edx + 0x62c]
xor eax, ecx
mov dword [edx + 0x9b8], eax
sub esi, 1
jne 0x10057d70
mov eax, dword [edi]
jmp 0x10057e99
cmp eax, 0x4e0
jb 0x10057e99
mov eax, dword [edi + 0x9c4]
push ebx
lea ebx, [edi + 0x9c4]
mov edi, 0xe3
nop dword [eax + eax]
mov ecx, dword [ebx + 4]
lea edx, [ebx + 4]
xor ecx, eax
and ecx, 0x7fffffff
xor ecx, eax
mov eax, ecx
and al, 1
movzx eax, al
neg eax
sbb eax, eax
shr ecx, 1
and eax, 0x9908b0df
xor eax, dword [ebx + 0x634]
xor eax, ecx
mov dword [ebx - 0x9c0], eax
lea ebx, [edx]
mov eax, dword [edx]
sub edi, 1
jne 0x10057dd0
mov ebx, dword [ebp - 4]
mov edi, 0x18c
add ebx, 0xd50
mov eax, dword [ebx]
nop dword [eax]
mov ecx, eax
lea edx, [ebx + 4]
xor ecx, dword [edx]
and ecx, 0x7fffffff
xor ecx, eax
mov eax, ecx
and al, 1
movzx eax, al
neg eax
sbb eax, eax
shr ecx, 1
and eax, 0x9908b0df
xor eax, dword [ebx - 0xd4c]
xor eax, ecx
mov dword [ebx - 0x9c0], eax
lea ebx, [edx]
mov eax, dword [edx]
sub edi, 1
jne 0x10057e20
mov edi, dword [ebp - 4]
pop ebx
mov ecx, dword [edi + 0x1380]
xor ecx, dword [edi + 4]
and ecx, 0x7fffffff
xor ecx, dword [edi + 0x1380]
mov eax, ecx
and al, 1
movzx eax, al
neg eax
sbb eax, eax
shr ecx, 1
and eax, 0x9908b0df
xor eax, dword [edi + 0x634]
xor eax, ecx
mov dword [edi + 0x9c0], eax
xor eax, eax
mov dword [edi], 0
mov edx, dword [edi + eax*4 + 4]
inc eax
mov dword [edi], eax
mov ecx, edx
mov eax, dword [edi + 0x1384]
shr ecx, 0xb
and eax, ecx
xor edx, eax
mov eax, edx
and eax, 0xff3a58ad
shl eax, 7
xor edx, eax
mov eax, edx
and eax, 0xffffdf8c
shl eax, 0xf
xor edx, eax
mov eax, edx
shr eax, 0x12
pop edi
xor eax, edx
pop esi
mov esp, ebp
pop ebp
ret
Function at 0x10057ff0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, dword fs:[0]
push 0xffffffffffffffff
push 0x100d5cb1
push eax
mov dword fs:[0], esp
sub esp, 0x20
mov eax, dword fs:[0x2c]
mov edx, dword [0x100fbfac]
push esi
mov esi, ecx
mov edx, dword [eax + edx*4]
mov eax, dword [0x1017d96c]
cmp eax, dword [edx + 4]
jle 0x100580d0
push 0x1017d96c
call fcn.100d136a
add esp, 4
cmp dword [0x1017d96c], 0xffffffff
jne 0x100580d0
mov dword [ebp - 4], 0
xor ecx, ecx
mov dword [ebp - 0x28], 0x94ac9ead
mov dword [ebp - 0x24], 0xb5a3b1a5
mov dword [ebp - 0x20], 0xaebcac84
mov word [ebp - 0x1c], 0xa0
mov byte [ebp - 0x1a], 1
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x28], al
inc ecx
cmp ecx, 0xd
jb 0x10058070
mov byte [ebp - 0x1a], 0
xor ecx, ecx
mov dword [ebp - 0x19], 0x979d9584
mov dword [ebp - 0x15], 0xa6aa9582
mov dword [ebp - 0x11], 0xb8acb1
mov byte [ebp - 0xd], 1
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x19], al
inc ecx
cmp ecx, 0xb
jb 0x100580a0
lea eax, [ebp - 0x28]
mov byte [ebp - 0xd], 0
push eax
lea eax, [ebp - 0x19]
push eax
call fcn.10007f10
push 0x1017d96c
mov dword [0x1017d9a8], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d9a8]
mov ecx, dword [ebp - 0xc]
cmp byte [eax + esi], 1
mov dword fs:[0], ecx
seta al
pop esi
mov esp, ebp
pop ebp
ret

Function at 0x100580f0
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, dword fs:[0]
push 0xffffffffffffffff
push 0x100d5cd1
push eax
mov dword fs:[0], esp
sub esp, 0x44
mov eax, dword fs:[0x2c]
mov edx, dword [0x100fbfac]
push esi
mov esi, ecx
mov edx, dword [eax + edx*4]
mov eax, dword [0x1017d994]
cmp eax, dword [edx + 4]
jle 0x10058204
push 0x1017d994
call fcn.100d136a
add esp, 4
cmp dword [0x1017d994], 0xffffffff
jne 0x10058204
mov dword [ebp - 4], 0
xor ecx, ecx
movaps xmm0, xmmword [0x100f10b0]
movups xmmword [ebp - 0x38], xmm0
mov dword [ebp - 0x28], 0xb0b3a5a4
mov word [ebp - 0x24], 0xbf
mov byte [ebp - 0x22], 1
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x38], al
inc ecx
cmp ecx, 0x15
jb 0x10058170
movaps xmm0, xmmword [0x100f1300]
xor ecx, ecx
mov byte [ebp - 0x22], 0
movups xmmword [ebp - 0x4f], xmm0
mov dword [ebp - 0x3f], 0xa7b395be
mov word [ebp - 0x3b], 0xb5
mov byte [ebp - 0x39], 1
nop
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x4f], al
inc ecx
cmp ecx, 0x15
jb 0x100581a0
movaps xmm0, xmmword [0x100f1590]
xor ecx, ecx
mov byte [ebp - 0x39], 0
movups xmmword [ebp - 0x21], xmm0
mov dword [ebp - 0x11], 0xbcbea0
mov byte [ebp - 0xd], 1
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x21], al
inc ecx
cmp ecx, 0x13
jb 0x100581d0
lea eax, [ebp - 0x38]
mov byte [ebp - 0xd], 0
push eax
lea eax, [ebp - 0x4f]
push eax
lea eax, [ebp - 0x21]
push eax
call fcn.1000ef40
push 0x1017d994
mov dword [0x1017d9b8], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d9b8]
cmp byte [eax + esi + 0xc], 0
jne 0x1005822a
cmp dword [esi + 0xb28], 0
jne 0x1005822a
xor al, al
pop esi
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
mov esp, ebp
pop ebp
ret
mov ecx, dword [ebp - 0xc]
mov al, 1
pop esi
mov dword fs:[0], ecx
mov esp, ebp
pop ebp
ret
Function at 0x10058240
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, dword fs:[0]
push 0xffffffffffffffff
push 0x100d5cf1
push eax
mov dword fs:[0], esp
sub esp, 0x64
mov eax, dword fs:[0x2c]
mov ecx, dword [0x100fbfac]
push esi
push edi
mov esi, dword [eax + ecx*4]
mov eax, dword [0x1017d9a4]
cmp eax, dword [esi + 4]
jle 0x1005839f
push 0x1017d9a4
call fcn.100d136a
add esp, 4
cmp dword [0x1017d9a4], 0xffffffff
jne 0x1005839f
mov dword [ebp - 4], 0
xor eax, eax
mov dword [ebp - 0x6c], 0x4f1048d
xor ecx, ecx
mov dword [ebp - 0x68], 0x4f404ea
mov dword [ebp - 0x64], 0x4f204ec
mov dword [ebp - 0x60], 0x4f004ee
mov dword [ebp - 0x5c], 0x4ee04f0
mov dword [ebp - 0x58], 0x4eb04f2
mov dword [ebp - 0x54], 0x4f504e7
mov dword [ebp - 0x50], 0x4e30495
mov dword [ebp - 0x4c], 0x4e804f8
mov dword [ebp - 0x48], 0x4fb04ee
mov dword [ebp - 0x44], 0x4e804e4
mov dword [ebp - 0x40], 0x49c04fe
mov dword [ebp - 0x3c], 0x4c104d0
mov dword [ebp - 0x38], 0x4d704d5
mov dword [ebp - 0x34], 0x4d404c4
mov dword [ebp - 0x30], 0x4c704d6
mov dword [ebp - 0x2c], 0x4d104de
mov word [ebp - 0x28], ax
mov byte [ebp - 0x26], 1
lea eax, [ecx + 0x4c8]
xor word [ebp + ecx*2 - 0x6c], ax
inc ecx
cmp ecx, 0x22
jb 0x10058321
xor eax, eax
mov byte [ebp - 0x26], 0
mov dword [ebp - 0x24], 0x4ad04a3
mov dword [ebp - 0x20], 0x4a604ab
mov dword [ebp - 0x1c], 0x4b104aa
mov dword [ebp - 0x18], 0x4a304e8
mov dword [ebp - 0x14], 0x4a504a4
mov word [ebp - 0x10], ax
mov byte [ebp - 0xe], 1
lea ecx, [eax + 0x4c0]
xor word [ebp + eax*2 - 0x24], cx
inc eax
cmp eax, 0xa
jb 0x10058363
lea eax, [ebp - 0x6c]
mov byte [ebp - 0xe], 0
push eax
lea eax, [ebp - 0x24]
push eax
call fcn.100d08f0
inc eax
mov dword [ebp - 4], 0xffffffff
push 0x1017d9a4
mov dword [0x1017d9a0], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d970]
cmp eax, dword [esi + 4]
jle 0x100583e1
push 0x1017d970
call fcn.100d136a
add esp, 4
cmp dword [0x1017d970], 0xffffffff
jne 0x100583e1
mov ecx, dword [0x1017d9a0]
push 0x1017d970
mov eax, dword [ecx]
add ecx, 4
add eax, ecx
mov dword [0x1017d97c], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d980]
cmp eax, dword [esi + 4]
jle 0x1005841b
push 0x1017d980
call fcn.100d136a
add esp, 4
cmp dword [0x1017d980], 0xffffffff
jne 0x1005841b
mov eax, dword [0x1017d97c]
push 0x1017d980
mov dword [0x1017d998], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d998]
push 0x20
call eax
mov ecx, dword [ebp - 0xc]
add esp, 4
mov dword fs:[0], ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret
Function at 0x10058a60
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x100d4510
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
sub esp, 0x34
cmp dword [0x1017dbe8], 0
push esi
push edi
movss dword [ebp - 0x10], xmm1
je 0x10058c4b
mov eax, dword fs:[0x2c]
mov ecx, dword [0x100fbfac]
mov esi, dword [eax + ecx*4]
mov eax, dword [0x1017ec04]
cmp eax, dword [esi + 4]
jle 0x10058b94
push 0x1017ec04
call fcn.100d136a
add esp, 4
cmp dword [0x1017ec04], 0xffffffff
jne 0x10058b94
mov eax, dword [0x1017d988]
mov edi, dword [0x1017dbe8]
cmp eax, dword [esi + 4]
jle 0x10058b75
push 0x1017d988
call fcn.100d136a
add esp, 4
cmp dword [0x1017d988], 0xffffffff
jne 0x10058b75
mov dword [ebp - 0x1e], 0xafa49ead
xor ecx, ecx
mov dword [ebp - 0x1a], 0xb4bea489
mov dword [ebp - 0x16], 0xafafacb8
mov word [ebp - 0x12], 0x100
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x1e], al
inc ecx
cmp ecx, 0xc
jb 0x10058b13
mov byte [ebp - 0x11], 0
xor ecx, ecx
mov dword [ebp - 0x2d], 0x819d9584
mov dword [ebp - 0x29], 0x97a3b6a5
mov dword [ebp - 0x25], 0xaeb3a8a4
mov word [ebp - 0x21], 0xbe
mov byte [ebp - 0x1f], 1
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x2d], al
inc ecx
cmp ecx, 0xd
jb 0x10058b45
lea eax, [ebp - 0x1e]
mov byte [ebp - 0x1f], 0
push eax
lea eax, [ebp - 0x2d]
push eax
call fcn.10007f10
push 0x1017d988
mov dword [0x1017d984], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d984]
push 0x1017ec04
movss xmm0, dword [eax + edi]
movss dword [0x1017ec08], xmm0
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017ec14]
cmp eax, dword [esi + 4]
jle 0x10058bfe
push 0x1017ec14
call fcn.100d136a
add esp, 4
cmp dword [0x1017ec14], 0xffffffff
jne 0x10058bfe
mov ecx, dword [0x100fc338]
xor edx, edx
movaps xmm0, xmmword [0x100f14a0]
mov eax, dword [ecx]
movups xmmword [ebp - 0x3f], xmm0
mov word [ebp - 0x2f], 0x100
mov esi, dword [eax + 0x34]
lea eax, [edx - 0x40]
xor byte [ebp + edx - 0x3f], al
inc edx
cmp edx, 0x10
jb 0x10058bd5
lea eax, [ebp - 0x3f]
mov byte [ebp - 0x2e], 0
push eax
call esi
push 0x1017ec14
mov dword [0x1017ec1c], eax
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017ec1c]
movss xmm0, dword [0x100f0884]
movss xmm1, dword [0x100f06a8]
mov eax, dword [eax + 0x1c]
divss xmm0, dword [eax + 0x2c]
divss xmm0, dword [0x1017ec08]
divss xmm0, dword [ebp - 0x10]
comiss xmm1, xmm0
jbe 0x10058c4b
comiss xmm0, dword [0x100f08f4]
jbe 0x10058c4b
call fcn.1000fd10
mov ecx, dword [ebp - 0xc]
mov dword fs:[0], ecx
pop edi
pop esi
mov esp, ebp
pop ebp
ret
mov ecx, dword [ebp - 0xc]
xorps xmm0, xmm0
pop edi
mov dword fs:[0], ecx
pop esi
mov esp, ebp
pop ebp
ret
Function at 0x10058c70
Capabilities:
Encode data using xor

Disassembly:
push ebx
mov ebx, esp
sub esp, 8
and esp, 0xfffffff8
add esp, 4
push ebp
mov ebp, dword [ebx + 4]
mov dword [esp + 4], ebp
mov ebp, esp
push 0xffffffffffffffff
push 0x100d5d11
mov eax, dword fs:[0]
push eax
mov dword fs:[0], esp
push ebx
sub esp, 0x80
mov eax, dword [0x100db158]
mov ecx, dword [0x100fbfac]
movups xmm0, xmmword [str.use_action_slot_item_server]
mov dword [ebp - 0x30], eax
xor eax, eax
mov word [ebp - 0x2c], ax
mov eax, dword fs:[0x2c]
push esi
movups xmmword [ebp - 0x48], xmm0
push edi
mov esi, dword [eax + ecx*4]
movq xmm0, qword [0x100db150]
mov eax, dword [0x1017ec0c]
movq qword [ebp - 0x38], xmm0
cmp eax, dword [esi + 4]
jle 0x10058e2e
push 0x1017ec0c
call fcn.100d136a
add esp, 4
cmp dword [0x1017ec0c], 0xffffffff
jne 0x10058e2e
mov dword [ebp - 4], 0
xor eax, eax
mov dword [ebp - 0x90], 0x48f048e
xor ecx, ecx
mov dword [ebp - 0x8c], 0x4fa04ea
mov dword [ebp - 0x88], 0x4ed04f9
mov dword [ebp - 0x84], 0x4ef04f1
mov dword [ebp - 0x80], 0x4f104ef
mov dword [ebp - 0x7c], 0x4f304ed
mov dword [ebp - 0x78], 0x4f504eb
mov dword [ebp - 0x74], 0x4e404ee
mov dword [ebp - 0x70], 0x49a04f8
mov dword [ebp - 0x6c], 0x4fb04ee
mov dword [ebp - 0x68], 0x4e504ec
mov dword [ebp - 0x64], 0x4e704fe
mov dword [ebp - 0x60], 0x4c104d9
mov dword [ebp - 0x5c], 0x4d504d2
mov dword [ebp - 0x58], 0x4dd04c4
mov dword [ebp - 0x54], 0x4c704a4
mov dword [ebp - 0x50], 0x4df04ab
mov word [ebp - 0x4c], ax
mov byte [ebp - 0x4a], 1
nop word [eax + eax]
lea eax, [ecx + 0x4c8]
xor word [ebp + ecx*2 - 0x90], ax
inc ecx
cmp ecx, 0x22
jb 0x10058da0
xor eax, eax
mov byte [ebp - 0x4a], 0
mov dword [ebp - 0x28], 0x4ad04a3
xor ecx, ecx
mov dword [ebp - 0x24], 0x4a604ab
mov dword [ebp - 0x20], 0x4b104aa
mov dword [ebp - 0x1c], 0x4a304e8
mov dword [ebp - 0x18], 0x4a504a4
mov word [ebp - 0x14], ax
mov byte [ebp - 0x12], 1
nop word [eax + eax]
lea eax, [ecx + 0x4c0]
xor word [ebp + ecx*2 - 0x28], ax
inc ecx
cmp ecx, 0xa
jb 0x10058df0
lea eax, [ebp - 0x90]
mov byte [ebp - 0x12], 0
push eax
lea eax, [ebp - 0x28]
push eax
call fcn.100d08f0
push 0x1017ec0c
mov dword [0x1017ec20], eax
mov dword [ebp - 4], 0xffffffff
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017ec10]
cmp eax, dword [esi + 4]
jle 0x10058e6d
push 0x1017ec10
call fcn.100d136a
add esp, 4
cmp dword [0x1017ec10], 0xffffffff
jne 0x10058e6d
mov eax, dword [0x1017ec20]
push 0x1017ec10
mov eax, dword [eax + 2]
mov eax, dword [eax]
mov dword [0x1017ec18], eax
call fcn.100d1320
add esp, 4
mov edi, dword [ebx + 8]
xor esi, esi
test esi, esi
je 0x10058eab
cmp esi, 0x10
je 0x10058e9f
mov dword [esi + edi], 0
add esi, 4
cmp esi, 0x1d
jl 0x10058e72
mov ecx, dword [ebp - 0xc]
pop edi
mov dword fs:[0], ecx
pop esi
mov esp, ebp
pop ebp
mov esp, ebx
pop ebx
ret 4
mov dword [esi + edi], 0x10000
add esi, 4
jmp 0x10058e72
lea eax, [ebp - 0x48]
push 1
push eax
call dword [0x1017ec18]
add esp, 8
mov dword [esi + edi], eax
add esi, 4
jmp 0x10058e72
Function at 0x10058f00
Capabilities:
Encode data using xor

Disassembly:
push ebp
mov ebp, esp
mov eax, dword fs:[0]
push 0xffffffffffffffff
push 0x100d5d3d
push eax
mov dword fs:[0], esp
sub esp, 0x3c
cmp byte [0x100f961c], 0
push esi
push edi
je 0x10059125
mov esi, dword [0x1017dbe8]
test esi, esi
je 0x10059125
mov eax, dword fs:[0x2c]
mov ecx, dword [0x100fbfac]
mov edi, dword [eax + ecx*4]
mov eax, dword [0x1017d968]
cmp eax, dword [edi + 4]
jle 0x10058ff7
push 0x1017d968
call fcn.100d136a
add esp, 4
cmp dword [0x1017d968], 0xffffffff
jne 0x10058ff7
mov dword [ebp - 4], 0
xor ecx, ecx
movaps xmm0, xmmword [0x100f1360]
movups xmmword [ebp - 0x2d], xmm0
mov dword [ebp - 0x1d], 0x100a5bf
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x2d], al
inc ecx
cmp ecx, 0x12
jb 0x10058f90
mov byte [ebp - 0x1a], 0
xor ecx, ecx
mov dword [ebp - 0x19], 0x979d9584
mov dword [ebp - 0x15], 0xa6aa9582
mov dword [ebp - 0x11], 0xb8acb1
mov byte [ebp - 0xd], 1
nop dword [eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x19], al
inc ecx
cmp ecx, 0xb
jb 0x10058fc0
lea eax, [ebp - 0x2d]
mov byte [ebp - 0xd], 0
push eax
lea eax, [ebp - 0x19]
push eax
call fcn.10007f10
push 0x1017d968
mov dword [0x1017d978], eax
mov dword [ebp - 4], 0xffffffff
call fcn.100d1320
add esp, 4
mov eax, dword [0x1017d978]
mov al, byte [eax + esi]
test al, al
jne 0x10059125
mov eax, dword [0x1017d990]
mov esi, dword [0x1017dbe8]
cmp eax, dword [edi + 4]
jle 0x100590ee
push 0x1017d990
call fcn.100d136a
add esp, 4
cmp dword [0x1017d990], 0xffffffff
jne 0x100590ee
mov dword [ebp - 4], 1
xor ecx, ecx
movaps xmm0, xmmword [0x100f13a0]
movups xmmword [ebp - 0x45], xmm0
mov dword [ebp - 0x35], 0xba86a3b5
mov dword [ebp - 0x31], 0x100b0b9
nop word [eax + eax]
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x45], al
inc ecx
cmp ecx, 0x16
jb 0x10059060
mov byte [ebp - 0x2e], 0
xor ecx, ecx
mov dword [ebp - 0x16], 0xab919ead
mov dword [ebp - 0x12], 0xa3a3b7a5
mov word [ebp - 0xe], 0x100
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x16], al
inc ecx
cmp ecx, 8
jb 0x10059087
mov byte [ebp - 0xd], 0
xor ecx, ecx
mov dword [ebp - 0x26], 0x979d9584
mov dword [ebp - 0x22], 0xa6aa9582
mov dword [ebp - 0x1e], 0xb8acb1
mov byte [ebp - 0x1a], 1
lea eax, [ecx - 0x40]
xor byte [ebp + ecx - 0x26], al
inc ecx
cmp ecx, 0xb
jb 0x100590b3
lea eax, [ebp - 0x45]
mov byte [ebp - 0x1a], 0
push eax
lea eax, [ebp - 0x16]
push eax
lea eax, [ebp - 0x26]
push eax
call fcn.1000ef40
push 0x1017d990
mov dword [0x1017d9b0], eax
mov dword [ebp - 4], 0xffffffff
call fcn.100d1320
add esp, 4
mov eax, dword [0x100fc33c]
movss xmm0, dword [eax + 0xc]
mov eax, dword [0x1017d9b0]
comiss xmm0, dword [eax + esi]
jbe 0x10059125
call fcn.10058240
mov esi, eax
test esi, esi
je 0x10059125
push esi
call fcn.10058c70
mov ecx, dword [0x100fc310]
push esi
mov eax, dword [ecx]
mov eax, dword [eax + 0x1fc]
call eax
mov ecx, dword [ebp - 0xc]
pop edi
mov dword fs:[0], ecx
pop esi
mov esp, ebp
pop ebp
ret