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

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

    RETURN
END SUBROUTINE SORT

PROGRAM MAIN
    IMPLICIT NONE
    INTEGER :: N, W_SUM, TAR, I, J, CURR, MAX
    INTEGER, ALLOCATABLE, DIMENSION(:) :: W, A, B

    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)
    IF (TAR == 0) THEN
        PRINT *, 'possible'
        RETURN
    END IF
    ALLOCATE(A(TAR), SOURCE = 0)
    ALLOCATE(B(TAR))
    B(1) = 0
    CURR = 1
    MAX = 1

    ! PRINT *, W(:)
    ! PRINT *, TAR

    
    DO I = 1, N - 1
        DO J = 1, CURR
            IF (A(W(I) + B(J)) == 0) THEN
                MAX = MAX + 1
                A(W(I) + B(J)) = 1
                B(MAX) = W(I) + B(J)
                IF (B(MAX) == TAR) THEN
                    PRINT *, 'possible'
                    RETURN
                END IF
            END IF
        END DO
        CURR = MAX
    END DO

    PRINT *, 'impossible'
END PROGRAM MAIN