output_description: If the assignment is possible, print `POSSIBLE`; otherwise, print
  `IMPOSSIBLE`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      p_1 p_2 ... p_N
attempt: # coding: utf-8
  from collections import defaultdict
  
  
  def II():
      return int(input())
  
  
  def ILI():
      return list(map(int, input().split()))
  
  
  def read():
      N = II()
      p = ILI()
      return N, p
  
  
  def solve(N, p):
      ans = None
      edges = defaultdict(list)
      for i in range(N):
          edges[p[i]].append(i + 1)
  
      nodes_has_branch = []
      for i in range(1, N + 1):
          if len(edges[i]) == 2:
              nodes_has_branch.append(i)
  
      if len(nodes_has_branch) == 0:
          if N % 2 == 0:
              ans = "POSSIBLE"
          else:
              ans = "IMPOSSIBLE"
      else:
          first_node = nodes_has_branch[0]
          edges_reverse = defaultdict(list)
          for fro, to in edges.items():
              for i in to:
                  edges_reverse[i].append(fro)
          circles = []
          next_node = edges_reverse[first_node]
          while True:
              if next_node[0] == first_node:
                  break
              circles.append(next_node[0])
              next_node = edges_reverse[next_node[0]]
  
          circles = [first_node] + list(reversed(circles))
  
          s_circles = set(circles)
          s_branch = set(range(1, N + 1)) - s_circles
  
          circles_depth = [0] * len(circles)
          for i, node in enumerate(circles):
              next_node = edges[node]
              if len(next_node) == 1:
                  continue
              else:
                  next_node = list((set(next_node) & s_branch))[0]
                  while True:
                      circles_depth[i] += 1
                      next_node = edges[next_node]
                      if len(next_node) == 0:
                          break
  
          if not 0 in circles_depth:
              ans = "IMPOSSIBLE"
          else:
              ans = "POSSIBLE"
  
      return ans
  
  
  def main():
      params = read()
      print(solve(*params))
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  There is a directed graph with N vertices and N edges. The vertices are
  numbered 1, 2, ..., N.
  
  The graph has the following N edges: (p_1, 1), (p_2, 2), ..., (p_N, N), and
  the graph is weakly connected. Here, an edge from Vertex u to Vertex v is
  denoted by (u, v), and a weakly connected graph is a graph which would be
  connected if each edge was bidirectional.
  
  We would like to assign a value to each of the vertices in this graph so that
  the following conditions are satisfied. Here, a_i is the value assigned to
  Vertex i.
  
    * Each a_i is a non-negative integer.
    * For each edge (i, j), a_i \neq a_j holds.
    * For each i and each integer x(0 ≤ x < a_i), there exists a vertex j such that the edge (i, j) exists and x = a_j holds.
  
  Determine whether there exists such an assignment.
samples: [{"input": "4\n    2 3 4 1", "output": "POSSIBLE\n    \n\nThe assignment is possible: {a_i} = {0, 1, 0, 1} or {a_i} = {1, 0, 1, 0}.\n\n* * *"}, {"input": "3\n    2 3 1", "output": "IMPOSSIBLE\n    \n\n* * *"}, {"input": "4\n    2 3 1 1", "output": "POSSIBLE\n    \n\nThe assignment is possible: {a_i} = {2, 0, 1, 0}.\n\n* * *"}, {"input": "6\n    4 5 6 5 6 4", "output": "IMPOSSIBLE"}]