output_description: Print the length of the longest even string that can be obtained.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      S
attempt: import sys
  
  
  ## io ##
  def IS():
      return sys.stdin.readline().rstrip()
  
  
  def II():
      return int(IS())
  
  
  def MII():
      return list(map(int, IS().split()))
  
  
  def MIIZ():
      return list(map(lambda x: x - 1, MII()))
  
  
  ## dp ##
  def DD2(d1, d2, init=0):
      return [[init] * d2 for _ in range(d1)]
  
  
  def DD3(d1, d2, d3, init=0):
      return [DD2(d2, d3, init) for _ in range(d1)]
  
  
  ## math ##
  def to_bin(x: int) -> str:
      return format(x, "b")  # rev => int(res, 2)
  
  
  def to_oct(x: int) -> str:
      return format(x, "o")  # rev => int(res, 8)
  
  
  def to_hex(x: int) -> str:
      return format(x, "x")  # rev => int(res, 16)
  
  
  MOD = 10**9 + 7
  
  
  def divc(x, y) -> int:
      return -(-x // y)
  
  
  def divf(x, y) -> int:
      return x // y
  
  
  def gcd(x, y):
      while y:
          x, y = y, x % y
      return x
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def enumerate_divs(n):
      """Return a tuple list of divisor of n"""
      return [(i, n // i) for i in range(1, int(n**0.5) + 1) if n % i == 0]
  
  
  def get_primes(MAX_NUM=10**3):
      """Return a list of prime numbers n or less"""
      is_prime = [True] * (MAX_NUM + 1)
      is_prime[0] = is_prime[1] = False
      for i in range(2, int(MAX_NUM**0.5) + 1):
          if not is_prime[i]:
              continue
          for j in range(i * 2, MAX_NUM + 1, i):
              is_prime[j] = False
      return [i for i in range(MAX_NUM + 1) if is_prime[i]]
  
  
  ## libs ##
  from itertools import (
      accumulate as acc,
      combinations as combi,
      product,
      combinations_with_replacement as combi_dup,
  )
  from collections import deque, Counter
  from heapq import heapify, heappop, heappush
  from bisect import bisect_left
  
  # ======================================================#
  
  
  def main():
      s = IS()
      n = len(s)
      for i in range(2, n, 2):
          si = s[: n - i]
          sl = si[: (n - i) // 2]
          sr = si[(n - i) // 2 :]
          if sl == sr:
              print(n - i)
              return None
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  We will call a string that can be obtained by concatenating two equal strings
  an _even_ string. For example, `xyzxyz` and `aaaaaa` are even, while `ababab`
  and `xyzxy` are not.
  
  You are given an even string S consisting of lowercase English letters. Find
  the length of the longest even string that can be obtained by deleting one or
  more characters from the end of S. It is guaranteed that such a non-empty
  string exists for a given input.
samples: [{"input": "abaababaab", "output": "6\n    \n\n  * `abaababaab` itself is even, but we need to delete at least one character.\n  * `abaababaa` is not even.\n  * `abaababa` is not even.\n  * `abaabab` is not even.\n  * `abaaba` is even. Thus, we should print its length, 6.\n\n* * *"}, {"input": "xxxx", "output": "2\n    \n\n  * `xxx` is not even.\n  * `xx` is even.\n\n* * *"}, {"input": "abcabcabcabc", "output": "6\n    \n\nThe longest even string that can be obtained is `abcabc`, whose length is 6.\n\n* * *"}, {"input": "akasakaakasakasakaakas", "output": "14\n    \n\nThe longest even string that can be obtained is `akasakaakasaka`, whose length\nis 14."}]