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 Pascal (FPC 2.6.2) (judge verdict: Runtime Error)

const oo=10000000;
var n,m,nheap:longint;x,y,h,a,pos,heap,cp,c,f:array[0..500005] of longint;free:array[0..500005] of boolean;
procedure       nhap;
var i:longint;
begin
        readln(n,m);
        for i:=1 to m do
                begin
                readln(x[i],y[i]);
                inc(h[x[i]]);
                inc(h[y[i]]);
                end;
        for i:=2 to n+1 do
                h[i]:=h[i-1]+h[i];
        for i:=1 to m do
                begin
                A[h[x[i]]]:=y[i];
                a[h[y[i]]]:=x[i];
                C[h[x[i]]]:=1;
                C[h[y[i]]]:=1;
                dec(h[x[i]]);
                dec(h[y[i]]);
                end;
end;
procedure   init;
var i:longint;
begin
    for i:=1 to n do
        cp[i]:=oo;
    fillchar(free,sizeof(free),true);
    cp[1]:=0;
end;

procedure   swap(var x,y:longint);
var tamp:longint;
begin
    tamp:=x;
    x:=y;
    y:=tamp;
end;
procedure   upheap(i:longint);
begin
    if (i=1)or (cp[heap[i]]>cp[heap[i div 2]]) then exit;
    swap(heap[i],heap[i div 2]);
    swap(pos[heap[i]],pos[heap[i div 2]]);
    upheap(i div 2);
end;
procedure   downheap(I:longint);
var j:longint;
begin
    j:=i*2;
    if j>nheap then exit;
    if (j<nheap) and (cp[heap[j]]>cp[heap[j+1]]) then inc(j);
    if cp[heap[i]]>cp[heap[j]] then
        begin
        swap(heap[i],heap[j]);
        swap(pos[heap[i]],pos[heap[j]]);
        downheap(j);
        end;
end;
function pop(v:longint):longint;
begin
    pop:=heap[v];
    heap[v]:=heap[nheap];
    pos[heap[v]]:=v;
    dec(nheap);
    upheap(v);
    downheap(v);
end;
procedure   push(x:longint);
begin
    inc(nheap);
    pos[x]:=nheap;
    heap[nheap]:=x;
    upheap(nheap);
end;
procedure   dijheap;
var v,vjp,u:longint;
begin
    f[1]:=1;
    push(1);
    repeat
        u:=pop(1);
        if u=n then exit;
        free[u]:=false;
        for v:=h[u]+1 to h[u+1] do
            if (free[a[v]]) then
                begin
                if cp[a[v]]>=cp[u]+c[v] then
                    begin
                    if cp[a[v]]>cp[u]+c[v] then F[a[v]]:=f[u]
                    else f[a[v]]:=f[a[v]]+f[u];
                    cp[a[v]]:=cp[u]+c[v];
                    if pos[a[v]]=0 then push(a[v]) else
                        begin
                        vjp:=pos[a[v]];
                        upheap(vjp);
                        downheap(vjp);
                        end;
                    end

                end;
        until false;
end;
procedure       xuat;
begin
        if Cp[n]>2 then writeln('IMPOSSIBLE')
        else writeln('POSSIBLE');
end;
begin
       
        nhap;
        init;
        dijheap;
        xuat;
end.