use std::io::{self, Read};

#[derive(Debug)]
struct Input {
    n: i32,
}

fn next_token(cin_lock: &mut io::StdinLock) -> String {
    cin_lock
        .by_ref()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect::<String>()
}

fn read_input(cin_lock: &mut io::StdinLock) -> Input {
    Input {
        n: next_token(cin_lock).parse().unwrap(),
    }
}

fn prime_numbers(n: i32) -> Vec<i32> {
    let mut numbers = (0..=n).collect::<Vec<_>>();
    // numbers[0] = 0; // [0] == 0なので不要
    numbers[1] = 0;

    let limit = (n as f64).sqrt() as usize;
    for i in 2..=limit {
        let x = numbers[i];
        if x == 0 {
            continue;
        }

        let mut k = i + x as usize;
        while k <= n as usize {
            if numbers[k] != 0 {
                numbers[k] = 0;
            }
            k += x as usize;
        }
    }

    numbers.into_iter().filter(|x| *x != 0).collect()
}

#[derive(Clone, Copy)]
enum GameResult {
    Win,
    Lose,
}

fn simulate(n: i32, primes: &[i32]) -> GameResult {
    let mut win = vec![false; (n + 1) as usize];
    win[0] = true;
    win[1] = true;

    for i in 2..=n {
        for p in primes {
            if *p > i {
                break;
            }

            let next_n = (i - *p) as usize;
            if !win[next_n] {
                win[i as usize] = true;
                break;
            }
        }
    }

    if win[n as usize] {
        GameResult::Win
    } else {
        GameResult::Lose
    }
}

fn solve(input: Input, _cin_lock: &mut io::StdinLock) {
    let primes = prime_numbers(input.n);
    println!(
        "{}",
        match simulate(input.n, &primes) {
            GameResult::Win => "Win",
            GameResult::Lose => "Lose",
        }
    );
}

fn main() {
    let cin = io::stdin();
    let mut cin_lock = cin.lock();

    let input = read_input(&mut cin_lock);
    solve(input, &mut cin_lock);
}