; lab8.asm - a function that checks if an array is a premutation of the other
;
        .MODEL SMALL
        .STACK 100h
        .DATA

            Count DW 10 DUP(?)                  ; count[10] = {0}

        .CODE
            PUBLIC _PermutationArray
            _PermutationArray PROC NEAR
                PUSH BP
                MOV BP,SP
                PUSH DI
                PUSH SI

                XOR CX,CX                       ; CX = 0
                XOR DI,DI                       ; DI = 0 (index)

                MOV CX,10                       ; CX = 10

                ZerofyLoop: ; Count[10] = {0}
                    CMP DI,CX
                    JE ExitZerofyLoop
                    MOV Count[DI],0
                    INC DI
                    JMP ZerofyLoop

                ExitZerofyLoop:
                MOV DI,[BP+4]                   ; DI = int array1[]
                MOV SI,[BP+6]                   ; SI = int array2[]
                MOV CX,[BP+8]                   ; CX = int size
                XOR BX,BX                       ; i = 0

                CounterLoop:
                    CMP BX,CX                   ; i < size
                    JE CounterLoop2             ; i = size
                    INC Count[DI]               ; count[array1[i]]++
                    ADD DI,2
                    INC BX                      ; i++
                    JMP CounterLoop

                XOR BX,BX                       ; i = 0

                CounterLoop2:
                    CMP BX,CX                   ; i < size
                    JE ExitCounterLoop2         ; i = size
                    DEC Count[SI]               ; count[array1[i]]++
                    ADD SI,2
                    INC BX                      ; i++
                    JMP CounterLoop2

                ExitCounterLoop2:
                MOV CX,10                       ; CX = 10
                XOR DI,DI                       ; i = 0


                CheckLoop:
                    CMP DI,CX                   ; i < size
                    JE ReturnTrue               ; return 1
                    CMP Count[DI],'0'           ; if(count[i])
                    JNE ReturnFalse             ; return 0
                    INC DI                      ; i++
                    JMP CheckLoop

                ReturnTrue:
                MOV AX,1
                JMP Exit

                ReturnFalse:
                XOR AX,AX

                Exit:
                POP SI
                POP DI
                POP BP
                RET
            _PermutationArray ENDP
        END