Problem:
Score : 300 points

Problem Statement

In Takahashi Kingdom, there is an archipelago of N islands, called Takahashi Islands.
For convenience, we will call them Island 1, Island 2, ..., Island N.

There are M kinds of regular boat services between these islands.
Each service connects two islands. The i-th service connects Island a_i and Island b_i.

Cat Snuke is on Island 1 now, and wants to go to Island N.
However, it turned out that there is no boat service from Island 1 to Island N, so he wants to know whether it is possible to go to Island N by using two boat services.

Help him.

Constraints

3 ≤ N ≤ 200 000

1 ≤ M ≤ 200 000

1 ≤ a_i < b_i ≤ N

(a_i, b_i) \neq (1, N)

If i \neq j, (a_i, b_i) \neq (a_j, b_j).

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

If it is possible to go to Island N by using two boat services, print POSSIBLE; otherwise, print IMPOSSIBLE.

Sample Input 1

3 2
1 2
2 3

Sample Output 1

POSSIBLE

Sample Input 2

4 3
1 2
2 3
3 4

Sample Output 2

IMPOSSIBLE

You have to use three boat services to get to Island 4.

Sample Input 3

100000 1
1 99999

Sample Output 3

IMPOSSIBLE

Sample Input 4

5 5
1 3
4 5
2 3
2 4
1 4

Sample Output 4

POSSIBLE

You can get to Island 5 by using two boat services: Island 1 -> Island 4 -> Island 5.

Solution in Rust (1.15.1) (judge verdict: Accepted)

///////////////////////////////////////////// Template /////////////////////////////////////////////
#![allow(non_snake_case, unused)]
use std::collections::*;

macro_rules! debug {
	($($v: expr),*) => { {
		use ::std::io::Write;
		$(let _ = write!(::std::io::stderr(), "{} = {:?} ", stringify!($v), $v);)*
		let _ = writeln!(::std::io::stderr(), "@ {}:{}", file!(), line!());
	} }
}
macro_rules! mat {
	($e:expr) => { $e };
	($e:expr; $d:expr $(; $ds:expr)*) => { vec![mat![$e $(; $ds)*]; $d] };
}
macro_rules! ok {
	($a:ident$([$i:expr])*.$f:ident()$(@$t:ident)*) => {
		$a$([$i])*.$f($($t),*)
	};
	($a:ident$([$i:expr])*.$f:ident($e:expr$(,$es:expr)*)$(@$t:ident)*) => { {
		let t = $e;
		ok!($a$([$i])*.$f($($es),*)$(@$t)*@t)
	} };
}
mod template {
	type I<'a> = ::std::iter::Peekable<::std::str::SplitWhitespace<'a>>;
	pub trait FromLn<'a> {
		fn fromln(&mut I<'a>) -> Self;
	}
	pub fn readln<T: for<'a> FromLn<'a>>() -> T {
		let mut buf = String::new();
		let _ = ::std::io::stdin().read_line(&mut buf).unwrap_or_else(|e| panic!("{}", e));
		let mut it = buf.split_whitespace().peekable();
		let t = T::fromln(&mut it);
		if it.peek().is_some() { panic!("input mismatch") }
		t
	}
	pub fn readlns<T: for<'a> FromLn<'a>>(n: usize) -> Vec<T> {
		(0..n).map(|_| readln()).collect()
	}
	macro_rules! read_primitives {
		($($t:ty),*) => { $(
			impl<'a> FromLn<'a> for $t {
				fn fromln(it: &mut I<'a>) -> $t {
					it.next().unwrap_or_else(|| panic!("input mismatch")).parse().unwrap_or_else(|e| panic!("{}", e))
				}
			}
		)* }
	}
	read_primitives!(String, bool, f64, i32, i64, usize, u32, u64);
	impl<'a, T> FromLn<'a> for Vec<T> where T: for<'b> FromLn<'b> {
		fn fromln(it: &mut I) -> Vec<T> {
			let mut vs = vec![];
			while it.peek().is_some() {
				vs.push(T::fromln(it));
			}
			vs
		}
	}
	impl<'a> FromLn<'a> for Vec<char> {
		fn fromln(it: &mut I) -> Vec<char> {
			String::fromln(it).chars().collect()
		}
	}
	impl<'a> FromLn<'a> for Vec<u8> {
		fn fromln(it: &mut I) -> Vec<u8> {
			String::fromln(it).into()
		}
	}
	macro_rules! read_tuple {
		($($t:ident),*) => {
			impl<'a, $($t),*> FromLn<'a> for ($($t),*) where $($t: for<'b> FromLn<'b>),* {
				fn fromln(it: &mut I) -> ($($t),*) {
					($($t::fromln(it)),*)
				}
			}
		}
	}
	read_tuple!(A, B);
	read_tuple!(A, B, C);
	read_tuple!(A, B, C, D);
	pub trait SetMin {
		fn setmin(&mut self, v: Self) -> bool;
	}
	impl<T> SetMin for T where T: PartialOrd {
		fn setmin(&mut self, v: T) -> bool {
			*self > v && { *self = v; true }
		}
	}
	pub trait SetMax {
		fn setmax(&mut self, v: Self) -> bool;
	}
	impl<T> SetMax for T where T: PartialOrd {
		fn setmax(&mut self, v: T) -> bool {
			*self < v && { *self = v; true }
		}
	}
}
use self::template::*;

fn main() {
	let (n, m) = readln();
	let mut to = vec![false; n];
	let mut from = vec![false; n];
	for (a, b) in readlns::<(usize, usize)>(m) {
		if a == 1 {
			to[b - 1] = true;
		}
		if b == n {
			from[a - 1] = true;
		}
	}
	if from.into_iter().zip(to.into_iter()).any(|(a, b)| a && b) {
		println!("POSSIBLE");
	} else {
		println!("IMPOSSIBLE");
	}
}