SUBROUTINE SORT(W, N)
    IMPLICIT NONE
    INTEGER, INTENT(INOUT) :: W(N)
    INTEGER :: I, J, N, TMP

    DO I = 1, N
        DO J = 1, N - I
            IF (W(I) > W(J)) THEN
                TMP = W(J)
                W(J) = W(I)
                W(I) = TMP
            END IF
        END DO
    END DO

END SUBROUTINE SORT

RECURSIVE SUBROUTINE DOVE(TAR, CURRENT, N, IMA, W)
    IMPLICIT NONE
    INTEGER :: TAR, CURRENT, N, IMA
    INTEGER ::  W(N)

    IF (TAR == 0 .OR. CURRENT == N) THEN
        RETURN
    END IF

    IF (IMA + W(CURRENT) < TAR) THEN
        CALL DOVE(TAR, CURRENT + 1, N, IMA + W(CURRENT), W)
    ELSE IF (IMA + W(CURRENT) == TAR) THEN
        TAR = 0
    END IF

END SUBROUTINE DOVE
            


PROGRAM MAIN
    IMPLICIT NONE
    INTEGER :: N, W_SUM, TAR
    INTEGER, ALLOCATABLE, DIMENSION(:) :: W

    READ *, N
    
    ALLOCATE(W(N))
    READ *, W(:)

    CALL SORT(W, N)

    W_SUM = SUM(W)
    IF (MOD(W_SUM, 2) /= 0) THEN
        PRINT *, 'impossible'
        RETURN
    END IF

    TAR = W_SUM / 2 - W(N)

    ! PRINT *, TAR

    CALL DOVE(TAR, 1, N, 0, W)
    IF (TAR == 0) THEN
        PRINT *, 'possible'
    ELSE
        PRINT *, 'impossible'
    END IF

END PROGRAM MAIN