inline int randrnd(int max)
{
   int a;
   _asm
   {
      rdtsc   ; call read time-stamp counter instruction
                ; returns timer value in edx:eax
      cdq     ; convert double word to quad word
                ; edx:eax <-- sign extension of EAX
      idiv max   ; divide edx:eax by max integer
                     ; stores result in EAX <- Quotient, EDX <- Remainder
                     ; EDX = edx:eax % max
      cmp edx, 0  ; compare value to zero?
      jnl after       ; jump if not less than to after: label
      neg edx      ; otherwise, change sign to positive
after:
      mov a, edx  ; store random number in a
   }
   return(a);      // return random number
}
    

inline int randrnd(int max) 
{ 
int a; 
_asm 
{ 
rdtsc ; call read time-stamp counter instruction 
; returns timer value in edx:eax 
cdq ; convert double word to quad word 
; edx:eax <-- sign extension of EAX 
idiv max ; divide edx:eax by max integer 
; stores result in EAX <- Quotient, EDX <- Remainder 
; EDX = edx:eax % max 
or edx,edx ;cmp edx, 0 ; compare value to zero? 
jns after ;jnl after ; jump if not less than to after: label 
neg edx ; otherwise, change sign to positive 
after: 
mov a, edx ; store random number in a 
} 
return(a); // return random number 
}
    

rdtsc
xor     edx, edx ; non-negative quad-word
div     max      ; hope it work so
    

org 256

call set320x200x256
call initrandomz


mainloop:

mov ecx,320
call randomz3
mov bx,ax

mov ecx,200
call randomz3
mov cx,ax

push ecx
mov ecx,256
call randomz3
pop ecx

call putpixel320x200x256 ; al=color bx=x cx=y

push eax
call bkeycheck
cmp al,27
pop eax
jnz mainloop

call set80x25t

int 20h

initrandomz: ; modifies edx, eax
rdtsc
ret


randomz3: ; Z3 ecx=range transparent
push ebx  ; number returned is:  0 <= n < ecx
push edx
mov ebx,eax
rdtsc

mov dx,cx

mov cl,al
xor cl,ah
ror ch,4
xor bl,ch
and cx,$f
rol bx,cl
btc bx,cx
xor bx,ax
ror eax,16
xor bx,ax
ror eax,16
mov cl,al
xor cl,ah
ror ch,4
xor bl,ch
and cx,$f
ror bx,cl
btc bx,cx

mov cl,bl
.minorloop:
rol eax,cl
and cx,$f
btc ax,cx
loopw .minorloop
mov cl,bh
.majorloop:
ror eax,cl
and cl,$f
btc ax,cx
loopw .majorloop
mov cx,dx

mul ecx
mov eax,edx
pop edx
pop ebx
ret

putpixel320x200x256: ; al=color, bx=x, cx=y
        push    es
        push    $A000
        pop     es
        mov     di,cx   ; y
        shl     cx,2
        add     di,cx   ; 5y
        shl     di,6    ; 320y
        add     di,bx
        stosb
        pop     es
        ret

bkeycheck:  ;returns: AH = BIOS scan code AL = ASCII character note: enhanced
mov ah,0x11 ;Return: ZF set if no keystroke available, ZF clear if keystroke available
int 0x16    ;only checks buffer without removing key
ret

set320x200x256:
mov ax,$13
int $10
ret

set80x25t:
mov ax,$03
int $10
ret
    

I tried a few random number generators, but I ended up finding one that worked by putting it in a loop (CX=5000 loops), saving & counting the random output, keeping count of how many times it returned 0, then 1, etc
0-255, then alph organize the text file output 0-255
I found that the nicest looking, intelegent, best promoted RANDOM number gen was usually the worst. They would miss numbers (lots of them)
and would have one number get an unusually high number of hits
compaired to other numbers. It's suspose to be an even amount of hits
for each number when the generator is called repeatedly alot.
Any way, since most programs that use a RAND GEN work in a loop,
which calls the generator on consistant intervals, the save/count loop
seemed to act much like a commonly used program.

Well, it's just some thoughts anyway.

Bitdog