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

Disassembly:
test ecx, ecx
je 0x203d849c
test edx, edx
je 0x203d84cc
movzx eax, byte [0x2059ded0]
cmp al, 0xd7
je 0x203d8494
mov cl, 0xd9
nop word cs:[rax + rax]
mov al, 0x2f
lock cmpxchg byte [0x2059ded0], cl
je 0x203d852c
cmp al, 0xd7
jne 0x203d8480
lea rax, [0x2059dec0]
ret
test edx, edx
je 0x203d84fc
movzx eax, byte [0x2059e25a]
cmp al, 0x18
je 0x203d84c4
mov cl, 7
nop dword [rax]
mov al, 0x22
lock cmpxchg byte [0x2059e25a], cl
je 0x203d858e
cmp al, 0x18
jne 0x203d84b0
lea rax, [0x2059e250]
ret
movzx eax, byte [0x2059de93]
cmp al, 0xe4
je 0x203d84f4
mov cl, 0x5b
nop dword [rax]
mov al, 0xcc
lock cmpxchg byte [0x2059de93], cl
je 0x203d860c
cmp al, 0xe4
jne 0x203d84e0
lea rax, [0x2059de90]
ret
movzx eax, byte [0x2059e695]
cmp al, 0xc1
je 0x203d8524
mov cl, 0xb4
nop dword [rax]
mov al, 0x2d
lock cmpxchg byte [0x2059e695], cl
je 0x203d8669
cmp al, 0xc1
jne 0x203d8510
lea rax, [0x2059e680]
ret
xor eax, eax
lea rcx, [0x2059dec0]
lea rdx, [0x20493b70]
nop dword [rax]
movzx r8d, byte [rax + rcx]
mov r9d, r8d
xor r9b, 0xd4
and r8b, 0x54
add r8b, r8b
add r8b, r9b
add r8b, byte [rax + rdx]
mov r9d, r8d
xor r9b, 0x2c
and r8b, 0x2c
add r8b, r8b
add r8b, r9b
mov byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0xf
jg 0x203d857e
inc rax
jmp 0x203d8540
mov al, 0xd7
xchg byte [0x2059ded0], al
lea rax, [0x2059dec0]
ret
xor edx, edx
lea rax, [0x2059e250]
lea rcx, [0x20493ed0]
nop
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
add edx, 0xdc29ba7b
mov r8d, edx
not r8d
mov r9d, r8d
and r9d, 1
mov r10d, edx
and r10d, 0xfffffffe
or r10d, r9d
xor edx, 1
and r8d, 0x7ffffffe
or r8d, edx
not r8d
lea edx, [r10 + r8*2]
add edx, 0x23d64585
cmp edx, 0xa
jl 0x203d85a0
movzx eax, byte [0x2059f3bc]
add al, 0xe7
mov ecx, eax
xor cl, 0x2a
and al, 0x2a
add al, al
add al, cl
add al, 0xb3
xchg byte [0x2059e25a], al
lea rax, [0x2059e250]
ret
xor r8d, r8d
lea rax, [0x2059de90]
lea rcx, [0x20493b40]
mov edx, 0xac65a43f
nop word cs:[rax + rax]
movsxd r8, r8d
movzx r9d, byte [r8 + rcx]
add byte [r8 + rax], r9b
mov r9d, dword [0x2059f3b8]
add r9d, edx
mov r10d, r8d
xor r10d, r9d
and r9d, r8d
lea r8d, [r10 + r9*2]
cmp r8d, 3
jl 0x203d8630
mov al, 0xe4
xchg byte [0x2059de93], al
lea rax, [0x2059de90]
ret
xor eax, eax
lea rcx, [0x2059e680]
lea rdx, [0x204942b0]
nop dword [rax]
movzx r8d, byte [rax + rcx]
movzx r9d, byte [rax + rdx]
add r8b, 0x96
mov r10d, r8d
xor r10b, r9b
and r8b, r9b
add r8b, r8b
add r8b, r10b
mov r9d, r8d
xor r9b, 0x6a
and r8b, 0x6a
add r8b, r8b
add r8b, r9b
mov byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0x14
jg 0x203d86c1
inc rax
jmp 0x203d8680
mov al, 0xc1
xchg byte [0x2059e695], al
lea rax, [0x2059e680]
ret
Function at 0x203d8910
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203d894c
test edx, edx
je 0x203d897c
movzx eax, byte [0x2059e601]
cmp al, 0xe1
je 0x203d8944
mov cl, 0x2c
nop word cs:[rax + rax]
mov al, 0xcb
lock cmpxchg byte [0x2059e601], cl
je 0x203d8a31
cmp al, 0xe1
jne 0x203d8930
lea rax, [0x2059e500]
ret
test edx, edx
je 0x203d89ac
movzx eax, byte [0x2059e33b]
cmp al, 0x7d
je 0x203d8974
mov cl, 0x64
nop dword [rax]
mov al, 0x98
lock cmpxchg byte [0x2059e33b], cl
je 0x203d8a8a
cmp al, 0x7d
jne 0x203d8960
lea rax, [0x2059e300]
ret
movzx eax, byte [0x2059e20d]
cmp al, 0x8d
je 0x203d89a4
mov cl, 0x51
nop dword [rax]
mov al, 0x67
lock cmpxchg byte [0x2059e20d], cl
je 0x203d8ad8
cmp al, 0x8d
jne 0x203d8990
lea rax, [0x2059e200]
ret
movzx eax, byte [0x2059dd26]
nop word cs:[rax + rax]
cmp al, 0x71
je 0x203d8a29
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx + 1]
mov edx, ecx
xor dl, 0x3b
and cl, 0x3b
add cl, cl
add cl, dl
lock cmpxchg byte [0x2059dd26], cl
jne 0x203d89c0
xor edx, edx
lea rax, [0x2059dd20]
lea rcx, [0x204939d0]
nop word cs:[rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
xor byte [rdx + rax], r8b
mov r8d, dword [0x2059f3b8]
add edx, r8d
add edx, 0xac65a43f
cmp edx, 6
jl 0x203d8a00
mov al, 0x71
xchg byte [0x2059dd26], al
lea rax, [0x2059dd20]
ret
xor r8d, r8d
lea rax, [0x2059e500]
lea rcx, [0x20494140]
mov edx, 0xac65a53f
nop word [rax + rax]
movsxd r8, r8d
movzx r9d, byte [r8 + rcx]
xor byte [r8 + rax], r9b
mov r9d, r8d
xor r9d, 1
and r8d, 1
lea r8d, [r9 + r8*2]
mov r9d, dword [0x2059f3b8]
add r9d, edx
cmp r8d, r9d
jl 0x203d8a50
mov al, 0xe1
xchg byte [0x2059e601], al
lea rax, [0x2059e500]
ret
xor edx, edx
lea rax, [0x2059e300]
lea rcx, [0x20493f80]
nop word [rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
mov r8d, dword [0x2059f3b8]
add edx, r8d
add edx, 0xac65a43f
cmp edx, 0x3b
jl 0x203d8aa0
movzx eax, byte [0x2059f3bc]
add al, 0x29
xchg byte [0x2059e33b], al
lea rax, [0x2059e300]
ret
xor edx, edx
lea rax, [0x2059e200]
lea rcx, [0x20493e80]
nop dword [rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
mov r8d, dword [0x2059f3b8]
add edx, r8d
add edx, 0xac65a43f
cmp edx, 0xd
jl 0x203d8af0
mov al, 0x8d
xchg byte [0x2059e20d], al
lea rax, [0x2059e200]
ret
Function at 0x203d9670
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203d96f5
mov eax, 0xac65a43e
add eax, dword [0x2059f3b8]
cmp edx, eax
jne 0x203d975c
movzx eax, byte [0x2059e43d]
cmp al, 0x2a
je 0x203d96ed
nop word cs:[rax + rax]
movzx ecx, byte [0x2059f3bc]
mov edx, ecx
xor dl, 0x9e
mov eax, ecx
not al
and al, 0x61
or al, dl
not al
add al, al
mov r8d, edx
xor r8b, al
and al, dl
add al, al
mov edx, r8d
xor dl, al
and al, r8b
add al, al
add al, dl
add cl, 0x9b
lock cmpxchg byte [0x2059e43d], cl
je 0x203d97bc
movzx ecx, byte [0x2059f3bc]
add cl, 0xd6
cmp al, cl
jne 0x203d96a0
lea rax, [0x2059e430]
ret
test edx, edx
je 0x203d978c
movzx eax, byte [0x2059e396]
nop word cs:[rax + rax]
cmp al, 0x61
je 0x203d98a8
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx - 0xe]
add cl, 0x3a
lock cmpxchg byte [0x2059e396], cl
jne 0x203d9710
xor eax, eax
lea rcx, [0x2059e390]
lea rdx, [0x20494000]
nop
movzx r8d, byte [rax + rdx]
add byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 5
jg 0x203d98a0
inc rax
jmp 0x203d9740
movzx eax, byte [0x2059e6b6]
cmp al, 0xec
je 0x203d9784
mov cl, 0x72
nop dword [rax]
mov al, 0xf8
lock cmpxchg byte [0x2059e6b6], cl
je 0x203d9836
cmp al, 0xec
jne 0x203d9770
lea rax, [0x2059e6a0]
ret
movzx eax, byte [0x2059e1ae]
cmp al, 0xdc
je 0x203d97b4
mov cl, 0xdd
nop dword [rax]
mov al, 0x70
lock cmpxchg byte [0x2059e1ae], cl
je 0x203d98b0
cmp al, 0xdc
jne 0x203d97a0
lea rax, [0x2059e190]
ret
xor edx, edx
lea rax, [0x2059e430]
lea rcx, [0x204940a0]
nop dword [rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
mov r8d, edx
not r8d
mov r9d, r8d
and r9d, 1
mov r10d, edx
and r10d, 0xfffffffe
or r10d, r9d
xor edx, 1
and r8d, 0x7ffffffe
or r8d, edx
not r8d
lea edx, [r10 + r8*2]
add edx, 0xfbd94e44
mov r8d, edx
xor r8d, 0x426b1bc
and edx, 0x426b1bc
lea edx, [r8 + rdx*2]
cmp edx, 0xd
jl 0x203d97d0
mov al, 0x2a
xchg byte [0x2059e43d], al
lea rax, [0x2059e430]
ret
xor edx, edx
lea rax, [0x2059e6a0]
lea rcx, [0x204942d0]
nop word cs:[rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 0x2a74537
not edx
and edx, 0x7d58bac8
or edx, r8d
not edx
lea edx, [r8 + rdx*2]
mov r8d, edx
xor r8d, 1
and edx, 1
lea edx, [r8 + rdx*2]
add edx, 0xfd58bac9
cmp edx, 0x16
jl 0x203d9850
mov al, 0xec
xchg byte [0x2059e6b6], al
lea rax, [0x2059e6a0]
ret
mov al, 0x61
xchg byte [0x2059e396], al
lea rax, [0x2059e390]
ret
xor eax, eax
lea rcx, [0x2059e190]
lea rdx, [0x20493e10]
movzx r8d, byte [rax + rdx]
add byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0x1d
jg 0x203d98d8
inc rax
jmp 0x203d98c0
mov al, 0xdc
xchg byte [0x2059e1ae], al
lea rax, [0x2059e190]
ret
Function at 0x203d9b00
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203d9b3c
test edx, edx
je 0x203d9b7c
movzx eax, byte [0x2059e42e]
movzx ecx, byte [0x2059f3bc]
add cl, 0xce
cmp al, cl
je 0x203d9b34
mov cl, 0x1f
nop
mov al, 0x15
lock cmpxchg byte [0x2059e42e], cl
je 0x203d9c2c
cmp al, 0x22
jne 0x203d9b20
lea rax, [0x2059e420]
ret
test edx, edx
je 0x203d9c00
movzx eax, byte [0x2059e040]
cmp al, 0x1c
je 0x203d9b74
mov cl, 0x1d
nop word cs:[rax + rax]
mov al, 0x6d
lock cmpxchg byte [0x2059e040], cl
je 0x203d9c7b
cmp al, 0x1c
jne 0x203d9b60
lea rax, [0x2059e030]
ret
movzx eax, byte [0x2059e245]
nop word cs:[rax + rax]
cmp al, 0x99
je 0x203d9cb0
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx - 0x6c]
mov edx, ecx
xor dl, 0x66
and cl, 0x66
add cl, cl
add cl, dl
lock cmpxchg byte [0x2059e245], cl
jne 0x203d9b90
xor eax, eax
lea rcx, [0x2059e230]
lea rdx, [0x20493eb0]
nop dword [rax + rax]
movzx r8d, byte [rax + rcx]
movzx r9d, byte [rax + rdx]
mov r10d, r8d
xor r10b, r9b
and r8b, r9b
add r8b, r8b
add r8b, r10b
mov byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0x14
jg 0x203d9ca8
inc rax
jmp 0x203d9bd0
movzx eax, byte [0x2059e26b]
cmp al, 0x53
je 0x203d9c24
mov cl, 0x2e
nop dword [rax]
mov al, 0x9d
lock cmpxchg byte [0x2059e26b], cl
je 0x203d9cc8
cmp al, 0x53
jne 0x203d9c10
lea rax, [0x2059e260]
ret
xor edx, edx
lea rax, [0x2059e420]
lea rcx, [0x20494090]
nop dword [rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 0xd195556c
and edx, 0x5195556c
lea edx, [r8 + rdx*2]
add edx, 0x2e6aaa95
cmp edx, 0xe
jl 0x203d9c40
mov al, 0x22
xchg byte [0x2059e42e], al
lea rax, [0x2059e420]
ret
xor eax, eax
lea rcx, [0x2059e030]
lea rdx, [0x20493cd0]
nop dword [rax + rax]
movzx r8d, byte [rax + rdx]
add byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0xf
jg 0x203d9cb8
inc rax
jmp 0x203d9c90
mov al, 0x99
xchg byte [0x2059e245], al
lea rax, [0x2059e230]
ret
mov al, 0x1c
xchg byte [0x2059e040], al
lea rax, [0x2059e030]
ret
xor eax, eax
lea rcx, [0x2059e260]
lea rdx, [0x20493ee0]
nop dword [rax + rax]
movzx r8d, byte [rax + rdx]
movzx r9d, byte [rax + rcx]
xor r9b, r8b
mov r10d, r9d
not r10b
and r10b, r8b
add r10b, r10b
add r10b, r9b
mov byte [rax + rcx], r10b
lea r8d, [rax + 1]
cmp r8d, 0xa
jg 0x203d9d0f
inc rax
jmp 0x203d9ce0
mov al, 0x53
xchg byte [0x2059e26b], al
lea rax, [0x2059e260]
ret
Function at 0x203d9d50
Capabilities:
Encode data using xor

Disassembly:
push rbx
test ecx, ecx
je 0x203d9da2
test edx, edx
je 0x203d9e45
movzx eax, byte [0x2059e14b]
cmp al, 7
je 0x203d9f0f
mov cl, 0x42
nop
mov al, 0x67
lock cmpxchg byte [0x2059e14b], cl
je 0x203d9ea9
movzx edx, byte [0x2059f3bc]
mov r8d, edx
xor r8b, 0xaf
and dl, 0x2f
add dl, dl
add dl, r8b
add dl, 4
cmp al, dl
jne 0x203d9d70
jmp 0x203d9f0f
mov eax, 0xac65a43e
add eax, dword [0x2059f3b8]
cmp edx, eax
jne 0x203d9e79
movzx eax, byte [0x2059e223]
nop dword [rax]
cmp al, 0x98
je 0x203d9f90
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx + 0x7d]
add cl, 0xef
lock cmpxchg byte [0x2059e223], cl
jne 0x203d9dc0
xor eax, eax
lea rcx, [0x2059e210]
lea rdx, [0x20493e90]
mov r8d, 0xac65a451
nop word cs:[rax + rax]
movzx r9d, byte [rax + rcx]
movzx r10d, byte [rax + rdx]
mov r11d, r9d
not r11b
xor r9b, r11b
and r9b, r10b
xor r9b, r11b
and r11b, r10b
or r9b, r11b
not r9b
or r9b, r11b
mov byte [rax + rcx], r9b
lea r9d, [rax + 1]
mov r10d, dword [0x2059f3b8]
add r10d, r8d
cmp r9d, r10d
jge 0x203d9f88
inc rax
jmp 0x203d9e00
movzx eax, byte [0x2059e01d]
cmp al, 0x83
je 0x203d9f7f
mov cl, 0x3a
nop word cs:[rax + rax]
mov al, 0x7e
lock cmpxchg byte [0x2059e01d], cl
je 0x203d9f18
cmp al, 0x83
jne 0x203d9e60
jmp 0x203d9f7f
movzx eax, byte [0x2059e652]
cmp al, 0x4c
je 0x203d9fe1
mov cl, 0x45
nop word [rax + rax]
mov al, 0x6c
lock cmpxchg byte [0x2059e652], cl
je 0x203d9f99
cmp al, 0x4c
jne 0x203d9e90
jmp 0x203d9fe1
xor eax, eax
lea rcx, [0x2059e140]
lea rdx, [0x20493dc0]
mov r8d, 0xac65a449
nop
movzx r9d, byte [rax + rcx]
movzx r10d, byte [rax + rdx]
mov r11d, r9d
not r11b
mov ebx, r11d
xor bl, r10b
not r10b
and r9b, r10b
or r9b, bl
not r9b
xor r11b, r10b
and r11b, r10b
or r11b, r9b
mov byte [rax + rcx], r11b
lea r9d, [rax + 1]
mov r10d, dword [0x2059f3b8]
add r10d, r8d
cmp r9d, r10d
jge 0x203d9f07
inc rax
jmp 0x203d9ec0
mov al, 7
xchg byte [0x2059e14b], al
lea rax, [0x2059e140]
pop rbx
ret
xor eax, eax
lea rcx, [0x2059e010]
lea rdx, [0x20493cb0]
nop dword [rax + rax]
movzx r8d, byte [rax + rcx]
movzx r9d, byte [rax + rdx]
mov r10d, r9d
not r10b
mov r11d, r8d
and r11b, r10b
xor r10b, r8b
not r8b
mov ebx, r8d
xor bl, r9b
or r11b, bl
not r11b
and r8b, r9b
or r8b, r10b
not r8b
or r8b, r11b
mov byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0xc
jg 0x203d9f77
inc rax
jmp 0x203d9f30
mov al, 0x83
xchg byte [0x2059e01d], al
lea rax, [0x2059e010]
pop rbx
ret
mov al, 0x98
xchg byte [0x2059e223], al
lea rax, [0x2059e210]
pop rbx
ret
xor edx, edx
lea rax, [0x2059e650]
lea rcx, [0x20494290]
nop dword [rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
xor byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 1
not edx
and edx, 0x7ffffffe
or edx, r8d
not edx
lea edx, [r8 + rdx*2]
cmp edx, 2
jl 0x203d9fb0
mov al, 0x4c
xchg byte [0x2059e652], al
lea rax, [0x2059e650]
pop rbx
ret
Function at 0x203d9ff0
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203da04a
test edx, edx
je 0x203da07c
movzx eax, byte [0x2059e186]
cmp al, 0x43
je 0x203da042
nop word [rax + rax]
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx - 0x1b]
mov edx, ecx
xor dl, 0x89
and cl, 9
add cl, cl
add cl, dl
lock cmpxchg byte [0x2059e186], cl
je 0x203da131
movzx ecx, byte [0x2059f3bc]
add cl, 0xef
cmp al, cl
jne 0x203da010
lea rax, [0x2059e180]
ret
test edx, edx
je 0x203da0ec
movzx eax, byte [0x2059e7a8]
cmp al, 0x67
je 0x203da074
mov cl, 0x5f
nop
mov al, 0x87
lock cmpxchg byte [0x2059e7a8], cl
je 0x203da17f
cmp al, 0x67
jne 0x203da060
lea rax, [0x2059e790]
ret
movzx eax, byte [0x2059de72]
nop word cs:[rax + rax]
cmp al, 0xc1
je 0x203da1d7
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx + 0xe]
add cl, 2
lock cmpxchg byte [0x2059de72], cl
jne 0x203da090
xor eax, eax
lea rcx, [0x2059de70]
lea rdx, [0x20493b20]
nop
movzx r8d, byte [rax + rdx]
mov r9d, r8d
xor r9b, r8b
not r9b
and r9b, byte [rax + rcx]
xor r9b, r8b
mov byte [rax + rcx], r9b
lea r8d, [rax + 1]
cmp r8d, 1
jg 0x203da1cf
inc rax
jmp 0x203da0c0
movzx eax, byte [0x2059de6a]
cmp al, 0xd8
je 0x203da129
nop word [rax + rax]
movzx ecx, byte [0x2059f3bc]
lea eax, [rcx + 0x4a]
add cl, 0x25
lock cmpxchg byte [0x2059de6a], cl
je 0x203da1df
movzx ecx, byte [0x2059f3bc]
add cl, 0x84
cmp al, cl
jne 0x203da100
lea rax, [0x2059de60]
ret
xor edx, edx
lea rax, [0x2059e180]
lea rcx, [0x20493e00]
nop word cs:[rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
xor byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 1
and edx, 1
lea edx, [r8 + rdx*2]
cmp edx, 6
jl 0x203da150
mov al, 0x43
xchg byte [0x2059e186], al
lea rax, [0x2059e180]
ret
xor edx, edx
lea rax, [0x2059e790]
lea rcx, [0x204943b0]
nop
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
mov r9d, r8d
xor r9b, r8b
not r9b
and r9b, byte [rdx + rax]
xor r9b, r8b
mov byte [rdx + rax], r9b
mov r8d, edx
xor r8d, 1
and edx, 1
lea edx, [r8 + rdx*2]
cmp edx, 0x18
jl 0x203da190
mov al, 0x67
xchg byte [0x2059e7a8], al
lea rax, [0x2059e790]
ret
mov al, 0xc1
xchg byte [0x2059de72], al
lea rax, [0x2059de70]
ret
xor eax, eax
lea rcx, [0x2059de60]
lea rdx, [0x20493b10]
nop
movzx r8d, byte [rax + rdx]
mov r9d, r8d
xor r9b, r8b
not r9b
and r9b, byte [rax + rcx]
xor r9b, r8b
mov byte [rax + rcx], r9b
lea r8d, [rax + 1]
cmp r8d, 9
jg 0x203da218
inc rax
jmp 0x203da1f0
mov al, 0xd8
xchg byte [0x2059de6a], al
lea rax, [0x2059de60]
ret
Function at 0x203dafa0
Capabilities:
Hash data using fnv

Disassembly:
mov rax, qword [rsp + 0x28]
xor rcx, rdx
movabs rdx, 0x100000001b3
imul rcx, rdx
movzx r8d, byte [r8 + 0x17]
mov r10, r8
not r10
mov r11, rcx
and r11, r10
xor r10, rcx
not rcx
and r10, rcx
xor rcx, r8
or r11, rcx
mov rcx, r11
not rcx
or r10, r8
mov r8, rcx
xor r8, r10
and r8, rcx
xor rcx, r11
and rcx, r10
xor rcx, r11
or rcx, r8
imul rcx, rdx
mov rdx, qword [r9]
mov r8, rcx
not r8
mov r9, r8
and r9, rdx
mov r10, rcx
and rcx, rdx
not rdx
and r10, rdx
or r10, r9
xor rdx, r8
or rcx, rdx
not rcx
or rcx, r10
not rcx
mov qword [rax], rcx
ret
Function at 0x203e1d80
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203e1dbc
test edx, edx
je 0x203e1dec
movzx eax, byte [0x205a0292]
movzx ecx, byte [0x205a0b88]
add cl, 0x81
cmp al, cl
je 0x203e1db4
mov cl, 0xfa
nop
mov al, 0x3d
lock cmpxchg byte [0x205a0292], cl
je 0x203e1e5c
cmp al, 0x91
jne 0x203e1da0
lea rax, [0x205a0280]
ret
test edx, edx
je 0x203e1e26
movzx eax, byte [0x205a03cb]
cmp al, 0xea
je 0x203e1de4
mov cl, 0x8a
nop dword [rax]
mov al, 0xd5
lock cmpxchg byte [0x205a03cb], cl
je 0x203e1eb1
cmp al, 0xea
jne 0x203e1dd0
lea rax, [0x205a03b0]
ret
movzx eax, byte [0x205a026d]
cmp al, 0x2b
je 0x203e1e1e
mov cl, 0x4e
nop dword [rax]
mov al, 0xf0
lock cmpxchg byte [0x205a026d], cl
je 0x203e1ee8
movzx edx, byte [0x205a0b88]
add dl, 0x1b
cmp al, dl
jne 0x203e1e00
lea rax, [0x205a0260]
ret
movzx eax, byte [0x205a048d]
cmp al, 0xbf
je 0x203e1e54
mov cl, 0xf4
nop word cs:[rax + rax]
mov al, 0xab
lock cmpxchg byte [0x205a048d], cl
je 0x203e1f60
cmp al, 0xbf
jne 0x203e1e40
lea rax, [0x205a0470]
ret
xor eax, eax
lea rcx, [0x205a0280]
lea rdx, [0x20494640]
mov r8d, 0x1d234b5b
nop word cs:[rax + rax]
movzx r9d, byte [rax + rdx]
add byte [rax + rcx], r9b
lea r9d, [rax + 1]
mov r10d, dword [0x205a0b80]
add r10d, r8d
cmp r9d, r10d
jge 0x203e1ea1
inc rax
jmp 0x203e1e80
mov al, 0x91
xchg byte [0x205a0292], al
lea rax, [0x205a0280]
ret
xor eax, eax
lea rcx, [0x205a03b0]
lea rdx, [0x20494750]
nop word cs:[rax + rax]
movzx r8d, byte [rax + rdx]
xor byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0x1a
jg 0x203e1f50
inc rax
jmp 0x203e1ed0
xor edx, edx
lea rax, [0x205a0260]
lea rcx, [0x20494620]
nop dword [rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rax]
movzx r9d, byte [rdx + rcx]
not r8b
mov r10d, r8d
and r10b, r9b
or r8b, r9b
not r8b
or r8b, r10b
mov byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 1
not edx
and edx, 0x7ffffffe
or edx, r8d
not edx
lea edx, [r8 + rdx*2]
cmp edx, 0xd
jl 0x203e1f00
mov al, 0x2b
xchg byte [0x205a026d], al
lea rax, [0x205a0260]
ret
mov al, 0xea
xchg byte [0x205a03cb], al
lea rax, [0x205a03b0]
ret
xor edx, edx
lea rax, [0x205a0470]
lea rcx, [0x204947e0]
movsxd r8, edx
movzx edx, byte [r8 + rcx]
xor byte [r8 + rax], dl
lea edx, [r8 + r8]
sub edx, r8d
inc edx
cmp edx, 0x1d
jl 0x203e1f70
mov al, 0xbf
xchg byte [0x205a048d], al
lea rax, [0x205a0470]
ret
Function at 0x203e7d02
Capabilities:
Encode data using xor

Disassembly:
test ecx, ecx
je 0x203e7ccf
test edx, edx
je 0x203e7d0c
movzx eax, byte [0x205a11bd]
nop word cs:[rax + rax]
cmp al, 0xb4
je 0x203e7cc7
movzx ecx, byte [0x205a1d38]
lea eax, [rcx + 0x43]
add cl, 0x89
lock cmpxchg byte [0x205a11bd], cl
jne 0x203e7c70
xor edx, edx
lea rax, [0x205a11b0]
lea rcx, [0x20494d80]
nop dword [rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
xor byte [rdx + rax], r8b
mov r8d, edx
xor r8d, 1
and edx, 1
lea edx, [r8 + rdx*2]
cmp edx, 0xd
jl 0x203e7ca0
mov al, 0xb4
xchg byte [0x205a11bd], al
lea rax, [0x205a11b0]
ret
test edx, edx
je 0x203e7d50
movzx eax, byte [0x205a0f89]
movzx ecx, byte [0x205a1d38]
add cl, 0x3f
cmp al, cl
je 0x203e7d04
mov cl, 0x68
nop word [rax + rax]
mov al, 0xc9
lock cmpxchg byte [0x205a0f89], cl
je 0x203e7d7c
cmp al, 0x21
jne 0x203e7cf0
lea rax, [0x205a0f80]
ret
movzx eax, byte [0x205a0f7a]
cmp al, 6
je 0x203e7d48
nop word [rax + rax]
movzx ecx, byte [0x205a1d38]
lea eax, [rcx + 0x55]
inc cl
lock cmpxchg byte [0x205a0f7a], cl
je 0x203e7df1
movzx ecx, byte [0x205a1d38]
add cl, 0x24
cmp al, cl
jne 0x203e7d20
lea rax, [0x205a0f70]
ret
movzx eax, byte [0x205a11ac]
cmp al, 0xb5
je 0x203e7d74
mov cl, 0x12
nop dword [rax]
mov al, 0x30
lock cmpxchg byte [0x205a11ac], cl
je 0x203e7e52
cmp al, 0xb5
jne 0x203e7d60
lea rax, [0x205a11a0]
ret
xor r8d, r8d
lea rax, [0x205a0f80]
lea rcx, [0x20494b60]
mov edx, 0x2085a029
nop word cs:[rax + rax]
movsxd r8, r8d
movzx r9d, byte [r8 + rcx]
mov r10d, r9d
xor r10b, r9b
not r10b
and r10b, byte [r8 + rax]
xor r10b, r9b
mov byte [r8 + rax], r10b
mov r9d, r8d
xor r9d, 1
and r8d, 1
lea r8d, [r9 + r8*2]
mov r9d, dword [0x205a1d34]
add r9d, edx
cmp r8d, r9d
jl 0x203e7da0
movzx eax, byte [0x205a1d38]
add al, 0x3f
xchg byte [0x205a0f89], al
lea rax, [0x205a0f80]
ret
xor edx, edx
lea rax, [0x205a0f70]
lea rcx, [0x20494b50]
nop word cs:[rax + rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
add byte [rdx + rax], r8b
add edx, 0x2b593f6f
mov r8d, edx
xor r8d, 1
and edx, 1
lea edx, [r8 + rdx*2]
add edx, 0xd4a6c091
cmp edx, 0xa
jl 0x203e7e10
movzx eax, byte [0x205a1d38]
add al, 0x24
xchg byte [0x205a0f7a], al
lea rax, [0x205a0f70]
ret
xor eax, eax
lea rcx, [0x205a11a0]
lea rdx, [0x20494d70]
mov r8d, 0x2085a02c
nop dword [rax + rax]
movzx r9d, byte [rax + rdx]
xor byte [rax + rcx], r9b
lea r9d, [rax + 1]
mov r10d, dword [0x205a1d34]
add r10d, r8d
cmp r9d, r10d
jge 0x203e7e91
inc rax
jmp 0x203e7e70
mov al, 0xb5
xchg byte [0x205a11ac], al
lea rax, [0x205a11a0]
ret
Function at 0x203e8db0
Capabilities:
Encode data using xor

Disassembly:
push rbx
test ecx, ecx
je 0x203e8df3
test edx, edx
je 0x203e8e61
movzx eax, byte [0x205a1055]
cmp al, 0x46
je 0x203e8f00
mov cl, 0x80
nop
mov al, 0x3d
lock cmpxchg byte [0x205a1055], cl
je 0x203e8ec9
movzx edx, byte [0x205a1d38]
add dl, 0x64
cmp al, dl
jne 0x203e8dd0
jmp 0x203e8f00
mov eax, 0x2085a020
add eax, dword [0x205a1d34]
cmp edx, eax
jne 0x203e8e95
movzx eax, byte [0x205a1030]
movzx ecx, byte [0x205a1d38]
add cl, 7
cmp al, cl
je 0x203e8ff2
nop
movzx ecx, byte [0x205a1d38]
mov edx, ecx
xor dl, 0xd
mov eax, ecx
and al, 0xd
add al, al
add al, dl
add cl, 0x69
lock cmpxchg byte [0x205a1030], cl
je 0x203e8f59
movzx ecx, byte [0x205a1d38]
mov edx, ecx
xor dl, 7
and cl, 7
add cl, cl
add cl, dl
cmp al, cl
jne 0x203e8e20
jmp 0x203e8ff2
movzx eax, byte [0x205a0ffb]
cmp al, 0xb2
je 0x203e8f50
mov cl, 0x13
nop word cs:[rax + rax]
mov al, 0x8c
lock cmpxchg byte [0x205a0ffb], cl
je 0x203e8f09
cmp al, 0xb2
jne 0x203e8e80
jmp 0x203e8f50
movzx eax, byte [0x205a111d]
cmp al, 0xb7
je 0x203e8fe1
mov cl, 0x6b
nop word cs:[rax + rax]
mov al, 0x25
lock cmpxchg byte [0x205a111d], cl
je 0x203e8fac
cmp al, 0xb7
jne 0x203e8eb0
jmp 0x203e8fe1
xor eax, eax
lea rcx, [0x205a1040]
lea rdx, [0x20494c10]
nop dword [rax]
movzx r8d, byte [rax + rdx]
add byte [rax + rcx], r8b
lea r8d, [rax + 1]
cmp r8d, 0x14
jg 0x203e8ef8
inc rax
jmp 0x203e8ee0
mov al, 0x46
xchg byte [0x205a1055], al
lea rax, [0x205a1040]
pop rbx
ret
xor edx, edx
lea rax, [0x205a0fc0]
lea rcx, [0x20494ba0]
nop dword [rax]
movsxd rdx, edx
movzx r8d, byte [rdx + rcx]
xor byte [rdx + rax], r8b
mov r8d, dword [0x205a1d34]
add edx, r8d
add edx, 0x2085a021
add r8d, 0x2085a05b
cmp edx, r8d
jl 0x203e8f20
mov al, 0xb2
xchg byte [0x205a0ffb], al
lea rax, [0x205a0fc0]
pop rbx
ret
xor eax, eax
lea rcx, [0x205a1020]
lea rdx, [0x20494c00]
mov r8d, 0x2085a030
nop
movzx r9d, byte [rax + rcx]
movzx r10d, byte [rax + rdx]
mov r11d, r9d
not r11b
mov ebx, r10d
xor bl, r11b
and r11b, r10b
not bl
and bl, r9b
or bl, r11b
mov byte [rax + rcx], bl
lea r9d, [rax + 1]
mov r10d, dword [0x205a1d34]
add r10d, r8d
cmp r9d, r10d
jge 0x203e8fea
inc rax
jmp 0x203e8f70
xor eax, eax
lea rcx, [0x205a1110]
lea rdx, [0x20494ce0]
nop dword [rax]
cdqe
movzx r8d, byte [rax + rdx]
xor byte [rax + rcx], r8b
inc eax
cmp eax, 0xd
jl 0x203e8fc0
movzx eax, byte [0x205a1d38]
add al, 0xd5
xchg byte [0x205a111d], al
lea rax, [0x205a1110]
pop rbx
ret
mov al, 0xe9
xchg byte [0x205a1030], al
lea rax, [0x205a1020]
pop rbx
ret