Let x be a string of length at least 1.
We will call x a good string, if for any string y and any integer k (k \geq 2), the string obtained by concatenating k copies of y is different from x.
For example, a, bbc and cdcdc are good strings, while aa, bbbb and cdcdcd are not.
Let w be a string of length at least 1.
For a sequence F=(\,f_1,\,f_2,\,...,\,f_m) consisting of m elements,
we will call F a good representation of w, if the following conditions are both satisfied:
 - For any i \, (1 \leq i \leq m), f_i is a good string.
 - The string obtained by concatenating f_1,\,f_2,\,...,\,f_m in this order, is w.
For example, when w=aabb, there are five good representations of w:
 - (aabb)
 - (a,abb)
 - (aab,b)
 - (a,ab,b)
 - (a,a,b,b)
Among the good representations of w, the ones with the smallest number of elements are called the best representations of w.
For example, there are only one best representation of w=aabb: (aabb).
You are given a string w. Find the following:
 - the number of elements of a best representation of w
 - the number of the best representations of w, modulo 1000000007 \, (=10^9+7)
(It is guaranteed that a good representation of w always exists.)

-----Constraints-----
 - 1 \leq |w| \leq 500000 \, (=5 \times 10^5)
 - w consists of lowercase letters (a-z).

-----Partial Score-----
 - 400 points will be awarded for passing the test set satisfying 1 \leq |w| \leq 4000.

-----Input-----
The input is given from Standard Input in the following format:
w

-----Output-----
Print 2 lines.
 - In the first line, print the number of elements of a best representation of w.
 - In the second line, print the number of the best representations of w, modulo 1000000007.

-----Sample Input-----
aab

-----Sample Output-----
1
1

```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 = "import sys\nreadline = sys.stdin.readline\n\nclass Rollinhash:\n    def __init__(self, S):\n        N = len(S)\n        self.mod = 10**9+9\n        self.base = 2009          \n        self.has = [0]*(N+1)\n        self.power = [1]*(N+1)\n        for i in range(N):\n            s = S[i]\n            self.has[i+1] = (self.has[i]*self.base + s)%self.mod\n            self.power[i+1] = self.power[i]*self.base%self.mod\n \n    def rh(self, i, j):\n        return (self.has[j] - self.has[i]*self.power[j-i])%self.mod\n\nMOD = 10**9+7\n \nS = list(map(ord, readline().strip()))\nN = len(S)\nif len(set(S)) == 1:\n    print(N)\n    print((1))\nelse:\n    Rs = Rollinhash(S)\n    \n    tabler = [True]*(N+1)\n    for d in range(1, 1+N//2):\n        r = Rs.rh(0, d)\n        for i in range(1, N//d):\n            if r != Rs.rh(i*d, (i+1)*d):\n                break\n            tabler[(i+1)*d] = False\n    tablel = [True]*(N+1)\n    for d in range(1, 1+N//2):\n        r = Rs.rh(N-d, N)\n        for i in range(1, N//d):\n            if r != Rs.rh(N-(i+1)*d, N-i*d):\n                break\n            tablel[N-(i+1)*d] = False\n    \n    if tabler[N]:\n        print((1))\n        print((1))\n    else:\n        print((2))\n        ans = 0\n        for i in range(N+1):\n            if tabler[i] and tablel[i]:\n                ans += 1\n        assert ans > 0, ''\n        print(ans)\n"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 16829