output_description: 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.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      w
attempt: import sys
  
  readline = sys.stdin.readline
  
  
  class Rollinhash:
      def __init__(self, S):
          N = len(S)
          self.mod = 10**9 + 9
          self.base = 2009
          self.has = [0] * (N + 1)
          self.power = [1] * (N + 1)
          for i in range(N):
              s = S[i]
              self.has[i + 1] = (self.has[i] * self.base + s) % self.mod
              self.power[i + 1] = self.power[i] * self.base % self.mod
  
      def rh(self, i, j):
          return (self.has[j] - self.has[i] * self.power[j - i]) % self.mod
  
  
  MOD = 10**9 + 7
  
  S = list(map(ord, readline().strip()))
  N = len(S)
  if len(set(S)) == 1:
      print(N)
      print(1)
  else:
      Rs = Rollinhash(S)
  
      tabler = [True] * (N + 1)
      for d in range(2, 1 + N // 2):
          r = Rs.rh(0, d)
          for i in range(1, N // d):
              if r != Rs.rh(i * d, (i + 1) * d):
                  break
              tabler[(i + 1) * d] = False
      tablel = [True] * (N + 1)
      for d in range(2, 1 + N // 2):
          r = Rs.rh(N - d, N)
          for i in range(1, N // d):
              if r != Rs.rh(N - (i + 1) * d, N - i * d):
                  break
              tablel[N - (i + 1) * d] = False
  
      if tabler[N]:
          print(1)
          print(1)
      else:
          print(2)
          ans = 0
          for i in range(N + 1):
              if tabler[i] and tablel[i]:
                  ans += 1
          print(ans)
  
problem_description: Statement
  
  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.)
samples: [{"input": "aab", "output": "1\n    1\n    \n\n* * *"}, {"input": "bcbc", "output": "2\n    3\n    \n\n  * In this case, there are 3 best representations of 2 elements:\n    * (`b`,`cbc`)\n    * (`bc`,`bc`)\n    * (`bcb`,`c`)\n\n* * *"}, {"input": "ddd", "output": "3\n    1"}]