stack segment para stack 'stack'
	db 100h	dup (?)
stack ends
data segment para public 'data'
	arr1 dw -3, 5, 7, 21, -3, 9, 0, 11, -14, 2
	arr2 dw 10 dup (0)
	arr2_n	dw	0
	arr1_n	dw	10
	arrpos dw 10 dup (?)
	arrp_n	dw	0
	left dw 0
	right dw 0
	minimum dw ?
	maximum dw ?
	indpos dw 0
	arrneg dw 10 dup (?)
	arrn_n	dw	0
	indneg dw 0 
	ind dw 0
	ind2 dw 0
	max dw 0
	sr_arifm dw 0
	perem dw 0
	iter dw 0
	
	pr		dw	?
	count_d	dw 0
	devisor	dw 10
	mess 	db '-$'
	mess2 	db '!$'
	mess_space db ' $'
	mes_n	db	"neg$"
	mes_ent db	10,13,'$'
	
	ax_	equ	ax
	ah_	equ	ah
	cx_	equ	cx
	bx_	equ	bx
	dx_	equ	dx
	di_	equ	di
	si_	equ	si
print_str macro s 
	lea	dx_,s
	mov	ah_,09h
	int	21h
endm
data ends
code segment para public 'code'
	assume cs:code,ds:data,ss:stack
main:
	mov		ax_,data
	mov		ds,ax_
	xor		ax_,ax_
	mov		cx_,arr1_n
	mov		si_,0
print_r1_loop:
	push	arr1[si_]
	call	p_print
	add		si_,2
	loop	print_r1_loop
	print_str mes_ent
	lea 	bx_, arrneg
	mov		indneg, bx_
	lea		bx_, arrpos
	mov		indpos, bx_
	lea		bx_, arr1
	mov 	ind, bx_
	mov		cx_,arr1_n
cycle:
	mov		dx_, [bx_]
	cmp 	dx_,0
	jge		positive
negative:
	inc		arrn_n
	mov		bx_, indneg
	mov		[bx_], dx_
	add		bx_, 2
	mov		indneg, bx_
	jmp		next_int
positive:
	inc		arrp_n
	mov		bx_, indpos
	mov		[bx_], dx_
	add		bx_, 2
	mov		indpos, bx_
next_int:
	add		ind, 2
	mov		bx_, ind
	loop	cycle
	
	mov si, 2
	mov ax, arr1[si]
	mov left, ax
	
	mov si, 16
	mov ax, arr1[si]
	mov right, ax
	
	neg left
	neg right
	mov ax, left
	cmp ax, right
	jl left_to_min
	jge right_to_min
right_to_min:
	mov ax, right
	mov minimum, ax
	mov ax, left
	mov maximum, ax
	jmp create
left_to_min:
	mov ax, left
	mov minimum, ax
	mov ax, right
	mov maximum, ax
create:
	
	lea		bx_,arrpos
	mov		indpos,bx_
	lea		bx_,arrneg
	mov		indneg,bx_
	lea		bx_,arr1
	mov		ind,bx_
	mov		ax_,arrp_n
	cmp		ax_,arrn_n
	jl		negat
	jge		posit
negat:
	mov		ax_,arrp_n
	mov 	iter, ax_
	mov		cx_,iter
	jmp		sort
posit:
	mov		ax_,arrn_n
	mov		iter, ax_
	mov		cx_, iter
sort:
	mov		bx_,indneg
	mov		ax_,[bx_]
	mov		bx_,ind
	mov		[bx_],ax_
	add		ind,2
	add		indneg,2
	mov		bx_,indpos
	mov		ax_,[bx_]
	mov		bx_,ind
	mov		[bx_],ax_
	add		ind,2
	add		indpos,2
	loop	sort
dop_sort:
	mov		ax_, arrp_n
	cmp		ax_,arrn_n
	jl		dop_negat
	jge		dop_posit
dop_negat:
	mov		ax_,arrp_n
	sub		arrn_n,ax_
	mov		cx_, arrn_n
dop_s_n:
	mov		bx_,indneg
	mov		ax_,[bx_]
	mov		bx_,ind
	mov		[bx_],ax_
	add		ind,2
	add		indneg,2
	loop	dop_s_n
	jmp		metka
dop_posit:
	mov		ax_,arrn_n
	sub		arrp_n,ax_
	mov		cx_, arrp_n
dop_s_p:
	mov		bx_,indpos
	mov		ax_,[bx_]
	mov		bx_,ind
	mov		[bx_],ax_
	add		ind,2
	add		indpos,2
	loop	dop_s_p
	
	mov		cx_, arr1_n
metka:
	mov		cx_,arr1_n
	mov		si_,0

create_arr2:
	mov		ind,0
	mov		ind2,0
	mov		cx_,arr1_n
arr2_make:
	mov		si, ind
	mov 	ax, minimum
	cmp		ax, arr1[si]
	jl     more_min
	jmp     next
	
more_min:
	mov		ax, maximum
	cmp 	arr1[si], ax
	jl		add_to_array
	jmp 	next
add_to_array:
	mov 	ax, arr1[si]
	mov 	si, ind2
	mov		arr2[si], ax
	add		ind2, 2
	add		arr2_n, 1
	jmp 	next
next:
	add ind,2
	loop arr2_make

	
	
	mov		cx_,arr1_n
	mov		si_,0
print_r_loop:
	push	arr1[si_]
	call	p_print
	add		si_,2
	loop	print_r_loop
	print_str mes_ent	
	mov		cx_,arr2_n
	jcxz	exit
	mov		si_,0
print_loop:
	push	arr2[si_]
	call	p_print
	add		si_,2
	loop	print_loop	
	
	

		
	
exit:
	mov		ax_,4c00h
  	int		21h
p_print proc
	pop		dx_
	pop		ax_
	push	dx_
	mov		pr,ax_
	push	cx_
	push	si_
	mov		count_d,0
	mov		dx_,pr
	cmp		dx_,0
	jge		print_pos
print_neg:
	lea		dx_,mess
	mov		ah_,09h
	int		21h
	neg		pr
print_pos:
	mov		ax_,pr
	cwd
	div		devisor
	push	dx_
	mov		pr,ax_
	inc		count_d
	cmp		pr,0
	jg		print_pos
	mov 	cx_,count_d
print:
	mov		ah_,02h
	pop		dx_
	add		dx_,'0'
	int		21h
	loop	print
	lea		dx_,mess_space
	mov		ah_,09h
	int		21h
	pop		si_
	pop		cx_
	ret
p_print endp
code ends
end 	main