PROGRAM MAIN
    IMPLICIT NONE
    INTEGER :: N, I, J, P, PRIME_COUNT
    LOGICAL, ALLOCATABLE, DIMENSION(:) :: IS_PRIME, WIN_LOSE
    INTEGER, ALLOCATABLE, DIMENSION(:) :: PRIME

    READ *, N
    IF (N < 4) THEN
        PRINT *, 'Lose'
        RETURN
    END IF

    IS_PRIME = ERATOSTHENES(N)
    ! PRINT *, IS_PRIME(:)
    ALLOCATE(PRIME(N))
    J = 1
    DO I = 1, N
        IF (IS_PRIME(I)) THEN
            PRIME(J) = I
            J = J + 1
        END IF
    END DO
    PRIME_COUNT = J - 1

    ! この後において、勝敗判定を行う。
    ALLOCATE(WIN_LOSE(N))
    ! WIN_LOSE = TRUE(勝ち) FALSE(負け)
    WIN_LOSE = .FALSE.
    DO I = 4, N
        DO J = 1, PRIME_COUNT
            P = PRIME(J)

            IF (P >= I - 1) EXIT
            
            IF (.NOT. WIN_LOSE(I - P)) THEN
                WIN_LOSE(I) = .TRUE.
                EXIT
            END IF
        END DO
    END DO

    IF (WIN_LOSE(N)) THEN
        PRINT *, 'Win'
    ELSE
        PRINT *, 'Lose'
    END IF

CONTAINS
    FUNCTION ERATOSTHENES(N) RESULT(IS_PRIME)
        IMPLICIT NONE
        INTEGER, INTENT(IN) :: N
        LOGICAL, ALLOCATABLE, DIMENSION(:):: IS_PRIME
        INTEGER :: I, J

        ALLOCATE(IS_PRIME(N))
        IS_PRIME = .TRUE.

        ! エラトステネスの篩を実装するよ。
        ! IS_PRIME = .TRUE.(素数) .FALSE.(合成数・1)

        IS_PRIME(1) = .FALSE.
        IS_PRIME(2) = .TRUE.
        DO I = 2, N
            IF (.NOT. IS_PRIME(I)) THEN
                CYCLE
            END IF

            IF (I * I > N) THEN
                EXIT
            END IF

            DO J = I * I, N, I
                IS_PRIME(J) = .FALSE.
            END DO
        END DO

        RETURN
    END FUNCTION ERATOSTHENES
END PROGRAM MAIN