output_description: If every word announced by Takahashi satisfied the conditions, print `Yes`;
  otherwise, print `No`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      W_1
      W_2
      :
      W_N
attempt: #!/usr/bin/env python3
  from collections import defaultdict
  from collections import deque
  from heapq import heappush, heappop
  import sys
  import math
  import bisect
  import random
  import itertools
  
  sys.setrecursionlimit(10**5)
  stdin = sys.stdin
  bisect_left = bisect.bisect_left
  bisect_right = bisect.bisect_right
  
  
  def LI():
      return list(map(int, stdin.readline().split()))
  
  
  def LF():
      return list(map(float, stdin.readline().split()))
  
  
  def LI_():
      return list(map(lambda x: int(x) - 1, stdin.readline().split()))
  
  
  def II():
      return int(stdin.readline())
  
  
  def IF():
      return float(stdin.readline())
  
  
  def LS():
      return list(map(list, stdin.readline().split()))
  
  
  def S():
      return list(stdin.readline().rstrip())
  
  
  def IR(n):
      return [II() for _ in range(n)]
  
  
  def LIR(n):
      return [LI() for _ in range(n)]
  
  
  def FR(n):
      return [IF() for _ in range(n)]
  
  
  def LFR(n):
      return [LI() for _ in range(n)]
  
  
  def LIR_(n):
      return [LI_() for _ in range(n)]
  
  
  def SR(n):
      return [S() for _ in range(n)]
  
  
  def LSR(n):
      return [LS() for _ in range(n)]
  
  
  mod = 1000000007
  inf = float("INF")
  
  
  # A
  def A():
      a, b = LI()
      if (a * b) % 2:
          print("Yes")
      else:
          print("No")
      return
  
  
  # B
  def B():
      n = II()
      w = SR(n)
      d = []
      for i in w:
          d.append("".join(i))
      if len(set(d)) != n:
          print("No")
          return
      for i in range(n - 1):
          if w[i][-1] != w[i + 1][0]:
              print("No")
              return
      print("Yes")
      return
  
  
  # C
  def C():
      return
  
  
  # D
  def D():
      return
  
  
  # Solve
  if __name__ == "__main__":
      B()
  
problem_description: Statement
  
  Takahashi is practicing _shiritori_ alone again today.
  
  Shiritori is a game as follows:
  
    * In the first turn, a player announces any one word.
    * In the subsequent turns, a player announces a word that satisfies the following conditions:
      * That word is not announced before.
      * The first character of that word is the same as the last character of the last word announced.
  
  In this game, he is practicing to announce as many words as possible in ten
  seconds.
  
  You are given the number of words Takahashi announced, N, and the i-th word he
  announced, W_i, for each i. Determine if the rules of shiritori was observed,
  that is, every word announced by him satisfied the conditions.
samples: [{"input": "4\n    hoge\n    english\n    hoge\n    enigma", "output": "No\n    \n\nAs `hoge` is announced multiple times, the rules of shiritori was not\nobserved.\n\n* * *"}, {"input": "9\n    basic\n    c\n    cpp\n    php\n    python\n    nadesico\n    ocaml\n    lua\n    assembly", "output": "Yes\n    \n\n* * *"}, {"input": "8\n    a\n    aa\n    aaa\n    aaaa\n    aaaaa\n    aaaaaa\n    aaa\n    aaaaaaa", "output": "No\n    \n\n* * *"}, {"input": "3\n    abc\n    arc\n    agc", "output": "No"}]