;		Graph_lib
;
;		call from High C
;
;		1990 4  Hiroshi TODA
;

	.386p

work1	struc		; get17 & put17 WORK
;data area
addre1	dd	?		; data address
seg11	dd	?		; DS segment
x11	dd	?		; point1
y11	dd	?		;
x12	dd	?		; point2
y12	dd	?		;
mode1	dd	?		; put mode( 0:normal 1:ovlay 2:chrma )
color1	dd	?		; ovlay & chrma color data
mix1	dd	?		; mix rate
;work area
seg12	dd	?		; segment store
x1	dd	?		; xpoint
y1	dd	?		; ypoint
xd1	dd	?		; xd
yd1	dd	?		; yd
buf1	dd	?		; buffer
buf12	dd	?
buf13	dd	?
buf14	dd	?
buf15	dd	?
work1	ends

work2	struc		; geta17 & puta17 mask17 WORK
;data area
addre2	dd	?		; data address
seg21	dd	?		; DS segment
mode2	dd	?		; mode
para21	dd	?		; ymin
para22	dd	?		; ymax
para23	dd	?		; mask-add
para24	dd	?		; color
;work area
seg22	dd	?		; segment store
work2	ends

work3	struc		; pline WORK
;data area
gadd	dd	?		; data address
padd	dd	? 		; point data address
seg31	dd	?		; DS segment
mode3	dd	?		; bit0:display xor line  bit1:data or line
pnum	dd	?		; start point number
pcount	dd	?		; total point
;work area
seg32	dd	?		; segment store
coradd	dd	?		; padd+pnum*8
ncount	dd	?		; =pcount
x31	dd	?
y31	dd	?
x32	dd	?
y32	dd	?
xd3	dd	?
yd3	dd	?
xadd	dd	?
yadd	dd	?
count	dd	?
xp31	dd	?	; put cor.*10000H
yp31	dd	?
xp32	dd	?	; put cor.*1
yp32	dd	?
work3	ends

work4	struc		; files WORK
;data area
path	dd	?	; path name address
output	dd	?	; file name output address
dta	dd	?	; DTA trans address
attr	dd	?	; attr
fmode	dd	?	; 0:first 1:next 2:end
;work area
pathbuf	dd	?	; path 転送
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
	dd	?
fbuf	dd	?
work4	ends

work5	struc		; key console BIOS WORK
x51	dd	?
x52	dd	?
x53	dd	?
x54	dd	?
work5	ends

        cseg	segment	'CODE'
	assume	cs:cseg,ds:cseg

;get17(work,para) para = buf-address,DS,x1,y1,x2,y2

	public	get17
	db	'get17',5
get17	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area top add
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- work area top add
	mov	edi,[ebp+12]		; edi <-- para. add.
	xor	ecx,ecx			; ecx=count
get01:	mov	eax,[edi][ecx*4]	; para. --> work area
	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,6
	jb	get01
	mov	eax,[esi].x11		; x1
	cmp	eax,[esi].x12
	jle	get02			; x11<x12 check
	mov	ebx,[esi].x12
	mov	[esi].x11,ebx
	mov	[esi].x12,eax
	mov	eax,ebx
get02:	mov	[esi].x1,eax
	mov	eax,[esi].x12		; xd1
	sub	eax,[esi].x11
	add	eax,1
	mov	[esi].xd1,eax
	mov	eax,[esi].y11		; y1
	cmp	eax,[esi].y12
	jle	get03			; y11<y12 check
	mov	ebx,[esi].y12
	mov	[esi].y11,ebx
	mov	[esi].y12,eax
	mov	eax,ebx
get03:	mov	[esi].y1,eax
	mov	eax,[esi].y12		; yd1
	sub	eax,[esi].y11
	add	eax,1
	mov	[esi].yd1,eax
	xor	ecx,ecx			; y count
	mov	ebx,[esi].addre1	; ebx <--data address
	xor	eax,eax			; FS store
	mov	ax,fs
	mov	[esi].seg12,eax
	mov	eax,[esi].seg11
	mov	fs,ax
get04:	mov	edi,[esi].y1		; top address cal.
	imul	edi,1024
	mov	edx,[esi].x11		; x count
get05:	cmp	edx,512			; x check = 512
	jae	get06
	cmp	[esi].y1,512/2		; y check = 512 *** 1991 2 割る2 ***
	jae	get06
	mov	ax,fs:[edi][edx*2]	; v-ram data 
	mov	[ebx],ax		; trans
get06:	add	ebx,2
	inc	edx
	cmp	edx,[esi].x12
	jle	get05
	inc	dword ptr [esi].y1
	inc	ecx
	cmp	ecx,[esi].yd1
	jb	get04
	mov	eax,[esi].seg12
	mov	fs,ax
	xor	eax,eax
getE:	je	getE2
	mov	eax,-1
getE2:	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret
get17	endp

;put17(work,para) para = buf-address,DS,x1,y1,x2,y2,mode,color
;	put mode 0:change 1:ovlay change 2:chrma change
;		 3:転送元polygon put 4:転送先polygon put 5:put
;		 6:polygon data buffer -> VRAM trans
;		 7:VRAM polygon data clear

	public	put17
	db	'put17',5
put17	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area top add
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- work area top add
	mov	edi,[ebp+12]		; edi <-- para. add.
	xor	ecx,ecx			; ecx=count
put01:	mov	eax,[edi][ecx*4]	; para. --> work area
	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,9
	jb	put01
	and	[esi].color1,7FFFh	; color data & 7fff
	mov	eax,256			; buf15 = 256 - mix1
	sub	eax,[esi].mix1
	mov	[esi].buf15,eax
	mov	eax,[esi].x11		; x1
	mov	[esi].x1,eax
	mov	eax,[esi].x12		; xd1
	sub	eax,[esi].x11
	add	eax,1
	mov	[esi].xd1,eax
	mov	eax,[esi].y11		; y1
	mov	[esi].y1,eax
	mov	eax,[esi].y12		; yd1
	sub	eax,[esi].y11
	add	eax,1
	mov	[esi].yd1,eax
	xor	ecx,ecx			; y count
	mov	ebx,[esi].addre1	; ebx <--data address
	xor	eax,eax			; FS store
	mov	ax,fs
	mov	[esi].seg12,eax
	mov	eax,[esi].seg11
	mov	fs,ax

	cmp	[esi].mode1,5		; special for mode5
	jne	put04
	cmp	[esi].mix1,256
	je	put50			; goto mode5

put04:	mov	edi,[esi].y1		; top address cal.
	imul	edi,1024
	mov	edx,[esi].x11		; x count
put05:	cmp	edx,512			; x check
	jae	put0E
	cmp	[esi].y1,512/2		; *** 1991 2 割る2 ***
	jae	put0E
	mov	ax,fs:[edi][edx*2]	; v-ram data -> buf
	mov	[esi].buf1,eax
	mov	eax,[esi].mode1
	cmp	eax,0			; change
	jne	put0A
	jmp	putXE
put0A:	cmp	eax,1			; オーバレイ
	jne	put0B
	mov	ax,[ebx]
	and	eax,7fffH
	cmp	eax,[esi].color1
	je	put06
	jmp	putXE
put0B:	cmp	eax,2			; クロマキー
	jne	put0C
	mov	ax,fs:[edi][edx*2]
	and	eax,7fffH
	cmp	eax,[esi].color1
	jne	put06
	jmp	putXE
put0C:	cmp	eax,5			; normal trans
	jne	put0D
	jmp	putXE
put0D:	cmp	eax,4			; 転送先のポリゴンデータ対応
	jne	put0F
	mov	eax,[esi].addre1
	add	eax,edi
	mov	ax,[eax][edx*2]
	cmp	ax,8000h
	jb	put06
	jmp	putXE
put0F:	cmp	eax,3			; 転送元ポリゴンデータ対応
	jne	put06
	mov	ax,[ebx]
	cmp	ax,7FFFh
	ja	putXE
	jmp	put06
putXE:	cmp	[esi].mix1,256
	jb	putXF
	mov	ax,[ebx]		; not mix
	and	ax,07FFFh
	mov	fs:[edi][edx*2],ax
	jmp	put06
putXF:	mov	ax,[ebx]		; B	RAM DATA
	and	eax,1Fh
	imul	eax,[esi].mix1
	mov	[esi].buf12,eax
	mov	ax,[ebx]		; R
	and	eax,1Fh*32
	imul	eax,[esi].mix1
	mov	[esi].buf13,eax
	mov	ax,[ebx]		; G
	and	eax,1Fh*1024
	imul	eax,[esi].mix1
	mov	[esi].buf14,eax
	mov	ax,fs:[edi][edx*2]	; B	VRAM DATA
	and	eax,1Fh
	imul	eax,[esi].buf15
	add	eax,[esi].buf12
	add	eax,80h			; 四捨五入
	shr	eax,8
	mov	[esi].buf12,eax
	mov	ax,fs:[edi][edx*2]	; R
	and	eax,1Fh*32
	imul	eax,[esi].buf15
	add	eax,[esi].buf13
	shr	eax,8
	add	eax,10h			; 四捨五入
	and	eax,1Fh*32		; clear
	mov	[esi].buf13,eax
	mov	ax,fs:[edi][edx*2]	; G
	and	eax,1Fh*1024
	imul	eax,[esi].buf15
	add	eax,[esi].buf14
	shr	eax,8
	add	eax,10h*32		; 四捨五入
	and	eax,1Fh*1024		; clear
	add	eax,[esi].buf12
	add	eax,[esi].buf13
	mov	fs:[edi][edx*2],ax
put06:	cmp	[esi].mode1,4
	jb	putXG
	ja	putXH
	mov	eax,[esi].buf1
	and	ax,08000h
	or	fs:[edi][edx*2],ax
	jmp	put0E
putXG:	mov	eax,[esi].buf1		; V-RAM polygon data back
	and	ax,08000h
	or	fs:[edi][edx*2],ax
	mov	eax,[esi].buf1		; mode<3 -> change
	and	ax,07FFFh
	mov	[ebx],ax
	jmp	put0E
putXH:	mov	ax,[ebx]
	and	ax,8000h
	or	fs:[edi][edx*2],ax
put0E:	add	ebx,2
	inc	edx
	cmp	edx,[esi].x12
	jle	put05
	inc	dword ptr [esi].y1
	inc	ecx
	cmp	ecx,[esi].yd1
	jb	put04
	mov	eax,[esi].seg12
	mov	fs,ax
	xor	eax,eax
	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret

	; special speed for mode=5

put50:	mov	edi,[esi].y1		; top address cal.
	shl	edi,10                  ; *1024
	mov	edx,[esi].x11		; x count
put51:	cmp	edx,512			; x check
	jae	put52
	cmp	[esi].y1,512/2		; *** 1991 2 割る2 ***
	jae	put52
	mov	ax,[ebx]		; not mix
	mov	fs:[edi][edx*2],ax
put52:	add	ebx,2
	inc	edx
	cmp	edx,[esi].x12
	jle	put51
	inc	dword ptr [esi].y1
	inc	ecx
	cmp	ecx,[esi].yd1
	jb	put50
	mov	eax,[esi].seg12
	mov	fs,ax
	xor	eax,eax
	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret

put17	endp

;geta17(work,para) para = buf-address,DS/bufferのPolygonData保存に改良 91 2/28

	public	geta17
	db	'geta17',6
geta17	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area top add
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- work area top add
	mov	edi,[ebp+12]		; edi <-- para. add.
	xor	ecx,ecx			; ecx=count
geta01:	mov	eax,[edi][ecx*4]	; para. --> work area
	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,2
	jb	geta01
	mov	eax,[esi].seg21
	mov	fs,ax			; fs <- vram seg( seg21 )
	mov	edi,[esi].addre2	; es:[edi] = buffer
	xor	esi,esi			; fs:[esi] = vram
	mov	ecx,512*512/2/2		; count set *** 1991 2 割る2 ***
	cld
geta0A:	lods	dword ptr fs:[esi]
	and	eax,7FFF7FFFh
	and	dword ptr [edi],80008000h
	or	[edi],eax
	add	edi,4
	loop	geta0A			;rep	movs dword ptr [edi],fs:[esi]
	xor	eax,eax
getaE:	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret
geta17	endp

;puta17(work,para) para = buf-address,DS,mode(0,3,4,5,6,7,8,9,10,11)
;mode 0:	VRAM <-> BUFFER change ( vram-poly:clear buffer-poly:保存 )
;mode 3,4:	VRAM <-  BUFFER polygon put ( polygon data に 従ってput )
;mode 5:	VRAM <-  BUFFER put ( 単純, clear 等で使用 )
;mode 6:	VRAM <-  BUFFER polygon data を VRAM に転送
;mode 7,9:	VRAM clear	vram polygon data を clear
;mode 8:	VRAM  -> BUFFER get ( polygon data を clear )
;mode 10:	VRAMpolygon反転	(xor)
;mode 11:	VRAM <-> BUFFER change ( 単純 )
;mode 12:	VRAM <-  BUFFER buffer-poly 保存

	public	puta17
	db	'puta17',6
puta17	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area top add
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- work area top add
	mov	edi,[ebp+12]		; edi <-- para. add.
	xor	ecx,ecx			; ecx=count
puta01:	mov	eax,[edi][ecx*4]	; para. --> work area
	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,3
	jb	puta01
	xor	ecx,ecx			; count = 0		基本セット
	mov	ebx,[esi].addre2	; ebx <--buffer address
	mov	eax,[esi].seg21		; fs = vram seg.
	mov	fs,ax
	mov	eax,[esi].mode2		; mode check
	cmp	eax,0
	je	puta02
	cmp	eax,3
	je	puta04
	cmp	eax,4
	je	puta04
	cmp	eax,5
	je	puta03
	cmp	eax,6
	je	puta06
	cmp	eax,7
	je	puta09
	cmp	eax,8
	je	puta08
	cmp	eax,9
	je	puta09
	cmp	eax,10
	je	puta10
	cmp	eax,11
	je	puta11
	cmp	eax,12
	je	puta12
	jmp	putaend
puta02:	mov	ax,fs		;mode0	change buffer-poly保存 vram-polyCLEAR
	mov	es,ax		; ds = no move, fs = 0x10c
	xor	edi,edi		; VRAM
	mov	esi,ebx		; buffer
	mov	ecx,512*512/2/2	; *** 1991 2 割る2 ***
puta2A:	mov	ebx,7FFF7FFFh	; edx <- vram
	and	ebx,es:[edi]
	lodsd
	mov	edx,80008000h
	and	edx,eax
	or	ebx,edx
	xor	eax,edx		; eax <- buffer
	stosd
	mov	[esi-4],ebx
	loop	puta2A
	mov	ax,ds
	mov	es,ax
	jmp	putaend
puta03:	mov	ax,fs		;mode5	 vram <- buffer
	mov	es,ax
	mov	esi,ebx		; buffer
	xor	edi,edi		; vram
	mov	ecx,512*512/2/2	; 512*512/2 *** 1991 2 割る2 ***
	cld
	rep	movsd	
	mov	ax,ds
	mov	es,ax
	jmp	putaend
puta04:	mov	ax,[ebx][ecx*2]	;mode3,4 polygon put
	cmp	ax,8000h
	jb	puta05
	and	ax,7fffh
	mov	fs:[ecx*2],ax
puta05:	inc	ecx
	cmp	ecx,512*512/2	; 512*512 *** 1991 2 割る2 ***
	jb	puta04
	jmp	putaend
puta06:	mov	eax,[ebx][ecx*4] ;mode6	polygon data put
	and	eax,80008000h
	or	fs:[ecx*4],eax
	inc	ecx
	cmp	ecx,512*512/2/2	; 512*512/2 *** 1991 2 割る2 ***
	jb	puta06
	jmp	putaend
puta08:	mov	eax,fs:[ecx*4]	;mode8	polygon clear & get
	and	eax,7FFF7FFFh
	mov	fs:[ecx*4],eax
	mov	[ebx][ecx*4],eax
	inc	ecx
	cmp	ecx,512*512/2/2	; 512*512/2 *** 1991 2 割る2 ***
	jb	puta08
	jmp	putaend
puta09:	mov	ax,fs		;mode7,9  vram poly clear
	mov	es,ax		; fs = ds, ds = 0x10c, es = 0x10c
	xor	edi,edi		; 分かりにくいが速度を稼ぐためSTRING関数使用
	xor	esi,esi
	mov	ebx,7FFF7FFFh
	mov	ecx,512*512/2/2	; *** 1991 2 割る2 ***
puta9A:	lods	dword ptr fs:[esi]
	and	eax,ebx
	stosd
	loop	puta9A
	mov	ax,ds
	mov	es,ax
	jmp	putaend
puta10:	xor	dword ptr [ebx][ecx*4],80008000h
	inc	ecx
	cmp	ecx,512*512/2/2	; 512*512/2 *** 1991 2 割る2 ***
	jb	puta10
	jmp	putaend
puta11:	mov	ax,fs			; normal change ( 1990 12 に新設 )
	mov	es,ax		; ds = no move, es = 0x10c
	xor	edi,edi		; VRAM
	mov	esi,ebx		; buffer
	mov	ecx,512*512/2/2	; *** 1991 2 割る2 ***
puta1A:	mov	eax,es:[edi]
	movsd
	mov	[esi-4],eax
	loop	puta1A
	mov	ax,ds
	mov	es,ax
	jmp	putaend
puta12:	mov	ax,fs
	mov	es,ax			; es <- vram seg( seg21 )
	mov	esi,ebx			; ds:[esi] = buffer
	xor	edi,edi			; es:[edi] = vram
	mov	ecx,512*512/2/2		; count set *** 1991 2 割る2 ***
	cld
puta1B:	lodsd
	and	eax,7FFF7FFFh
	stosd
	loop	puta1B
	mov	ax,ds			; esをdsの値に戻す
	mov	es,ax
	jmp	putaend
putaend:	xor	eax,eax
putaE:	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret
puta17	endp

;poly1(bbuf) polygon data clear

	public	poly1
	db	'poly1',5
poly1	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area +8
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- bbuf area top add
	xor	ecx,ecx
poly11:	and	dword ptr [esi][ecx*4],7fff7fffH
	inc	ecx
	cmp	ecx,512*512/2/2		; 512*512/2 *** 1991 2 割る2 ***
	jb	poly11
	xor	eax,eax
	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret
poly1	endp


;poly2(bbuf,startoffset(y座標),endoffset(y座標)) polygon data set

	public	poly2
	db	'poly2',5
poly2	proc	near
	push	ebp
	mov	ebp,esp			; ebp <-- param area +8
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- bbuf area top add
	mov	ecx,[ebp+12]		; ecx <-- start offset
	shl	ecx,8		; *256
	mov	ebx,[ebp+16]		; ebx <-- end offset
	shl	ebx,8		; *256
	add	ebx,256		; 1line add
	xor	edx,edx			; flag
poly21:	mov	eax,[esi][ecx*4]	; number cal.
	test	eax,00008000H
	je	poly22
	xor	edx,00000001H		; flag
poly22:	and	edx,00000001H
	je	poly23
	or	eax,00008000H
poly23:	test	eax,80000000H
	je	poly24
	xor	edx,00000001H
poly24:	and	edx,00000001H
	je	poly25
	or	eax,80000000H
poly25:	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,ebx
	jb	poly21
	xor	eax,eax
	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret
poly2	endp

;pline(work,para) para = gadd,padd,DS,mode,pnum,pcount

	public	pline
	db	'pline',5
pline	proc	near

xmax	equ	512			; cor. max
ymax	equ	512

	push	ebp
	mov	ebp,esp			; ebp <-- param area +8
	push	esi
	push	edi
	push	ebx
	mov	esi,[ebp+8]		; esi <-- work area top add
	mov	edi,[ebp+12]		; edi <-- para. add.
	xor	ecx,ecx			; ecx=count
plin00:	mov	eax,[edi][ecx*4]	; para. --> work area
	mov	[esi][ecx*4],eax
	inc	ecx
	cmp	ecx,6
	jb	plin00
	mov	eax,[esi].pnum
	shl	eax,2
	add	eax,[esi].padd
	mov	[esi].coradd,eax	; cor. top address
	mov	eax,[esi].pcount
	mov	[esi].ncount,eax	; cor. counter
	test	eax,eax
	je	plin13
	xor	eax,eax			; fs store
	mov	ax,fs
	mov	[esi].seg32,eax
	mov	eax,[esi].seg31		; fs : v-ram segment
	mov	fs,ax
plin01:	mov	ecx,[esi].coradd	; cor. set
	mov	eax,[ecx]
	and	eax,0ffffH
	mov	[esi].x31,eax
	mov	eax,[ecx]
	shr	eax,16
	mov	[esi].y31,eax
	mov	eax,[ecx+4]
	and	eax,0ffffH
	mov	[esi].x32,eax
	mov	eax,[ecx+4]
	shr	eax,16
	mov	[esi].y32,eax
	add	dword ptr [esi].coradd,4
	mov	eax,[esi].x31		; all 0 ck.
	cmp	eax,[esi].x32
	jne	plin02
	mov	eax,[esi].y31
	cmp	eax,[esi].y32
	jne	plin02
	jmp	plin12
plin02:	mov	eax,[esi].x32		; xd3,yd3 cal.
	sub	eax,[esi].x31
	mov	ecx,eax
	jae	plin03
	neg	ecx
plin03:	mov	[esi].xd3,eax
	mov	eax,[esi].y32
	sub	eax,[esi].y31
	mov	edx,eax
	jae	plin04
	neg	edx
plin04:	mov	[esi].yd3,eax
	cmp	ecx,edx
	jb	plin07
plin05:	mov	[esi].count,ecx		; abs(xd3)>=abs(yd3)
	mov	eax,10000H
	xor	ecx,ecx
	add	ecx,[esi].xd3
	jns	plin06
	mov	eax,-10000H
plin06:	mov	[esi].xadd,eax
	imul	dword ptr [esi].yd3
	idiv	ecx
	mov	[esi].yadd,eax
	jmp	plin09
plin07:	mov	[esi].count,edx		; abs(xd3)<abs(yd3)
	mov	eax,10000H
	xor	ecx,ecx
	add	ecx,[esi].yd3
	jns	plin08
	mov	eax,-10000H
plin08:	mov	[esi].yadd,eax
	imul	dword ptr [esi].xd3
	idiv	ecx
	mov	[esi].xadd,eax
plin09:	mov	eax,[esi].x31
	shl	eax,16
	mov	[esi].xp31,eax
	mov	eax,[esi].y31
	shl	eax,16
	mov	[esi].yp31,eax
plin10:	mov	eax,[esi].xp31
	add	eax,[esi].xadd
	cmp	eax,(xmax-1)*10000H
	jb	plin0C
	mov	eax,(xmax-1)*10000H
plin0C:	mov	[esi].xp31,eax
	mov	eax,[esi].yp31
	add	eax,[esi].yadd
	cmp	eax,(ymax-1)*10000H
	jb	plin0D
	mov	eax,(ymax-1)*10000H
plin0D:	mov	[esi].yp31,eax
	call	plsb
plin11:	dec	dword ptr [esi].count
	jne	plin10
plin12:	dec	dword ptr [esi].ncount
	jne	plin01
	mov	eax,[esi].seg32
	mov	fs,ax
plin13:	xor	eax,eax
	pop	ebx
	pop	edi
	pop	esi
	mov	esp,ebp
	pop	ebp
	ret

plsb:	mov	eax,[esi].yp31		; number cal.
	test	eax,8000H
	je	plsb01
	add	eax,10000H
plsb01:	shr	eax,16
	mov	[esi].yp32,eax
	shl	eax,10
	mov	ecx,[esi].xp31
	test	ecx,8000H
	je	plsb02
	add	ecx,10000H
plsb02:	shr	ecx,16
	mov	[esi].xp32,ecx
	shl	ecx,1
	add	eax,ecx
	cmp	eax,xmax*ymax*2-2
	ja	plsb04
	test	dword ptr [esi].mode3,1
	je	plsb03
	mov	cx,fs:[eax]
	xor	ecx,00007fffH
	mov	fs:[eax],cx
plsb03:	test	dword ptr [esi].mode3,2
	je	plsb04
	mov	eax,[esi].yp32
	imul	eax,xmax
	add	eax,[esi].xp32
	cmp	eax,xmax*ymax-1
	ja	plsb04
	shl	eax,1
	add	eax,[esi].gadd
	mov	cx,[eax]
	or	ecx,00008000H
	mov	[eax],cx
plsb04:	ret
pline	endp

;peekw( address, segment )

	public	peekw
	db	'peekw',5
peekw	proc	near
	mov	eax,4[esp]
	mov	fs,8[esp]
	mov	ax,fs:[eax]
	and	eax,0ffffH
	ret
peekw	endp

;pokew( address, segment, data )

	public	pokew
	db	'pokew',5
pokew	proc	near
	push	esi
	mov	esi,8[esp]
	mov	fs,12[esp]
	mov	eax,16[esp]
	mov	fs:[esi],ax
	pop	esi
	ret
pokew	endp

;xorw( address, segment, data )

	public	xorw
	db	'xorw',4
xorw	proc	near
	push	esi
	mov	esi,8[esp]
	mov	fs,12[esp]
	mov	eax,16[esp]
	xor	fs:[esi],ax
	pop	esi
	ret
xorw	endp

;peekd( address, segment )

	public	peekd
	db	'peekd',5
peekd	proc	near
	mov	eax,4[esp]
	mov	fs,8[esp]
	mov	eax,fs:[eax]
	ret
peekd	endp

;poked( address, segment, data )

	public	poked
	db	'poked',5
poked	proc	near
	push	esi
	mov	esi,8[esp]
	mov	fs,12[esp]
	mov	eax,16[esp]
	mov	fs:[esi],eax
	pop	esi
	ret
poked	endp

;xord( address, segment, data )

	public	xord
	db	'xord',4
xord	proc	near
	push	esi
	mov	esi,8[esp]
	mov	fs,12[esp]
	mov	eax,16[esp]
	xor	fs:[esi],eax
	pop	esi
	ret
xord	endp

;outfa( fa, haj )		; 垂直帰線中にhaj,fa WRITE

	public	outfa
	db	'outfa',5
outfa	proc	near
	mov	dx,0440h	; 垂直同期を読む
	mov	al,30
	out	dx,al
	mov	dx,0443h	; 0443h
	xor	ecx,ecx		; カウンター
outf01:	in	al,dx
	and	al,04h
	je	outf02
	loop	outf01
outf02:	in	al,dx
	and	al,04h
	jne	outf03
	loop	outf02
outf03:	mov	al,18		;*
	mov	dx,0440h
	out	dx,al
	mov	eax,[esp+8]
	mov	dx,0442h
	out	dx,ax
	mov	al,22		;*
	mov	dx,0440h
	out	dx,al
	mov	eax,[esp+8]
	mov	dx,0442h
	out	dx,ax
	mov	al,17		;*
	mov	dx,0440h
	out	dx,al
	mov	eax,[esp+4]
	mov	dx,0442h
	out	dx,ax
	mov	al,21		;*
	mov	dx,0440h
	out	dx,al
	mov	eax,[esp+4]
	mov	dx,0442h
	out	dx,ax
	ret
outfa	endp

;outb( address, data )  outw( address, data )  inb( address )  inw( address )

	public	outb
	db	'outb',4
outb	proc	near
	mov	edx,[esp+4]
	mov	eax,[esp+8]
	out	dx,al
	ret
outb	endp

	public	outw
	db	'outb',4
outw	proc	near
	mov	edx,[esp+4]
	mov	eax,[esp+8]
	out	dx,ax
	ret
outw	endp

	public	inb
	db	'inb',3
inb	proc	near
	mov	edx,[esp+4]
	in	al,dx
	movzx	eax,al
	ret
inb	endp

	public	inw
	db	'inw',3
inw	proc	near
	mov	edx,[esp+4]
	in	ax,dx
	movzx	eax,ax
	ret
inw	endp

        cseg	ends
	end