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 C (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>

#define START 1
#define SIZE 200005
#define PRINT(bool) (printf("%sPOSSIBLE\n", bool ? "":"IM"))

typedef struct __data{
  int from;  //Key
  int to;
}Route;

typedef struct __node{
  Route data;
  struct __node *next;
}Node;

typedef struct __hash{
  int size;
  Node **table;
}Hash;

int InitHash(Hash *hash, int size)
{
  int i;
  
  hash->size = 0;
  if((hash->table = calloc(size, sizeof(Node *))) == NULL){
    //printf("メモリ確保失敗\n");
    return 0;
  }
  
  hash->size = size;//メモリ確保に成功したらサイズを決める.
  
  for(i = 0; i < size; i++){
    //printf("\nメモリを初期化しました");
    hash->table[i] = NULL; //全バケット数を初期化
  }
  
  return 1;
}

void TermHash(Hash *h)
{
  int i;
  for(i = 0; i < h->size; i++){
    Node *p = h->table[i];
    while(p != NULL){
      Node *next = p->next;
      free(p);
      p = next;
    }
  }
  //printf("ハッシュテーブルを削除しました\n");
}

Node *SearchNode(Hash *h, Route x)
{
  int i;
  Node *node = h->table[x.from];

  while(node != NULL){
    if(x.from == node->data.from){
      return node;
    }
    node = node->next;
  }
  return NULL;
}

void DumpHash(Hash *h)
{
    int i;
    
    for(i=0; i<h->size; i++){
        Node *p = h->table[i];
        while(p != NULL){
            printf("%02d  ", i);
            printf("→ %d (%d)", p->data.from, p->data.to);
            p = p->next;
        }
        putchar('\n');
    }
}

int InsertNode(Hash *h, Route x)
{
  Node *p = h->table[x.from];
  Node *tmp;
  while(p != NULL){
    if(p->data.to == x.to){
      //printf("登録済みです\n");
      return 1;
    }
    p = p->next;
  }
  
  if((tmp = (Node *)calloc(1, sizeof(Node))) == NULL){
    //printf("メモリ確保に失敗し,データを挿入できません\n");
    return -1;
  }

  //printf("完了\n");
  tmp->data = x;
  tmp->next = h->table[x.from];
  h->table[x.from] = tmp;
  return 0;
}

int find_to(Hash *h, int from, int to)
{
  Node *p = h->table[from];
  Node *q;

  //printf("test: %d %d\n", from, to);
  //printf("%d\n", p[from].data.from);
  
  while(p != NULL){
    int mid = p->data.to;
    //printf("%d\n", mid);
    q = h->table[mid];
    while(q != NULL){
      if(q->data.to == to){
	return 1;
      }
      q = q->next;
    }
    p = p->next;
  }
  return 0;
}


//解説を見たあとの回答
int main()
{
  Hash hash;
  int n, size, i;
  int from, to;
  Route data;
  
  scanf("%d %d", &n, &size);

  InitHash(&hash, SIZE);
  
  for(i = 0; i < size; i++){
    scanf("%d %d", &from, &to);
    data.from = from;
    data.to = to;
    InsertNode(&hash, data);
    data.from = to;
    data.to = from;
    InsertNode(&hash, data);
  }

  //DumpHash(&hash);
  
  if(find_to(&hash, 1, n)){
    PRINT(1);
  }else{
    PRINT(0);
  }

  TermHash(&hash);
  return 0;
}