Удалить из массива все элементы, которые встречаются больше двух раз

MODEL tiny
.code
org 100h
 
.code
main:
    mov ds,ax
    xor ax,ax   ;обнуление ax
    mov cx,10   ;значение счетчика цикла в cx
    mov si,1    ;индекс начального элемента в cx
go:             ;цикл инициализации
    mov bh,i    ;i в bh
    mov mas[si],bh  ;запись в массив i
    inc i       ;инкремент i
    inc si      ;продвижение к следующему
                ;элементу массива
    loop    go  ;повторить цикл
;вывод на экран получившегося массива
    mov cx,10
    mov si,0
    mov ah,09h
    lea dx,mes
    int 21h
show:
    mov ah,02h  ;функция вывода значения
                ;из al на экран
    mov dl,mas[si]
    add dl,30h  ;преобразование числа в символ
    int 21h
    inc si
    loop    show
exit:
    mov ax,4c00h    ;стандартный выход
    int 21h
mes db  0ah,0dh,'Массив- ','$'
mas db  10 dup (?) ;исходный массив
i   db  0
end main        ;конец программы

ORG 100h
JMP start
 
mess0    DB  'RESULT: $'
massiv   DB  88,27,1,62,10,33,91,2,1,10,13,1,88,10,10,33,1,88
size     =   $ - massiv     ; длина массива
buff     DB  32 DUP(0)      ; буфер для результата
 
start:
   MOV   AH,9               ;
   MOV   DX,mess0           ;
   INT   21h                ;
   MOV   DI,buff            ; сюда будем писать
   MOV   SI,massiv          ; от сюда - читать
   MOV   DX,size            ; кол-во повторов (длина строки)
 
compare:                    ;
   MOV   AH,BYTE[SI]        ; Берём число
   CALL  count_Digit        ; сколько раз оно встретилось в массиве?
   CMP   BX,3               ; проверка на 3.
   JAE   next               ; если больше/равно, то пропускаем число
   XCHG  AH,AL              ; иначе: текущее число у нас в AH
   STOSB                    ; кидаем его в AL, и записываем в буфер!
next:                       ;
   INC   SI                 ; следующее число массива..
   DEC   DX                 ; уменьшаем его длину
   OR    DX,DX              ; это последнее число в массиве?
   JNZ   compare            ; нет - мотаем цикл..
 
   MOV   CX,DI              ; Отсеянные числа у нас в буфере.
   SUB   CX,buff            ; СХ = его длина
   MOV   SI,buff            ; травим SI на буфер (для LODSB)
print:                      ;
   XOR   AH,AH              ; обнуляем мусор
   LODSB                    ; читаем число из буфера
   MOV   BX,10              ; выводить на экран будем в DEC
   CALL  HEX2ASC            ; есть контакт!
   MOV   AL,','             ; вставим разделитель
   INT   29h                ;
   LOOP  print              ; мотаем цикл СХ-раз...
 
exit:                       ;
   XOR   AX,AX              ;
   INT   16h                ;
   INT   20h                ; на выход!
 
;ннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннн;
; Процедура:  "count_Digit" считает кол-во одинаковых символов в строке   ;
;  На входе:  АН = число/символ для поиска                                ;
;             СХ = длина строки                                           ;
;             SI = адрес строки                                           ;
; На выходе:  ВХ = количество найденых символов                           ;
;ннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннн;
count_Digit:                ;
   PUSH  SI                 ; SI нам нужен. сохраним его
   MOV   SI,massiv          ;
   MOV   CX,size            ;
   XOR   BX,BX              ; сбросим счётчик в нуль
@@1:                        ;
   LODSB                    ; читаем в AL из SI
   CMP   AH,AL              ;
   JNZ   @@2                ; прыг, если не совпало с фактором
   INC   BX                 ; иначе: счётчик +1
@@2:                        ;
   LOOP  @@1                ; обрабатываем строку до конца...
   POP   SI                 ;
RET                         ;
 
;ннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннн;
;   Функция:  "HEX2ASC" выводит на экран слово в различных СС             ;
;  На входе:  АХ = число для вывода                                       ;
;             ВХ = система счисления                                      ;
;ннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннннн;
HEX2ASC:                    ;
   PUSHA                    ;
   MOV   BX,10              ;
   XOR   CX,CX              ;
isDiv:                      ;
   XOR   DX,DX              ;
   DIV   BX                 ;
   PUSH  DX                 ;
   INC   CX                 ;
   OR    AX,AX              ;
   JNZ   isDiv              ;
isOut:                      ;
   POP   AX                 ;
   CMP   AL,9               ;
   JLE   noHex              ;
   ADD   AL,7               ;
noHex:                      ;
   ADD   AL,30h             ;
   INT   29h                ;
   LOOP  isOut              ;
   POPA                     ;
RET                         ;
;============================ E O F ======================================|

.model  medium
 
.stack  200h
 
.data
        CrLf            db      0Dh, 0Ah, '$'
        N               dw      10
        Array           dw      2, 73, 26, 7, 7, 18, 59, 121, 7, 68
        msgArrayLen     db      ' array length: ', '$'
        msgInnocence    db      'Innocence array:', 0Dh, 0Ah, '$'
        msgResult       db      0Dh, 0Ah, 'Result array:', 0Dh, 0Ah, '$'
        msgPressAnyKey  db      0Dh, 0Ah, 'Press any key to exit...', '$'
.code
 
main    proc
        ;инициализация сегментного регистра ds адресом сегмента данных
        mov     ax,     @data
        mov     ds,     ax
        ;вывод исходных данных
        mov     ah,     09h
        lea     dx,     [msgInnocence]
        int     21h
        call    ShowData
        ;обработка массива
        ; - сортировка
        lea     si,     [Array]
        mov     cx,     [N]
        call    BubbleSort
        ; - удаление элементов, встречающихся более двух раз
        push    ds
        pop     es
        lea     si,     [Array]
        mov     cx,     [N]
        sub     cx,     1
        jbe     @@Skip
        xor     dx,     dx
        mov     bx,     [si]
        add     si,     2
        mov     di,     si
        _do:                                            ;do{
                lodsw                                   ;  temp=a[indx++]
                cmp     bx,    ax                       ;  if(a[left]==temp)
                jne     _no_equal
                        inc     dx                      ;    deleted++;
                        jmp     _next
                _no_equal:                              ;  else
                        cmp     dx,     2
                        jb      _no_delete
                        inc     dx
                        sub     [N],    dx
                        shl     dx,     1
                        sub     di,     dx
                _no_delete:
                xor     dx,     dx
        _next:
                stosw
                mov     bx,     ax
        loop    _do                                     ;}while(indx<n)
        cmp     dx,     2
        jb      @@Skip
        inc     dx
        sub     [N],    dx                              ;n-=deleted
@@Skip:
        ;вывод результата
        mov     ah,     09h
        lea     dx,     [msgResult]
        int     21h
        call    ShowData
        ;ожидание нажатия любой клавиши
        mov     ah,     09h
        lea     dx,     [msgPressAnyKey]
        int     21h
        mov     ah,     00h
        int     16h
        ;завершение программы
        mov     ax,     4C00h
        int     21h
main    endp
 
ShowData        proc
        mov     ah,     09h
        lea     dx,     [msgArrayLen]
        int     21h
        mov     ax,     [N]
        call    ShowUInt16
        mov     ah,     09h
        lea     dx,     [CrLf]
        int     21h
        lea     dx,     [Array]
        mov     cx,     [N]
        call    ShowArray
        ret
ShowData        endp
 
;Вывод массива слов (word)
;на входе:
;  cx - количество выводимых элементов
;  ds:dx - адрес массива слов
ShowArray       proc
        push    ax
        push    bx
        push    cx
        push    dx
        push    si
        push    di
 
        jcxz    @@Exit          ;если массив пустой - завершить
 
        mov     si,     1       ;индекс элемента массива
        mov     di,     dx      ;адрес текущего элемента массива
        @@ForI:
                mov     ax,     [di]
                call    ShowUInt16
                mov     ah,     02h
                mov     dl,     ' '
                int     21h
                ;переход к следующему элементу
                inc     si
                add     di,     2
        loop    @@ForI
@@Exit:
        pop     di
        pop     si
        pop     dx
        pop     cx
        pop     bx
        pop     ax
        ret
ShowArray       endp
 
;Вывод на экран целого 16 разрядного беззнакового числа
;на входе:
;  ax - целое 16 разрядное беззнаковое число
ShowUInt16       proc
        push    ax
        push    bx
        push    cx
        push    dx
        mov     bx,     10              ;делитель (основание системы счисления)
        mov     cx,     0               ;количество выводимых цифр
        @@div:
                xor     dx,     dx      ;делим (dx:ax) на bx
                div     bx
                add     dl,     '0'     ;преобразуем остаток деления в символ цифры
                push    dx              ;и сохраняем его в стеке
                inc     cx              ;увеличиваем счётчик цифр
                test    ax,     ax      ;в числе ещё есть цифры?
        jnz     @@div                   ;да - повторить цикл выделения цифры
        @@show:
                mov     ah,     02h     ;функция ah=02h int 21h - вывести символ из dl на экран
                pop     dx              ;извлекаем из стека очередную цифру
                int     21h             ;и выводим её на экран
        loop    @@show                  ;и так поступаем столько раз, сколько нашли цифр в числе (cx)
        pop     dx
        pop     cx
        pop     bx
        pop     ax
        ret
ShowUInt16       endp
 
;Сортировка "пузырьком" массива слов
;на входе
;  ds:si - адрес массива слов
;  cx    - длина массива
BubbleSort      proc
        push    ax
        push    bx
        push    cx
        push    dx
        push    si
        push    di
 
        mov     bx,     si
        mov     dx,     cx
        dec     dx
        shl     dx,     1               ;приведение dx=N к размерности элементов
        dec     cx                      ;for i:=1 to N-1 do
        mov     si,     0
@@ForI:
        mov     di,     dx              ;  j:=N
@@ForJ:                                 ;  repeat
        mov     ax,     [bx+di-2]       ;    (a[j] < and a[j - 1])
        cmp     ax,     [bx+di]
        jbe     @@NextJ                 ;    if r<0 then
        xchg    ax,     [bx+di]         ;      temp:=a[j]
        xchg    ax,     [bx+di-2]       ;      a[j]:=a[j-1]
        xchg    ax,     [bx+di]         ;      a[j-1]:=a[j]
@@NextJ:
        sub     di,     2               ;    dec(j)
        cmp     di,     si              ;  until j<=i;
        ja      @@ForJ
        add     si,     2               ;  end; for i равноценно inc(i)
        loop    @@ForI
 
        pop     di
        pop     si
        pop     dx
        pop     cx
        pop     bx
        pop     ax
        ret
BubbleSort      endp
 
end     main