format pe console

section '.code' import readable writeable executable

include 'win32ax.inc'

library     msvcrt, 'msvcrt.dll'

import      msvcrt,\
            printf, 'printf',\
            getchar, 'getchar'


proc print, buf
    locals
        frmt db '%02X', 0
    endl

    mov esi, [buf]
    xor ecx, ecx

@@: movzx eax, byte[esi]

    push ecx
    cinvoke printf, addr frmt, eax
    pop ecx

    inc ecx
    inc esi

    cmp ecx, 32
    jne @b

    cinvoke printf, next_line

    ret
endp

proc strkey_to_uint, s, u
    mov esi, [s]
    mov edi, [u]

    xor ecx, ecx
@@: push ecx

    mov eax, ecx
    shr eax, 1

    xor ecx, ecx

.end_step:
    mov dl, byte[esi + ecx]
    sub dl, '0'
    cmp dl, 9
    jng .is_num
    push 'A' - 10
    jmp .is_chr
.is_num:
    push '0'
.is_chr:
    mov dl, byte[esi + ecx]
    pop ebx
    sub dl, bl

    cmp ecx, 0
    jne .next_step
    shl edx, 28
    inc ecx
    jmp .end_step

.next_step:
    mov ebx, edx
    and ebx, 0xF0000000
    shr ebx, 24
    or edx, ebx

    mov byte[edi + eax], dl

    pop ecx
    add ecx, 2
    add esi, 2
    cmp ecx, 64
    jl @b

    ret
endp

proc uint_to_strkey, s, u
    mov esi, [u]
    mov edi, [s]

    xor ecx, ecx
@@: push ecx
    mov cl, 4

.end_step:
    mov al, byte[esi]
    shr al, cl
    and al, 0xF

    cmp al, 9
    jng .is_num
    push 'A' - 10
    jmp .is_chr
.is_num:
    push '0'
.is_chr:
    pop edx

    add eax, edx

    mov byte[edi], al
    inc edi

    cmp cl, 4
    jne .next_step
    xor cl, cl
    jmp .end_step

.next_step:
    pop ecx
    inc ecx
    inc esi
    cmp ecx, 32
    jl @b

    mov byte[edi], 0

    ret
endp

entry $

    stdcall strkey_to_uint, key_str, buf_uint8
    stdcall print, buf_uint8

    cinvoke printf, key_str
    cinvoke printf, next_line

    stdcall uint_to_strkey, buf_char, buf_uint8
    cinvoke printf, buf_char

    cinvoke getchar
    xor eax, eax
    ret


    key_str         db '1122334455667788990011223344556677889900112233445566778899001122', 0
    next_line       db 13, 10, 0

    buf_uint8       rb 32
    buf_char        rb 64 + 1

typedef enum _KEY_CONV_MODE {
    KEY_ERROR = -1,
    KEY_OK,
    STRKEY_TO_UINT,
    UINT_TO_STRKEY
} KEY_CONV_MODE;


int convert_key(char *s, uint8_t *u, KEY_CONV_MODE m) {
    switch (m) {
        int i;

        case STRKEY_TO_UINT:
            if (strlen(s) != 64)
                return KEY_ERROR;

            for (i = 0; i < 64; i += 2)
                u[i / 2] = (s[i] - (s[i] - '0' <= 9 ? '0' : 'A' - 10)) * 16 + s[i + 1] - (s[i + 1] - '0' <= 9 ? '0' : 'A' - 10);

            break;

        case UINT_TO_STRKEY:
            for (i = 0; i < 32; i++)
                *s++ = (u[i] >> 4) % 16 + ((u[i] >> 4) % 16 <= 9 ? '0' : 'A' - 10),
                *s++ = u[i] % 16 + (u[i] % 16 <= 9 ? '0' : 'A' - 10);

            *s = '\0';

            break;

        default:
            return KEY_ERROR;
    }

    return KEY_OK;
}

use32

min = 0xFFFF
max = 0xFFFFFFFF

rept 10 {
    mov eax, min + %t mod max
}

    cmp    al,'t'
    je    get_timestamp_id

    cmp al, 'r'
    je get_rnd_id

      get_org_origin_id:
    mov    eax,3
    ret

      get_rnd_id:
    mov eax, 4
    ret

    cmp    eax,3
    je    org_origin_label

    cmp eax, 4
    je rnd_label

      timestamp_label:
    call    make_timestamp
      make_qword_label_value:
    stos    dword [edi]
    mov    eax,edx
    stos    dword [edi]
    add    edi,0Ch
    jmp    calculation_loop

      rnd_label:
    call make_rnd
    stos    dword [edi]
    xor    eax,eax
    stos    dword [edi]
    add    edi,0Ch
    jmp    calculation_loop

  dd 0,0,0,rva advapi_name,rva advapi_table

  advapi_table:
    RtlGenRandom dd rva _RtlGenRandom
    dd 0

  advapi_name db 'advapi32.dll', 0

  _RtlGenRandom dw 0
    db 'SystemFunction036', 0

pRandomBuffer rd 1

make_rnd:
    push 4
    push pRandomBuffer
    call [RtlGenRandom]
    
    cmp eax, 0
    je .err
    
    mov eax, [pRandomBuffer]
    jmp .fin

.err:
    xor eax, eax
    dec eax
.fin:
    ret

use32

min = 0xFFFF
max = 0xFFFFFFFF

rept 10 {
    mov eax, min + %r mod max
}

format pe console

section '.code' import readable writeable executable

include 'win32ax.inc'

library msvcrt, 'msvcrt.dll'

import msvcrt,\
            printf, 'printf',\
            getchar, 'getchar'


proc print, arr, n
    locals
        frmt_byte       db '%d%s',  0

        left_bracket    db '[',     0

        delim_comma     db ', ',    0
        right_bracket   db ']',     13, 10, 0
    endl

    cinvoke printf, edx, addr left_bracket

    mov esi, [arr]
    xor ecx, ecx

@@: push ecx

    mov edx, [n]
    dec edx
    cmp ecx, edx
    jne .comma

    lea edx, [right_bracket]
    push edx

    jmp .next

.comma:
    lea edx, [delim_comma]
    push edx

.next:
    movzx eax, byte[esi]
    cinvoke printf, addr frmt_byte, eax
    add esp, 4

    pop ecx
    inc ecx
    add esi, 4

    cmp ecx, [n]
    jne @b

    ret
endp

proc qsort, arr, left, right
    mov edx, [right]
    mov ebx, [left]
    mov edi, [arr]

@02:
    mov ecx, ebx
    lea eax, [edx + ebx]
    mov esi, edx
    mov eax, eax
    test eax, eax
    jns @03
    add eax, 1

@03:
    sar eax, 1
    mov eax, dword[eax * 4 + edi]
    jmp @05

@04:
    inc ecx

@05:
    cmp dword[ecx * 4 + edi], eax
    jl @04
    jmp @07

@06:
    dec esi

@07:
    cmp dword[esi * 4 + edi], eax
    jg @06
    cmp ecx, esi
    jg @09
    mov ebx, dword[ecx * 4 + edi]
    mov dword[ebp + 8], ebx
    mov ebx, dword[esi * 4 + edi]
    cmp dword[ebp + 8], ebx
    jle @08
    mov dword[ecx * 4 + edi], ebx
    mov ebx, dword[ebp + 8]
    mov dword[esi * 4 + edi], ebx

@08:
    inc ecx
    dec esi
    cmp ecx, esi
    jle @05

@09:
    mov ebx, dword[ebp + 12]
    cmp ecx, edx
    jge @10

    stdcall qsort, edi, ecx, edx

@10:
    cmp ebx, esi
    jge @11
    mov edx, esi
    jmp @02

@11:
    ret
endp


entry $
    stdcall print, arr, arr_sz
    stdcall qsort, arr, 0, arr_sz - 1
    stdcall print, arr, arr_sz

    cinvoke getchar
    xor eax, eax
    ret


    arr         dd 99, 88, 77, 66, 55, 44, 33, 22, 11
    arr_sz      = ($ - arr) / 4