A tree is an undirected connected graph without cycles.

Let's consider a rooted undirected tree with n vertices, numbered 1 through n. There are many ways to represent such a tree. One way is to create an array with n integers p_1, p_2, ..., p_{n}, where p_{i} denotes a parent of vertex i (here, for convenience a root is considered its own parent). [Image] For this rooted tree the array p is [2, 3, 3, 2]. 

Given a sequence p_1, p_2, ..., p_{n}, one is able to restore a tree:  There must be exactly one index r that p_{r} = r. A vertex r is a root of the tree.  For all other n - 1 vertices i, there is an edge between vertex i and vertex p_{i}. 

A sequence p_1, p_2, ..., p_{n} is called valid if the described procedure generates some (any) rooted tree. For example, for n = 3 sequences (1,2,2), (2,3,1) and (2,1,3) are not valid.

You are given a sequence a_1, a_2, ..., a_{n}, not necessarily valid. Your task is to change the minimum number of elements, in order to get a valid sequence. Print the minimum number of changes and an example of a valid sequence after that number of changes. If there are many valid sequences achievable in the minimum number of changes, print any of them.


-----Input-----

The first line of the input contains an integer n (2 ≤ n ≤ 200 000) — the number of vertices in the tree.

The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ n).


-----Output-----

In the first line print the minimum number of elements to change, in order to get a valid sequence.

In the second line, print any valid sequence possible to get from (a_1, a_2, ..., a_{n}) in the minimum number of changes. If there are many such sequences, any of them will be accepted.


-----Examples-----
Input
4
2 3 3 4

Output
1
2 3 4 4 

Input
5
3 2 2 5 3

Output
0
3 2 2 5 3 

Input
8
2 3 5 4 1 6 6 7

Output
2
2 3 7 8 1 6 6 7



-----Note-----

In the first sample, it's enough to change one element. In the provided output, a sequence represents a tree rooted in a vertex 4 (because p_4 = 4), which you can see on the left drawing below. One of other correct solutions would be a sequence 2 3 3 2, representing a tree rooted in vertex 3 (right drawing below). On both drawings, roots are painted red. [Image] 

In the second sample, the given sequence is already valid.

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = 'from collections import deque\n\n\n# ver si hay un camino que llega a el a partir\n# de su padre entonces hay un ciclo\n\n\ndef Padre(x, padre):\n    while x != padre[x]:\n        x = padre[x]\n    return x\n\n\ndef DFS(x, color, padre, ciclos, adyacentes, raiz):\n    color[x] = 1  # nodo gris\n    for y in adyacentes[x]:\n        # el adyacente es blanco\n        if color[y] == 0:\n            DFS(y, color, padre, ciclos, adyacentes, raiz)\n            padre[y] = x\n\n        elif color[y] == 2:\n            padre[y] = x\n        # ese adyacente es gris entonces <u,v>  rista de retroceso\n        else:\n            if y == x and not raiz:\n                raiz = x\n            else:\n                ciclos.append([x, y])\n    color[x] = 2  # nodo negro\n\n\ndef Solucion():\n    n = int(input())\n    A = list(map(lambda x: int(x)-1, input().split()))\n\n    padre = [x for x in range(0, n)]\n    ciclosC = 0\n    ciclos = deque([])\n    root = []\n\n    # ir haciendo Merge a cada arista\n    for i in range(0, n):\n\n        p = Padre(A[i], padre)\n        # Si dicha arista perticipa en un ciclo\n        if p == i:\n            # Si es un ciclo del tipo raiz y no hay raiz\n            if not root and (i == A[i]):\n                root = [i, A[i]]\n            else:\n                ciclos.append([i, A[i]])\n                ciclosC += 1\n        # Si no hay ciclo\n        else:\n            padre[i] = A[i]\n\n    print(str(ciclosC))\n    # si existe al menos un ciclo diferente d raiz\n    if ciclosC:\n        i = 0\n        # si no hay raiz el primer ciclo lo hago raiz\n        if not root:\n            root = ciclos.popleft()\n            i = 1\n\n        # los restantes ciclos hago que su padre sea la raiz\n        while ciclos:\n            ciclo = ciclos.popleft()\n            padre[ciclo[0]] = root[0]\n\n    PC = [x + 1 for x in padre]\n    print(*PC, sep=" ")\n\n\nSolucion()\n\n\n# Casos de prueba:\n# 4\n# 2 3 3 4\n# respuesta\n# 1\n#  2 3 3 3\n\n# 5\n# 3 2 2 5 3\n# respuesta\n# 0\n# 3 2 2 5 3\n\n# 8\n# 2 3 5 4 1 6 6 7\n# respuesta\n# 2\n# 2 3 5 4 1 4 6 7\n\n# 200000\n# hacer con el generador\n'
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14751