include console.inc
.STACK 4096
.DATA
        MISTAKE DB 'SOME KIND OF MISTAKE MAAAN',0
        prov DB 'JUST PROVERKA MAN',0
    B1 db ?
        B2 db ?
        B3 db ?
        W1 dw ?
        W2 dw ?
        W3 dw ?
        D1 dd ?
        D2 dd ?
        D3 dd ?
        Q1 dq ?
        Q2 dq ?
        Q3 dq ?
        ADDTHREE MACRO A,B,C
        PUSH ESP
        PUSH EAX

        IF TYPE A LE 4 AND TYPE A GE 1; помещаем в стек переменные

                PUSH 1 ;, если они размером от byte до dword
                IF TYPE A EQ BYTE
                        MOV AH, A
                        MOV BYTE PTR [ESP],AH
                        MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
                        MOV BYTE PTR [ESP+2],0
                        MOV BYTE PTR [ESP+3],0
                        MOV EAX, [ESP+4]
                ENDIF
                IF TYPE A EQ WORD
                        IFIDN <SP>,<A>
                                MOV AX, WORD PTR [ESP+8]
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX, [ESP+4]
                        ELSE
                                MOV AX,A
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX,[ESP+4]
                        ENDIF

                ENDIF
                IF TYPE A EQ DWORD
                        IFIDN <ESP>,<A> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
                                MOV EAX,[ESP+8]
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX, [ESP+4]
                        ELSE
                                MOV EAX,A
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX,[ESP+4]
                        ENDIF
                ENDIF


        ELSEIF TYPE A EQ 0
                PUSH A
        ENDIF
        outu [ESP]
        newline

        IF TYPE B LE 4 AND TYPE B GE 1; помещаем в стек переменные
                PUSH 1 ;, если они размером от byte до dword
                IF TYPE B EQ BYTE
                        MOV AH,B
                        MOV BYTE PTR [ESP],AH
                        MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
                        MOV BYTE PTR [ESP+2],0
                        MOV BYTE PTR [ESP+3],0
                        MOV EAX,[ESP+8]
                ENDIF
                IF TYPE B EQ WORD
                        IFIDN <SP>,<B>
                                outstr offset prov
                                newline
                                MOV AX, WORD PTR [ESP+12]
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX, [ESP+8]
                        ELSE
                                MOV AX,B
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX,[ESP+8]
                        ENDIF

                ENDIF
                IF TYPE B EQ DWORD
                        IFIDN <ESP>,<B> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
                                MOV EAX,[ESP+12]
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX, [ESP+8]
                        ELSE
                                MOV EAX,A
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX,[ESP+8]
                        ENDIF
                ENDIF


        ELSEIF TYPE B EQ 0
                PUSH B

        ENDIF
        outu [ESP]
        newline
        IF TYPE C LE 4 AND TYPE C GE 1; помещаем в стек переменные
                PUSH 1 ;, если они размером от byte до dword
                IF TYPE C EQ BYTE
                        MOV AH,C
                        MOV BYTE PTR [ESP],AH
                        MOV BYTE PTR [ESP+1],0 ;очищаем "мусор"
                        MOV BYTE PTR [ESP+2],0
                        MOV BYTE PTR [ESP+3],0
                        MOV EAX,[ESP+12]
                ENDIF
                IF TYPE C EQ WORD
                        IFIDN <SP>,<C>
                                outstr offset prov
                                newline
                                MOV AX, WORD PTR [ESP+16]
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX, [ESP+12]
                        ELSE
                                MOV AX,C
                                MOV WORD PTR [ESP],AX
                                MOV BYTE PTR [ESP+2],0
                                MOV BYTE PTR [ESP+3],0
                                MOV EAX,[ESP+12]
                        ENDIF

                ENDIF
                IF TYPE C EQ DWORD
                        IFIDN <ESP>,<C> ; ЕСЛИ А = ESP КАК ЭЛЕМЕНТ
                                MOV EAX,[ESP+16]
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX, [ESP+12]
                        ELSE
                                MOV EAX,C
                                MOV DWORD PTR [ESP],EAX
                                MOV EAX,[ESP+12]
                        ENDIF
                ENDIF


        ELSEIF TYPE C EQ 0
                PUSH C
        ELSEIF TYPE C EQ 8
                PUSH DWORD PTR C
                PUSH DWORD PTR C+4
        ENDIF
        outu [ESP]
        newline
        MOV EAX,0; обнуляем наш арифмитический регистр

        IF TYPE A EQ 0
                IF TYPE B EQ 0;1-START
                                IF TYPE C EQ 0;2-START
                                        OUTSTR OFFSET MISTAKE

                                ELSEIF TYPE C EQ 1
                                MOV AH, BYTE PTR [ESP+4]
                                ADD BYTE PTR [ESP], AH
                                MOV AH, BYTE PTR [ESP+8]
                                ADD BYTE PTR [ESP], AH
                                MOV AH, BYTE PTR [ESP]
                                MOV C, AH

                                ELSEIF TYPE C EQ 2
                                MOV AX, WORD PTR [ESP+4]
                                ADD WORD PTR [ESP], AX
                                MOV AX, WORD PTR [ESP+8]
                                ADD WORD PTR [ESP], AX
                                MOV AX, WORD PTR [ESP]
                                MOV C, AX

                                ELSEIF TYPE C EQ 4
                                MOV EAX, [ESP+4]
                                ADD [ESP], EAX
                                MOV EAX, [ESP+8]
                                ADD [ESP], EAX
                                MOV EAX, [ESP]
                                MOV C, EAX

                               ELSE
                               MOV EAX,[ESP+4]
                               ADD DWORD PTR C,EAX
                               ADC DWORD PTR C+4,0
                               MOV EAX, [ESP+8]
                               ADD DWORD PTR C,EAX
                               ADC DWORD PTR C+4,0

                               ENDIF;2-END

                 ELSEIF TYPE C GT TYPE B
                                OUTSTR OFFSET MISTAKE;Если b - ненулевой
                 ELSEIF TYPE B EQ BYTE
                                       MOV AH, byte ptr [ESP]
                                       ADD byte ptr [ESP+4], AH
                                       MOV AH, BYTE PTR [ESP+8]
                                       ADD BYTE PTR [ESP+4], AH
                                       MOV AH, BYTE PTR [ESP+4]
                                       MOV B,AH
                  ELSEIF TYPE B EQ WORD
                                       MOV AX, WORD ptr [ESP]
                                       ADD WORD ptr [ESP+4], AX
                                       MOV AX, WORD PTR [ESP+8]
                                       ADD WORD PTR [ESP+4], AX
                                       MOV AX, WORD PTR [ESP+4]
                                       MOV B,AX
                  ELSEIF TYPE B EQ DWORD
                                       MOV EAX, [ESP]
                                       ADD [ESP+4], EAX
                                       MOV EAX, [ESP+8]
                                       ADD [ESP+4], EAX
                                       MOV EAX, [ESP+4]
                                       MOV B,EAX
                  ELSEIF TYPE B EQ QWORD
                        IF TYPE C EQ QWORD
                                MOV EAX,[ESP+8]
                                ADD DWORD PTR B,EAX
                                ADC DWORD PTR B+4,0
                                MOV EAX,DWORD PTR C
                                ADD DWORD PTR B,EAX
                                ADC DWORD PTR B+4,0
                                MOV EAX,DWORD PTR C+4
                                ADD DWORD PTR B,EAX
                        ELSE
                                MOV EAX,[ESP+8]
                                ADD DWORD PTR B,EAX
                                ADC DWORD PTR B+4,0
                                MOV EAX,[ESP]
                                ADD DWORD PTR B,EAX
                                ADC DWORD PTR B+4,0
                        ENDIF
                  ENDIF



        ELSEIF TYPE A EQ BYTE; случай, когда первый операнд - byte
               IF TYPE B LE 1 AND TYPE C LE 1
                       MOV AH, byte ptr [ESP]
                       ADD byte ptr [ESP+8], AH
                       MOV AH, BYTE PTR [ESP+4]
                       ADD BYTE PTR [ESP+8], AH
                       MOV AH, BYTE PTR [ESP+8]
                       MOV A,AH
               ELSE
                       OUTSTR OFFSET MISTAKE
               ENDIF




        ELSEIF TYPE A EQ WORD

        IF TYPE B LE 2 AND TYPE C LE 2
                       MOV AX, WORD ptr [ESP]
                       ADD WORD ptr [ESP+8], AX
                       MOV AX, WORD PTR [ESP+4]
                       ADD WORD PTR [ESP+8], AX
                       MOV AX, WORD PTR [ESP+8]
                       MOV A,AX

               ELSE
                       OUTSTR OFFSET MISTAKE
               ENDIF

        ELSEIF TYPE A EQ DWORD

        IF TYPE B LE 4 AND TYPE C LE 4
                       MOV EAX,[ESP]
                       ADD [ESP+8], EAX
                       MOV EAX, [ESP+4]
                       ADD [ESP+8], EAX
                       MOV EAX,[ESP+8]
                       MOV A,EAX
               ELSE
                       OUTSTR OFFSET MISTAKE
               ENDIF
        ELSEIF TYPE A EQ QWORD
                IF (TYPE B EQ 8) AND (TYPE C EQ 8) ; Type b = type c = q
                        IFIDN <A>,<C>
                                PUSH DWORD PTR C
                                PUSH DWORD PTR C+4
                                MOV EAX, DWORD PTR B
                                ADD DWORD PTR A,EAX
                                ADC DWORD PTR A+4,0
                                MOV EAX, DWORD PTR B+4
                                ADD DWORD PTR A+4, EAX
                                MOV EAX, [ESP+4]
                                ADD DWORD PTR A,EAX
                                ADC DWORD PTR A+4,0
                                MOV EAX,[ESP]
                                ADD DWORD PTR A+4,EAX


                        ELSE
                                MOV EAX,DWORD PTR B
                                ADD DWORD PTR A,EAX
                                ADC DWORD PTR A+4, 0
                                MOV EAX,DWORD PTR B+4
                                ADD DWORD PTR A+4,EAX
                                MOV EAX,DWORD PTR C
                                ADD DWORD PTR A,EAX
                                ADC DWORD PTR A+4,0
                                MOV EAX,DWORD PTR C+4
                                ADD DWORD PTR A+4,EAX
                        ENDIF


                ELSEIF TYPE B NE 8 AND TYPE C EQ 8 ; type b !=q type c = q
                MOV EAX,DWORD PTR [ESP+4]
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                MOV EAX,DWORD PTR C
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                MOV EAX,DWORD PTR C+4
                ADD DWORD PTR A+4,EAX




                ELSEIF TYPE B EQ 8 AND TYPE C NE 8 ; type b = q type c !=q
                MOV EAX,DWORD PTR [ESP]
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                MOV EAX,DWORD PTR B
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                MOV EAX,DWORD PTR B+4
                ADD DWORD PTR A+4,EAX

                ELSEIF TYPE B NE 8 AND TYPE C NE 8 ; Type b !=q type c != q
                MOV EAX,DWORD PTR [ESP]
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                MOV EAX,DWORD PTR [ESP+4]
                ADD DWORD PTR A,EAX
                ADC DWORD PTR A+4,0
                ENDIF


        ENDIF



        OUTU A
        newline
        OUTU B
        newline
        OUTU C
        newline
        ENDM

        .CODE
        START:
        ;байты
        MOV byte ptr B1,5
        MOV byte ptr B2,6
        MOV byte ptr B3,7
        ;слова
        MOV word ptr W1,5
        MOV word ptr W2,6
        MOV word ptr W3,7
        ;dword
        MOV dword ptr D1,5
        MOV dword ptr D2,6
        MOV dword ptr D3,7
        ;qword
        MOV dword ptr Q1,4
        MOV dword ptr Q2,4
        MOV dword ptr Q3,4

        MOV dword ptr Q1+4,0
        MOV dword ptr Q2+4,0
        MOV dword ptr Q3+4,0
        ADDTHREE Q1,Q1,Q1

exit
END START