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: import math
  from collections import deque
  from collections import defaultdict
  
  
  # 自作関数群
  def readInt():
      return int(input())
  
  
  def readInts():
      return list(map(int, input().split()))
  
  
  def readChar():
      return input()
  
  
  def readChars():
      return input().split()
  
  
  def factorization(n):
      res = []
      if n % 2 == 0:
          res.append(2)
      for i in range(3, math.floor(n // 2) + 1, 2):
          if n % i == 0:
              c = 0
              for j in res:
                  if i % j == 0:
                      c = 1
              if c == 0:
                  res.append(i)
      return res
  
  
  def fact2(n):
      p = factorization(n)
      res = []
      for i in p:
          c = 0
          z = n
          while 1:
              if z % i == 0:
                  c += 1
                  z /= i
              else:
                  break
          res.append([i, c])
      return res
  
  
  def fact(n):  # 階乗
      ans = 1
      m = n
      for _i in range(n - 1):
          ans *= m
          m -= 1
      return ans
  
  
  def comb(n, r):  # コンビネーション
      if n < r:
          return 0
      l = min(r, n - r)
      m = n
      u = 1
      for _i in range(l):
          u *= m
          m -= 1
      return u // fact(l)
  
  
  def combmod(n, r, mod):
      return (fact(n) / fact(n - r) * pow(fact(r), mod - 2, mod)) % mod
  
  
  def printQueue(q):
      r = copyQueue(q)
      ans = [0] * r.qsize()
      for i in range(r.qsize() - 1, -1, -1):
          ans[i] = r.get()
      print(ans)
  
  
  class UnionFind:
      def __init__(self, n):
          self.n = n
          self.parents = [-1] * n
  
      def find(self, x):  # root
          if self.parents[x] < 0:
              return x
          else:
              self.parents[x] = self.find(self.parents[x])
              return self.parents[x]
  
      def union(self, x, y):
          x = self.find(x)
          y = self.find(y)
  
          if x == y:
              return
  
          if self.parents[x] > self.parents[y]:
              x, y = y, x
  
          self.parents[x] += self.parents[y]
          self.parents[y] = x
  
      def size(self, x):
          return -1 * self.parents[self.find(x)]
  
      def same(self, x, y):
          return self.find(x) == self.find(y)
  
      def members(self, x):  # much time
          root = self.find(x)
          return [i for i in range(self.n) if self.find(i) == root]
  
      def roots(self):
          return [i for i, x in enumerate(self.parents) if x < 0]
  
      def group_count(self):
          return len(self.roots())
  
      def all_group_members(self):
          return {r: self.members(r) for r in self.roots()}  # 1~n
  
  
  def bitArr(n):  # ビット全探索
      x = 1
      zero = "0" * n
      ans = []
      ans.append([0] * n)
      for i in range(2**n - 1):
          ans.append(list(map(lambda x: int(x), list((zero + bin(x)[2:])[-1 * n :]))))
          x += 1
      return ans
  
  
  def arrsSum(a1, a2):
      for i in range(len(a1)):
          a1[i] += a2[i]
      return a1
  
  
  def maxValue(a, b, v):
      v2 = v
      for i in range(v2, -1, -1):
          for j in range(v2 // a + 1):  # j:aの個数
              k = i - a * j
              if k % b == 0:
                  return i
      return -1
  
  
  def copyQueue(q):
      nq = queue.Queue()
      n = q.qsize()
      for i in range(n):
          x = q.get()
          q.put(x)
          nq.put(x)
      return nq
  
  
  def get_sieve_of_eratosthenes(n):
      # data = [2]
      data = [0, 0, 0]
      for i in range(3, n + 1, 2):
          data.append(i)
          data.append(0)
      for i in range(len(data)):
          interval = data[i]
          if interval != 0:
              for j in range(i + interval, n - 1, interval):
                  data[j] = 0
      # ans = [x for x in data if x!=0]
      ans = data[:]
      return ans
  
  
  n = readInt()
  d = defaultdict(int)
  p = "0"
  for i in range(n):
      x = input()
      if p[-1] != x[0]:
          print("No")
          exit()
      d[x] += 1
      p = x
  
  for i in d:
      if d[i] > 1:
          print("No")
          exit()
  
  print("Yes")
  
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"}]