use16
  org  256

  mov  al, 13h                  ; ...load al with 13h (mode number)
  int  10h                      ; set mode 13h

  mov  bp, 320                  ; screen is 320 pixels wide
 x:
  les  ax, [bx]                 ; es = end of mem (9fffh), ax = 20cdh
  cwd                           ; => dx = 0 (for idiv)
  mov  ax, di                   ; get dest address
  idiv bp                       ; div by width => ax=y coord, dx=x coord
  imul dx                       ; mul x by y
  stosb                         ; store color in vram
  mov  dx, 3c9h                 ; dac data
  bt   cx, 6                    ; bit 6 of cx => carry flag
  salc                          ; set al from carry flag
  xor  ax, cx                   ; => all this is functionally equivalent to something like
                                ; "test al, 64" / "jz skip" / "not al" / "skip: blah"
                                ; which should be somewhat easier understandable, but bigger.
  out  dx, al                   ; write grayscale pixel values
  out  dx, al
  out  dx, al
  loop x                        ; pixel loop.

  mov ah,01h
  int 16h
  jz  x
  mov ax,03h
  int 10h
  ret
    

                   use16
       org 100h

  start:
         mov al, 0x13
         cmc
         inc dx
         int 0x10
         push word 0xa000
         pop es

    pix:
         mul bx
         inc ax
         add ax, di
         adc [si], bx
         div word [si+12]

    clp:
         fmul dword [si]
         fiadd word [si]
         fistp word [bx]
         sub  ax, 130
         xchg ax, [bx]
         xor  cx, ax
         fild word [bx]
         fmul st0,st0
         xor  bx, bp
         xchg ax, dx
         fxch st1
         jnz  clp

         faddp st1, st0
         fsqrt
         fdivr dword [si]

         fild  word [bx]
         fild  word [bp]
         fpatan

         salc
         xchg ax, cx
         or   al, 0x87
         stosb

         mov ah,01h
         int 16h
         jz  pix

         mov ax,03h
         int 10h
         ret