10
abdcced
bdacdac
ecb
dc
eaeeebdd
adcdbadcac
eb
aadecccde
edbaeacad
accd
 100
d
a
e
eb
c
d
d
e
c
e
ac
d
c
aa
a
e
da
e
e
c
e
a
c
c
bc
bd
d
da
cc
be
b
a
ee
d
be
be
e
b
a
ed
cb
ab
a
ea
ac
aa
ed
d
b
eb
e
ed
c
ce
c
d
c
d
d
ee
e
b
ea
ea
da
ab
ba
ed
da
ec
ea
bd
ee
dc
d
bd
d
c
cc
ab
bd
a
ad
e
d
e
bc
bb
c
bc
a
a
e
ca
ac
c
ad
c
be
d
 3
ab
acb
ba
 10
a
b
a
c
b
a
b
a
a
a
 5
cab
bbc
caa
ccc
aca
 3
ac
abc
ca
 5
ab
bc
cd
de
ffffffffff
 16
ddgcb
fgbhgbdg
gha
dh
ddfb
fggbc
edb
hd
d
hfgcabf
hdaef
fhbcdgba
chee
cafeggc
f
ecb
 50
agecd
cghafi
fiide
iecc
jbdcfjhgd
diee
hfeg
ehc
gfijgjh
gacaifebg
dicbbddc
hjgciaei
jjcdh
g
gc
cf
hfdjhd
c
icidbec
ji
eeh
cgeejggc
acfd
jjg
ajefdj
eghhebiic
bih
gbb
jjaa
idc
gafi
ecg
dbigbjiehj
cedif
ahidfaaajg
hfhhiccbgb
dgegjgieif
hgjebhfdc
j
ahehd
ahdah
bijbhh
a
dabiggfhac
dedigbjbf
ihbdj
iihagchd
gfebhfdi
jbjdcggdh
f

0
 35
 5
 6
 9
 5
 10
 7
 37

import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintWriter;
 import java.io.*;
 import java.util.*;
 import java.util.LinkedList;
 import java.math.*;
 import java.lang.*;
 import java.util.PriorityQueue;
 import static java.lang.Math.*;
 @SuppressWarnings("unchecked")
 public class Solution implements Runnable {
     static class InputReader {
         private InputStream stream;
         private byte[] buf = new byte[1024];
         private int curChar;
         private int numChars;
         private SpaceCharFilter filter;
         private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

         public InputReader(InputStream stream) {
             this.stream = stream;
         }

         public int read() {
             if (numChars==-1)
                 throw new InputMismatchException();

             if (curChar >= numChars) {
                 curChar = 0;
                 try {
                     numChars = stream.read(buf);
                 }
                 catch (IOException e) {
                     throw new InputMismatchException();
                 }

                 if(numChars <= 0)
                     return -1;
             }
             return buf[curChar++];
         }

         public String nextLine() {
             String str = "";
             try {
                 str = br.readLine();
             }
             catch (IOException e) {
                 e.printStackTrace();
             }
             return str;
         }
         public int nextInt() {
             int c = read();

             while(isSpaceChar(c))
                 c = read();

             int sgn = 1;

             if (c == '-') {
                 sgn = -1;
                 c = read();
             }

             int res = 0;
             do {
                 if(c<'0'||c>'9')
                     throw new InputMismatchException();
                 res *= 10;
                 res += c - '0';
                 c = read();
             }
             while (!isSpaceChar(c));

             return res * sgn;
         }

         public long nextLong() {
             int c = read();
             while (isSpaceChar(c))
                 c = read();
             int sgn = 1;
             if (c == '-') {
                 sgn = -1;
                 c = read();
             }
             long res = 0;

             do {
                 if (c < '0' || c > '9')
                     throw new InputMismatchException();
                 res *= 10;
                 res += c - '0';
                 c = read();
             }
             while (!isSpaceChar(c));
                 return res * sgn;
         }

         public double nextDouble() {
             int c = read();
             while (isSpaceChar(c))
                 c = read();
             int sgn = 1;
             if (c == '-') {
                 sgn = -1;
                 c = read();
             }
             double res = 0;
             while (!isSpaceChar(c) && c != '.') {
                 if (c == 'e' || c == 'E')
                     return res * Math.pow(10, nextInt());
                 if (c < '0' || c > '9')
                     throw new InputMismatchException();
                 res *= 10;
                 res += c - '0';
                 c = read();
             }
             if (c == '.') {
                 c = read();
                 double m = 1;
                 while (!isSpaceChar(c)) {
                     if (c == 'e' || c == 'E')
                         return res * Math.pow(10, nextInt());
                     if (c < '0' || c > '9')
                         throw new InputMismatchException();
                     m /= 10;
                     res += (c - '0') * m;
                     c = read();
                 }
             }
             return res * sgn;
         }

         public String readString() {
             int c = read();
             while (isSpaceChar(c))
                 c = read();
             StringBuilder res = new StringBuilder();
             do {
                 res.appendCodePoint(c);
                 c = read();
             }
             while (!isSpaceChar(c));

             return res.toString();
         }

         public boolean isSpaceChar(int c) {
             if (filter != null)
                 return filter.isSpaceChar(c);
             return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
         }

         public String next() {
             return readString();
         }

         public interface SpaceCharFilter {
             public boolean isSpaceChar(int ch);
         }
     }
     public static long min(long a,long b)
     {
         if(a>b)
         {
             return b;
         }
         return a;
     }
     public static int min(int a,int b)
     {
         if(a>b)
         {
             return b;
         }
         return a;
     }
     public static long max(long a,long b)
     {
         if(a>b)
         {
             return a;
         }
         return b;
     }
     public static int max(int a,int b)
     {
         if(a>b)
         {
             return a;
         }
         return b;
     }
     static class pair implements Comparable<pair>
     {
       int x;
       int y;
       pair(int x,int y)
       {
         this.x = x;
         this.y = y;
       }
       public int compareTo(pair p)
       {
         return this.x-p.x;
       }
     }
     public static int gcd(int a,int b)
     {
         if(a==0)
         return b;
         if(b==0)
         return a;
         while((a%=b)!=0&&(b%=a)!=0);
         return a^b;
     }
     public static int mod(int a)
     {
       if(a>0)
         return a;
       return -a;
     }
     static int mod = (int)1e9+7;
     public static long expo(long exp,long pow)
     {
       long ans = 1;
       while(pow!=0)
       {
         if((pow&1)==1)
         {
           ans = (ans*exp)%mod;
         }
         exp = (exp*exp)%mod;
         pow = pow>>1;
       }
       return ans;
     }
     static int max = (int)1e5;
     public static long fact(int num)
     {
         if(num==0)
         {
           return 1;
         }
         return (fact(num-1)*num)%mod;
     }
     static int[] sieve;
     public static void sieve()
     {
       sieve = new int[max];
       for(int i=1;i<max;i++)
       {
         sieve[i] = i;
       }
       for(int i=2;i<max;i++)
       {
         if(sieve[i]==i)
         {
           for(int j=i*2;j<max;j+=i)
           {
             if(sieve[j]==j)
             {
               sieve[j] = i;
             }
           }
         }
       }
     }
     public static int lcm(int a,int b)
     {
       return a*b/gcd(a,b);
     }
     public static int bsearch(pair[] p,int x)
     {
       int l = 0;
       int r = p.length-1;
       while(r>l)
       {
         int mid = (l+r)/2;
         if(p[mid].y<=x)
         {
           l = mid+1;
         }
         else if(p[mid].x>x)
         {
           r = mid;
         }
         else
         {
           return 0;
         }
       }
       if(x>=p[r].x&&x<p[r].y)
       {
         return 0;
       }
       return p[r].x-x;
     }
     public static void main(String args[]) throws Exception {
         new Thread(null, new Solution(),"Main",1<<26).start();
     }
     public void run() {
       InputReader sc  = new InputReader(System.in);
       PrintWriter out = new PrintWriter(System.out);
       int t1 = 1;
       while(t1-->0)
       {
         int n = sc.nextInt();
         String[] s = new String[n];
         for(int i=0;i<n;i++)
         {
           s[i] = sc.readString();
         }
         int[][] mat = new int[26][26];
         for(int i=n-1;i>=0;i--)
         {
           char first = s[i].charAt(0);
           char last = s[i].charAt(s[i].length()-1);
           for(int j=0;j<26;j++)
           {
             if(mat[last-'a'][j]!=0)
             mat[first-'a'][j] = max(mat[first-'a'][j],s[i].length()+mat[last-'a'][j]);
           }
           mat[first-'a'][last-'a'] = max(mat[first-'a'][last-'a'],s[i].length());
         }
         int ans = 0;
         for(int i=0;i<26;i++)
         {
           ans = max(ans,mat[i][i]);
         }
         out.println(ans);
       }
      out.close();
   }
 }
