;*** a64.asm **notice linux_com regard @ as <backspace>**
;*0:1e0: 0-3   4-7                                      *
;*      angle delta                                     *
;   1e8-1ef **
;*0:1f0:                                                *
;*  port address                           0000-1       *
;*  start clock                            0002         *
;*  dome 1/0                               0003         *
;*  filter                                 0004-0007    *
;*  tit job                                0008         *
;*  com1 in                                0009         *
;*  adjust RA                              000a-b       *
;*  where is 6 bytes                       000c-d       *
;*  seg of c31                             000e-f       *
;*  200-26f shou com1 tit job                           *
;   26e-f               count, if !=0 not move done
; space 270-2d0
;   2f0  if whq shou <0a>    2e0  is count 0~255
;   2f1-4  X                 2e2-4 X      2e1 if fa
;   2f5-8  Y                 2e6-8 Y      2e5
;   2f9-d  D                 2ea-d D      2e9
;   2fe-f  W                 2ff   W      2ee
; 2d0  CLSE<0a>OPEN<0a>STOP<0a>
;*  300-318 ra,dec,epoch                                *
;*seg:                                                  *
;*  1/10                                   0004         *
;*  t1t2 begin beijing_time                0006         *
;*  s1s2 begin sidereal_time               000a         *
;*  counter                                000e         *
;*  speed                                  0010         *
;*                                                      *
;*  sec                                    0306         *
;*  minite                                 0308         *
;*  hour                                   030a         *
;*  b1b2 bejing_time                       030e         *
;*  w1w2 sidereal_time                     0312         *
;*  x1x2 time_angle                        0316         *
;
; whq sh:   baud=2400
;   shou in interupt, put buffer, while shou <0a>, put marker 0:2f0
;   in 55ms interupt, if 0:2f0 !=0, deal with buffer,
;                     put data into DISPLAY area.
; whq fa:
;   pc fa:   1500,  D1500
;   in 55ms interupt:
;  1. if [D], fa D1500, ch [D] to [ ], put buffer
;  2. if buffer !=0, count=0; goto end
;     if buffer ==0; count++; if count>255 fa x,y,d,w
;
;  pc ask      pc send      whq answer  pc disp
;    x<0a>     x#ask<0a>     x1230       x123
;    y<0a>     y#ask<0a>     y1230       y123
;    d<0a>     d#ask<0a>     d1234       d1234
;    w<0a>     w#ask<0a>     wopen       x1
;                            wclse       x0
;                            wwork       x2        ; working
;--------------------
;  pc command   pc send
;    X123        X1230
;    Y123        Y1230
;    D1234       D1234
;    W0          WCLSE
;    W1          WOPEN
;    W2          WSTOP                             ; stop in middle
;********************************************************
.286
comstat = 3fdh        ; com1 redhat    sh_fa int
comdata = 3f8h
comint  = 3fah
whqstat = 2fdh        ; com2 whq       sh    int
whqdata = 2f8h
stack   segment para stack 'stack'
stack   ends
code    segment 'code'
        assume cs:code,ds:code
map     dw 0fea5h
        dw 0f000h
count   dw 0
s1      dw 0                            ; 04 today ut=0 sidereal time
s2      dw 0                            ;    x95.for given
t1      dw 0                            ; 08 start beijing time, in 1/10
t2      dw 0                            ;    x95 given
c1      dw 0                            ; 12 time counter
c2      dw 0
speed   dw 58989                        ; 16 58989+delta, x95 given

start:  pushf
        call cs:map                     ; modify ff16 to ff1e by x3
                                        ; following is main body.
        push ds                         ; ds always=1e
        push cs                         ; es always=b800
        pop  ds
        push es
        pusha
        cli
        mov  bp,600                     ; never change, as a divide factor
        mov  bx,3c0ah                   ; bh=60, bl=10
        mov  ax,0b800h
        mov  es,ax                      ; es=b800h
        add  c1,1                       ; counter++       1/18.2s once
        adc  c2,0
        mov  cx,54                      ; 54/58989 =18/19663 =18*80/1573040
        mov  ax,c1                      ; unit 1 = 80/3*1/18.2 = 1.4652 s/day
        mul  cx
        mov  k1,ax                      ; low    wrok_unit
        mov  k2,dx                      ; high   work_unit
        mov  ax,c2
        mul  cx
        mov  dx,k2
        add  dx,ax
        mov  ax,k1
        mov  cx,speed
        div  cx
        push ax
        mov  ax,dx
        mul  bp                         ; unit is 1/10 sec.
        div  cx
        mov  k1,ax
        pop  ax
        mul  bp
        add  ax,k1                      ; counter to all 1/10
        adc  dx,0
        add  ax,t1
        adc  dx,t2                      ; add start0 time
        mov  b1,ax                      ; bejing_time unit
        mov  b2,dx
        div  bp
        mov  k2,ax
        mov  k1,dx
        mov  ax,dx
        div  bl
        mov  cl,ah
        mov  ch,0
        cmp  cx,count                   ; 1/10 not change
        jz   a3
;       cmp  count,99                   ; st 8:00 stop clock for day change
;       jz   a3
        mov  count,cx
        mov  ah,0
        cmp  ax,0                       ; if 0 sec ?
        jnz  a6
;       cmp  k2,1920                    ; if 32:00?
;       jnz  a6
;       mov  count,99                   ; yes, stop clock
        jmp  a6
a3:     jmp  a4
                                        ; display beijing time
a6:     mov  ch,13                      ; color of beijing time
        mov  di,152                     ; first line: seconds
        mov  sec,ax                     ; save second for beeping
        call dis
        mov  ax,k2
        div  bh
        push ax
        mov  ah,0
        mov  hour,ax                    ; save hour
ab1:     cmp  ax,32
         jc   ab2
         sub  ax,24
         jmp  ab1
ab2:    mov  di,140
        call dis                        ; hour
        pop  ax
        mov  al,ah
        mov  ah,0
        mov  min,ax                     ; save minuute for beeping
        mov  di,146
        call dis                        ; minute
        mov  di,144
        mov  cl,':'
        mov  es:[di],cx
        mov  es:[di]+6,cx
        mov  cl,'.'
        mov  es:[di]+12,cx
        mov  ax,count
        add  ax,48
        mov  cl,al
        mov  es:[di]+14,cx

        mov  ax,k2
        sub  ax,480                     ; sub 8 hour
        mul  bp
        add  ax,k1
        adc  dx,0
        mov  k2,dx                      ; s10 as 0:46e
        mov  k1,ax                      ; k2*65536+k1=t8-8 (unit 1/10sec)
                                        ; x=x*366/365 ==> x=x+x/365
        mov  di,365
        div  di
        add  ax,k1
        mov  dx,0
        adc  dx,k2
        add  ax,s1
        adc  dx,s2                      ; add begin_sidereal time
        mov  w1,ax                      ; w1 w2 sidereal time unit
        mov  w2,dx                      ; w1 w2 saved for alpha
        mov  cx,0a3ah                   ; color of sidereal time
        mov  di,304                     ; 160+144
        call disp                       ; display (1) sidereal time
                                        ; beeping
        cmp  count,0
        jnz  a4
        cmp  min,0
        jnz  tt1
        cmp  sec,1
        ja   a4                         ; if sec.gt.1
        jmp  tt4
tt1:    cmp  min,59
        jnz  a4
        cmp  sec,50
        jb   a4                         ; if sec.lt.50
tt4:    shr  sec,1
        jnc  tt2
        mov  ax,h61
        out  61h,al
        jmp  a4
tt2:    mov  ax,0b6h
        out  43h,al
        xor  ax,ax
        out  42h,al
        mov  al,6
        cmp  min,0
        jnz  tt3
        shr  al,1
tt3:    out  42h,al
        in   al,61h
        mov  h61,ax
        or   al,3
        out  61h,al
a4:     mov  ax,1eh
        mov  es,ax
        mov  bx,11h
        mov  ax,es:[bx]
        cmp  ah,0                       ; see input BCD code ?
        jz   a5
        call bcd                        ; bcd routine
a5:                                     ; if fa_buf not empty & 4fb=0;
        mov  ax,0
        mov  ds,ax                ; ds = 0h
        mov  bx,1feh
        mov  ax,ds:[bx]           ; es = c31_seg
        mov  es,ax

        mov  di,4fbh
        mov  al,byte ptr es:[di]
        cmp  al,0
        jnz  a51
                                        ; fa 1 char to alive fa.
        mov  di,4feh
        mov  cx,es:[di]           ; take fa point
        mov  bh,6
a52:    cmp  ch,cl
        jz   a51                  ; if no fa job
        mov  dx,comstat
        in   ax,dx
        and  al,20h               ; if com1 busy
        jz   a51
        inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ax,es:[bx]           ; fa data in al
        mov  dx,comdata
          cmp al,'0'
          jnz a510
          mov al,'='
a510:
        out  dx,al
a51:
        call pcfa_whq
        call c2fa_whq
        call shou_whq
        call disp_whq

        mov  bx,26eh
        mov  ax,ds:[bx]
        cmp  ax,0
        jz   a610
        dec  ax
        mov  ds:[bx],ax
a610:

        sti
        popa
        pop  es
        pop  ds
        iret

;----------------------

bcd:    dec  bx
        mov  dx,es:[bx]                 ; dx= pio_adrc,
         mov  ax,0                      ; get RA, put to i0-3
         out  dx,ax
         dec  dx
         in   ax,dx
         mov  i0,ax
         inc  dx
         mov  ax,10h
         out  dx,ax
         dec  dx
         in   ax,dx
         mov  i1,ax
         inc  dx
         mov  ax,20h
         out  dx,ax
         dec  dx
         in   ax,dx
         mov  i2,ax
         inc  dx
         mov  ax,30h
         out  dx,ax
         dec  dx
         in   ax,dx
         mov  i3,ax
         inc  dx

        mov  bx,4                       ; for(bx=4;bx<8;bx++){
tel:    mov  ax,bx
        shl  al,4
        out  dx,ax                      ; al<<4 --> [pio_c]
        dec  dx
        in   ax,dx                      ; [pio_b] --> ax
        push ax                         ; BCD --> HEX
        shr  al,4
        mov  cl,6                       ; = x - x/16*6
        mul  cl
        pop  cx
        sub  cx,ax
        mov  es:[bx],cl                 ; HEX --> [1e:bx]
        inc  dx
        inc  bx                         ; bx++;
        cmp  bx,8                       ; delta   input
        jnz  tel
a55:
          mov ax,0b800h
          mov es,ax
          mov di,1118+160               ; display false R.A counter
          mov ax,0
          mov k2,ax

          mov cx,i0
          and cl,15
          mov al,cl
          add cl,48
          mov ch,7
          mov es:[di],cx
          mov ah,0
          mov k1,ax
;                          wpos(2,20); printf("%c",i0+48);
; k=i0;
          mov bx,i1
          mov bh,bl
          and bl,15
          mov cl,bl
          add cl,48
          mov es:[di]-2,cx
          mov cl,'.'
          mov es:[di]-4,cx
          shr bh,4
          mov cl,bh
          add cl,48
          mov es:[di]-6,cx
          mov al,bh
          mov ah,0
          mov cl,6
          mul cl
          mov bh,0
          add ax,bx
          mov cl,10
          mul cl
          add ax,k1
          mov k1,ax
; j1=i1&15; j2=i1>>4;
;                          wpos(2,19); printf("%c",j1+48);
;                          wpos(2,17); printf("%c",j2+48);
; k+=(j1+j2*6)*10;
          mov bx,i2
          mov bh,bl
          and bl,15
          mov cl,bl
          add cl,48
          mov es:[di]-8,cx
          mov cl,'.'
          mov es:[di]-10,cx
          shr bh,4
          mov cl,bh
          add cl,48
          mov es:[di]-12,cx
          mov al,bh
          mov ah,0
          mov cl,6
          mul cl
          mov bh,0
          add ax,bx
          mul bp
          add ax,k1
          adc dx,k2
          mov k1,ax
          mov k2,dx
; j1=i2&15; j2=i2>>4;
;                          wpos(2,16); printf("%c",j1+48);
;                          wpos(2,14); printf("%c",j2+48);
; k+=(j1+j2*6)*600;
          mov bx,i3
          mov bh,bl
          and bl,15
          mov cl,bl
          add cl,48
          mov es:[di]-14,cx
          shr bh,4
          and bh,3
          mov cl,bh
          add cl,48
          mov es:[di]-16,cx
          mov al,bh
          mov ah,0
          mov cl,10
          mul cl
          mov bh,0
          add ax,bx
          cmp ax,36
          jb  if36
          mov ax,0
if36:
          mov bx,36000
          mul bx
          add ax,k1
          adc dx,k2
; j1=i3&15; j2=(i3>>4)&3;
;                          wpos(2,13); printf("%c",j1+48);
;                          wpos(2,12); printf("%c",j2+48);
; k+=(j1+j2*10)*36000;
          mov bx,i3
          mov cl,'+'
          and bl,40h
          jz  jjj
          mov cl,'-'
          mov k1,ax
          mov k2,dx
          mov ax,50816
          mov dx,19
          sub ax,k1
          sbb dx,k2
jjj:
          mov es:[di]-18,cx
; m=1; if((i3&0x40)!=0)m=-1;
;                          wpos(2,11); if(m==1)printf("+"); else printf("-");
; if(m==-1)k=(long)864000*1.5-k;
          mov bx,1eh
          mov es,bx
          mov bx,0

          mov cx,es:[bx]+1ah        ; [1fa-1fb]
          cmp cx,32768
          jae jj1
           cmp dx,0
           ja  jj3
           cmp ax,cx
           jae jj3
           add ax,50816
           adc dx,19
jj3:
          sub ax,cx
          sbb dx,0
          jmp jj2
jj1:
          neg cx
          add ax,cx
          adc dx,0
jj2:
;  adjust hour angle,  dxax+[1fa-1fb]
          mov cx,54000
          div cx
          mov es:[bx]+3,al
          mov ax,dx
          mov dx,0
          mov cx,900
          div cx
          mov es:[bx]+2,al
          mov ax,dx
          mov dx,0
          mov cx,15
          div cx
          mov es:[bx]+1,al
          mov ax,dx
          mov cl,10
          mul cl
          mov cl,15
          div cl
          mov es:[bx],al
; wpos(10,0);
; i3=k/54000;    k%=54000;
; i2=k/900;      k%=900;
; i1=k/15;
; i0=k%15;       i0=i0*10/15
; printf("       %02d:%02d:%02d.%d\n",i3,i2,i1,i0);
; pokeb(0,0x1e0,i0);  pokeb(0,0x1e1,i1);
; pokeb(0,0x1e2,i2);  pokeb(0,0x1e3,i3);

        mov  si,3                       ; time_angle   1e:[0-3]
        mov  cx,3c0ah
        mov  ax,es:[si]
        mul  ch
        mov  bx,es:[si-1]
        mov  bh,0
        add  ax,bx
        mul  bp
        mov  k1,ax
        mov  k2,dx
        mov  ax,es:[si-2]
        mul  cl
        mov  bx,es:[si-3]
        and  bx,000fh
        xor  dx,dx
        add  ax,bx
        adc  dx,0
        add  ax,k1
        adc  dx,k2
        mov  x1,ax                      ; x1,x2 time angle unit
        mov  x2,dx                      ; x1,x2 saved for alpha
        mov  bx,0b800h
        mov  es,bx
        mov  bx,3c0ah
        mov  cx,0e3ah                   ; display color of time angle
        mov  di,784                     ; (line:4*160+144)
        call disp                       ; display (4) time angle

                                        ; decl.  & dome display  & filter
        push ds
        mov  si,1eh
        mov  ds,si
;       mov  ch,03                      ; color=3
;       mov  si,9                       ; dome [1e:8-9]
;       mov  di,940                     ; 5*160+140+4
;       mov  ax,[si]
;       call dis
;       add  di,4
;       mov  ax,[si-1]
;       call dis
        mov  si,9
        mov  di,944                     ; 5*160+140+4
        mov  ch,7                       ; color=7
        mov  ax,[si+10]                 ; dome+display
        mov  cl,al
        add  cl,48
        mov  es:[di+06],cx              ;

        mov  ch,13                      ; color=13
        mov  ax,[si+11]
        mov  cl,al
        mov  es:[di+08],cx              ; filter display 1
        mov  cl,ah
        mov  es:[di+10],cx              ; filter display 2
        mov  ax,[si+13]
        mov  cl,al
        mov  es:[di+12],cx              ; filter display 3
        mov  cl,ah
        mov  es:[di+14],cx              ; filter display 4
        mov  ax,[si-2]
        cmp  al,9
        mov  cx,172dh                   ; -
        jnc  d01
        mov  cl,43                      ; +
        cmp  al,1
        jnz  d01
        mov  cl,49
d01:    mov  di,620                     ; display (3)
        mov  es:[di],cx                 ; 3 possible: + - 1
        mov  ax,[si-3]
        add  di,2
        call dis
   ;     mov  cl,248                     ; degree
        mov  cl,39                      ; degree
        mov  es:[di+4],cx
        mov  ax,[si-4]
        add  di,6
        call dis
        mov  cl,39
        mov  es:[di+4],cx
        mov  ax,[si-5]
        add  di,6
        call dis
        mov  cl,34
        mov  es:[di+4],cx
        pop  ds                         ; display (3) delta
                                        ; decl end
        mov  ax,w1
        mov  dx,w2
        add  ax,12032                   ; 13*65536+12032=864000 =24 hours
        adc  dx,13                      ; +864000  0.1s/unit
        sub  ax,x1                      ; alpha=time_angle-S0
        sbb  dx,x2
        cmp  dx,40
        jnc  a22
        mov  cx,173ah
        mov  di,464                     ; display (2) alpha
        call disp
a22:    ret                             ; bcd end
;------------------
dis:    mov  ah,0
        div  bl
        add  al,48
        mov  cl,al
        mov  es:[di],cx
        add  ah,48
        mov  cl,ah
        mov  es:[di]+2,cx
        ret
                                 ; prg 0-4??, enternce 0014
                                 ; SMT:                WHQ:
                                 ; if fa buf 4fb
                                 ; pointer 4fc-4ff     pointer 4ec-4ef
                                 ; shou data 500-5ff   shou data 700-7ff
                                 ; fa   data 600-6ff   fa   data 800-8ff
                                 ; prg  a00            prg  900
        org  900h                ; shou_whq_intrupt
whq2:
        push ds
        push es
        pusha
        cli

        mov  ax,0                 ; shou
        mov  ds,ax
        mov  bx,1feh
        mov  ax,ds:[bx]           ; take c31:seg
        mov  es,ax
        mov  dx,whqdata
        in   ax,dx

        mov  di,4ech
        mov  cx,es:[di]           ; take shou point
        mov  bh,7
        inc  cl
        mov  bl,cl
        mov  byte ptr es:[bx],al
        mov  es:[di],cx

        cmp  al,13                ;
        ja   whq29
                                  ; if rec 10 13 , put [2f0]!=0;
        mov  bx,2f0h
        mov  byte ptr ds:[bx],al

whq29:
        mov  al,20h                ; release intrupt
        out  20h,al

        sti
        popa
        pop  es
        pop  ds
        iret
;-----------------------------------------
screen:
        inc  bl
        mov  bh,6
        mov  byte ptr es:[bx],al   ; 1st  '`'
 ; b800:460
        mov  ax,0b800h
        mov  ds,ax
        mov  si,140
        mov  cx,160
        call com22
        mov  si,300
        mov  cx,320
        call com22
        mov  si,460
        mov  cx,480                ; move ra,dec,filter
        call com22
        mov  si,620
        mov  cx,640
        call com22
        mov  si,780
        mov  cx,800
        call com22
        mov  si,940
        mov  cx,960
        call com22
        mov  si,1100             ;   x_y      61-->68     unix_n3 need change
        mov  cx,1114             ;   take 7 byte only
        call com22               ;

        mov  al,0ah                ; last \0a
        inc  bl
        mov  byte ptr es:[bx],al

        mov  byte ptr es:[di],bl   ; save point
        ret
com22:
        mov  ax, ds:[si]
        inc  bl                 ; 256 buffer, neednot &0xff
         cmp al,126
         jg  ssss
         cmp al,'@'
         jz  ssss
         cmp al,32
         jg  com23
ssss:
         mov al,'_'
com23:
        mov  byte ptr es:[bx],al
        inc  si
        inc  si
        cmp  cx,si
        jnz  com22
        ret
;---------
disp:   mov  es:[di],cx
        mov  es:[di]+6,cx
        mov  cl,'.'
        mov  es:[di]+12,cx
        div  bp
a21:    cmp  ax,1440
        jc   a2
        sub  ax,1440
        jmp  a21
a2:     push ax
        mov  ax,dx
        div  bl
        push ax
        add  di,8
        call dis                        ; sec
        pop  ax
        add  ah,48
        mov  cl,ah
        add  di,6
        mov  es:[di],cx                 ; 1/10 sec
        pop  ax
        div  bh
        push ax
        sub  di,18
        call dis                        ; hour
        pop  ax
        mov  al,ah
        add  di,6
        call dis                        ; minute
        ret

;------------------------------------------
        org  0a00h
com1:
        push ds
        push es
        pusha
        cli

        mov  ax,0
        mov  ds,ax
        mov  bx,1feh
        mov  ax,ds:[bx]           ; take c31:seg
        mov  es,ax
        mov  di,4feh              ; take out fa+point
        mov  bx,es:[di]

        mov  dx,comint           ; inquire shou or fa
        in   ax,dx
        and  al,6
        cmp  al,4
        jnz  com30

        mov  dx,comdata
        in   ax,dx

         mov si,26eh          ; 41215
         cmp al,'$'
         jnz com11
         mov ax,2048
com13:
         mov ds:[si],ax
         jmp com29
com11:
         cmp al,'&'
         jnz com12
         mov ax,0
         jmp com13
com12:
        cmp  al,'`'
        jnz  com21

        cmp  bh,bl
        jnz  com29                ; if fa_buf not empty, ignore `
        call screen
        jmp  com29
;--------
com30:
        cmp  al,2
        jnz  com29
                                  ; fa com1
; bl,bh =fa point
        mov  cx,bx
        cmp  ch,cl
        jz   com32
        inc  ch
        mov  bh,6
        mov  bl,ch
        mov  ax,es:[bx]           ; fa data in al
        mov  dx,comdata
          cmp al,'0'
          jnz a511
          mov al,'='
a511:
        out  dx,al
        mov  es:[di],cx
com32:
        mov  al,0
        cmp  ch,cl
        jz   com31
        inc  al
com31:
        mov  di,4fbh
        mov  byte ptr es:[di],al  ; marked fa buffer, if empty
        jmp  com29                ; fa end
;------------
com21:
        mov  di,4fch
        mov  cx,es:[di]           ; take shou point
        mov  bh,5
        inc  cl
        mov  bl,cl
        mov  byte ptr es:[bx],al
        mov  es:[di],cx

        cmp  al,10
        jnz  com29
                                  ; if rec 10(\0a), put [1f9]=1;
        mov  ax,1fh
        mov  es,ax
        mov  bx,9
        mov  byte ptr es:[bx],bl

com29:
        mov  al,20h                ; release intrupt
        out  20h,al

        sti
        popa
        pop  es
        pop  ds
        iret
;-------------------------------
shou_whq:
        mov  bx,2f0h
        mov  al,byte ptr ds:[bx]    ; if [2f0]!=0
        cmp  al,0
        jnz  n01
        ret
n01:    mov  al,0
        mov  byte ptr ds:[bx],al
        mov  di,4ech
        mov  cx,es:[di]           ; take shou point
        mov  bh,7
a70:    cmp  cl,ch
        jnz  n02
        ret
n02:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        cmp  al,'w'
        jz   wcase
        cmp  al,'x'
        jz   xcase
        cmp  al,'y'
        jz   ycase
        cmp  al,'d'
        jnz  a70
        jmp  dcase
wcase:  mov  dx,2ffh
        cmp  cl,ch
        jnz  n03
        ret
n03:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        mov  si,dx
        mov  ah,'0'
        cmp  al,'c'
        jz   n033
        mov  ah,'1'
        cmp  al,'o'
        jz   n033
        mov  ah,'2'
        cmp  al,'w'
        jz   n033
        jmp  a70
n033:   mov  byte ptr ds:[si],ah      ; [2fe]=w?
        jmp  a70
xcase:  mov  dx,2f2h
        cmp  cl,ch
        jnz  n08
        ret
n08:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        cmp  cl,ch
        jnz  n09
        ret
n09:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ah,byte ptr es:[bx]
        mov  si,dx
        mov  ds:[si],ax
        cmp  cl,ch
        jnz  n0a
        ret
n0a:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        add  si,2
        mov  byte ptr ds:[si],al
        jmp  a70
ycase:  mov  dx,2f6h
        cmp  cl,ch
        jnz  n0b
        ret
n0b:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        cmp  cl,ch
        jnz  n0c
        ret
n0c:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ah,byte ptr es:[bx]
        mov  si,dx
        mov  ds:[si],ax
        cmp  cl,ch
        jnz  n0d
        ret
n0d:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        add  si,2
        mov  byte ptr ds:[si],al
        jmp  a70
dcase:  mov  dx,2fah
        cmp  cl,ch
        jnz  n04
        ret
n04:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        cmp  cl,ch
        jnz  n05
        ret
n05:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ah,byte ptr es:[bx]
        mov  si,dx
        mov  ds:[si],ax
        cmp  cl,ch
        jnz  n06
        ret
n06:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  al,byte ptr es:[bx]
        cmp  cl,ch
        jnz  n07
        ret
n07:    inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ah,byte ptr es:[bx]
        add  si,2
        mov  ds:[si],ax
        jmp  a70
        ret
;--------------
disp_whq:
  ;     mov  ds,0
        mov  ax,0b800h
        mov  es,ax
        mov  di,1100
        mov  ch,13
        mov  si,2f2h
        call disxyd                     ; x
        mov  ch,12
        call disxyd                     ; y
        mov  ch,3                       ; dome
        sub  di,176
        call disxyd
        mov  cl,byte ptr ds:[si-1]
        mov  es:[di-2],cx
        mov  ch,15
        mov  cl,byte ptr ds:[si+1]      ; win
        mov  es:[di],cx
        ret
disxyd:
        mov  cl,byte ptr ds:[si]        ; x
        mov  es:[di],cx
        mov  cl,byte ptr ds:[si+1]
        mov  es:[di+2],cx
        mov  cl,byte ptr ds:[si+2]
        mov  es:[di+4],cx
        add  di,8
        add  si,4
        ret
;----------------------------------
pcfa_whq:
        mov  bh,8
        mov  cx,0a00h
        mov  di,4eeh
        mov  bl,byte ptr es:[di]

        mov  si,2e1h                    ; x_fa
        mov  al,byte ptr ds:[si]
        cmp  al,0
        jz   a64
        call fa13
          mov  al,'0'                   ; 40922 X123 ==> X1230
          mov  byte ptr es:[bx],al
          inc  bl
        mov  byte ptr es:[bx],ch         ; last <0a>
a64:
        mov  si,2e5h                    ; y_fa
        mov  al,byte ptr ds:[si]
        cmp  al,0
        jz   a65
        call fa13
          mov  al,'0'
          mov  byte ptr es:[bx],al      ; 40922  Y123 ==> Y1230
          inc  bl
        mov  byte ptr es:[bx],ch         ; last <0a>
a65:
        mov  si,2e9h                    ; d_fa
        mov  al,byte ptr ds:[si]
        cmp  al,0
        jz   a66
        call fa13
        mov  al,byte ptr ds:[si+4]
        mov  byte ptr es:[bx],al
        inc  bl
        mov  byte ptr es:[bx],ch         ; last <0a>
a66:
        mov  si,2eeh                    ; d_fa
        mov  al,byte ptr ds:[si]
        cmp  al,0
        jz   a67
        mov  byte ptr ds:[si],cl         ; clear pcfa
        inc  bl
        mov  byte ptr es:[bx],al         ; fa 'W'
        mov  al,byte ptr ds:[si+1]       ; take 0 1 2
        sub  al,'0'
        mov  cl,5
        mul  cl
        mov  si,2d0h-1
        add  si,ax
        call fa14                        ; OPN
        add  si,2
        call fa15                        ; N<0a>
        dec  bl
a67:
        mov  byte ptr es:[di],bl         ; pointer ++
        ret
fa13:
        mov  byte ptr ds:[si],cl         ; clear pcfa
        inc  bl
        mov  byte ptr es:[bx],al
fa14:   inc  bl
        mov  al,byte ptr ds:[si+1]
        mov  byte ptr es:[bx],al
        inc  bl
fa15:   mov  al,byte ptr ds:[si+2]
        mov  byte ptr es:[bx],al
        inc  bl
        mov  al,byte ptr ds:[si+3]
        mov  byte ptr es:[bx],al
        inc  bl
        ret
;---------
c2fa_whq:
        mov  si,2e0h
;       mov  di,4eeh              ; pointer
        mov  cx,es:[di]           ; take fa point
        mov  bh,8                 ; buf hi
        cmp  ch,cl
        jz   a62                  ; if no fa job
        mov  dx,whqstat
        in   ax,dx
        and  al,20h               ; if whq  busy
        jz   a61
        inc  ch
        mov  es:[di],cx
        mov  bl,ch
        mov  ax,es:[bx]           ; fa data in al
        mov  dx,whqdata
        out  dx,al
        mov  al,0
        mov  byte ptr ds:[si],al
a61:    ret
a62:    mov  al,byte ptr ds:[si]
        inc  al
        mov  byte ptr ds:[si],al
        cmp  al,255               ; 14 secend ask com2 once
        jz   a63
        ret
a63:    mov  bh,8
        mov  cx,2361h                ; #a
        mov  dx,'sk'
        mov  ah,10
;       mov  di,4eeh
        mov  bl,byte ptr es:[di]
        mov  al,'x'
        call fask
        mov  al,'y'
        call fask
        mov  al,'d'
        call fask
        mov  al,'w'
        call fask
        mov  byte ptr es:[di],bl
        ret

fask:
        inc  bl
        mov  byte ptr es:[bx],al
        inc  bl
        mov  byte ptr es:[bx],ch
        inc  bl
        mov  byte ptr es:[bx],cl
        inc  bl
        mov  byte ptr es:[bx],dh
        inc  bl
        mov  byte ptr es:[bx],dl
        inc  bl
        mov  byte ptr es:[bx],ah
        ret
;--------------

dummy   db   0              ; D00
k1      dw   0
k2      dw   0
sec     dw   0
min     dw   0
hour    dw   0
h61     dw   0
b1      dw   0
b2      dw   0
w1      dw   0
w2      dw   0
x1      dw   0
x2      dw   0
i0      dw   0
i1      dw   0
i2      dw   0
i3      dw   0
code    ends
        end     start