using System;
using System.Collections.Generic;
using System.Linq;
using Debug = System.Diagnostics.Debug;
//using System.Numerics;
//using static System.Math;
using Number = System.Int64;

namespace Program {
    public class Solver {
        //const long MOD = (long)1e9 + 7;
        public void Solve() {
            var n = ri;
            var m = ri;
            var id = new HashMap<string, int>();
            for (int i = 0; i < n; i++)
                id[rs] = i;
            var g = new BridgeGraph(n);
            var f = new int[m];
            var t = new int[m];
            for (int i = 0; i < m; i++) {
                f[i] = id[rs]; t[i] = id[rs];
                g.AddEdge(f[i], t[i]);
            }
            g.Build();
            solve(f, t, g);
        }
        void solve(int[] ff, int[] tt, BridgeGraph g) {
            var n = g.Size;
            var G = Enumerate(n, x => new List<int>());
            for (int i = 0; i < ff.Length; i++)
                if (!g.IsSame(ff[i], tt[i])) {
                    G[g[ff[i]]].Add(g[tt[i]]);
                    G[g[tt[i]]].Add(g[ff[i]]);
                }
            var sz = Enumerate(n, x => g.Components[x].Count);

            Func<int, int, int[][]> dfs = null;
            dfs = (prev, cur) => {
                var sum = sz[cur];
                var ret = Enumerate(sum + 1, x => new int[sum + 1]);
                ret[sum][sum] = sum * sum;
                foreach (var t in G[cur]) {
                    if (prev == t) continue;
                    var res = dfs(cur, t);
                    sum += res.Length - 1;
                    var next = Enumerate(sum + 1, x => new int[sum + 1]);
                    for (int i = 0; i < ret.Length; i++)
                        for (int j = 0; j < ret.Length; j++)
                            for (int k = 0; k < res.Length; k++)
                                if (ret[i][j] != 0)
                                    for (int l = 0; l < res.Length; l++) {
                                        if (res[k][l] != 0) {
                                            next[i][j + l] = Math.Max(next[i][j + l], ret[i][j] + res[k][l] + i * l);
                                            next[i + k][j] = Math.Max(next[i + k][j], ret[i][j] + res[k][l] + j * k);
                                        }
                                    }
                    ret = next;
                }
                return ret;
            };
            var ans = dfs(-1, 0);
            var max = ans.SelectMany(x => x).Max();
            //foreach (var x in ans) Console.WriteLine(x.AsJoinedString("\t"));
            Console.WriteLine(max);
        }
        const long INF = 1L << 60;
        //int[] dx = { 1, 0, -1, 0 };
        //int[] dy = { 0, 1, 0, -1 };
        //*
        int ri { get { return sc.Integer(); } }
        long rl { get { return sc.Long(); } }
        double rd { get { return sc.Double(); } }
        string rs { get { return sc.Scan(); } }
        //*/

        public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());
        static T[] Enumerate<T>(int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; ++i) a[i] = f(i); return a; }
        static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
    }
}

#region main
static class Ex {
    static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
    static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
        return string.Join(st, ie.Select(x => x.ToString()).ToArray());
        //return string.Join(st, ie);
    }
    static public void Main() {
        Console.SetOut(new System.IO.StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false });
        var solver = new Program.Solver();
        solver.Solve();
        Console.Out.Flush();
    }
}
#endregion
#region Ex
namespace Program.IO {
    using System.Globalization;
    using System.IO;
    using System.Text;
    public class Printer: StreamWriter {
        public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
        public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
    }
    public class StreamScanner {
        public StreamScanner(Stream stream) { str = stream; }
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof = false;
        public bool IsEndOfStream { get { return isEof; } }
        private byte read() {
            if (isEof) return 0;
            if (ptr >= len) { ptr = 0; if ((len = str.Read(buf, 0, 1024)) <= 0) { isEof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while ((b < 33 || 126 < b) && !isEof); return (char)b; }

        public string Scan() {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
        public string ScanLine() {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n' && b != 0; b = (char)read())
                if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
        public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
        public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
        public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
}
#endregion
public class BridgeGraph {
    int n;
    List<int> E;
    List<int>[] g;

    int[] used;
    int[] val;
    int[] group;

    /// <summary>
    /// ???????????£???????????????????????????????????????
    /// </summary>
    public List<List<int>> Components = new List<List<int>>();
    public int Size { get { return Components.Count; } }
    public int this[int index] { get { return group[index]; } }


    /// <summary>
    /// ???????????£?????????????§£????????????????????°???????????????????????°??????????????£??????????????¨??????????????¨??????????????????????????£????????????????????????
    /// </summary>
    public BridgeGraph(int N) {
        n = N;
        g = new List<int>[n];
        for (int i = 0; i < n; i++)
            g[i] = new List<int>();
        E = new List<int>();
    }
    public void AddEdge(int f, int t) {
        var id = E.Count;
        g[f].Add(id);
        g[t].Add(id);
        E.Add(f ^ t);
    }
    /// <summary>
    /// ???????????£?????????????§£?????????
    /// </summary>
    /// <returns></returns>
    public void Build() {
        Decomposite();
        group = new int[n];
        for (int i = 0; i < Components.Count; i++)
            foreach (var x in Components[i]) group[x] = i;
    }
    /// <summary>
    /// ???????????£?????????????????°?????????
    /// </summary>
    public int Decomposite() {
        used = new int[n];
        val = new int[n];
        var ptr = 0;
        for (int i = 0; i < n; i++)
            if (used[i] == 0) dfs(-1, i, ref ptr);
        used = new int[n];
        ptr = 0;
        for (int i = 0; i < n; i++)
            if (used[i] == 0) efs(-1, i, null, ref ptr);
        return Components.Count;
    }

    void dfs(int eid, int cur, ref int ptr) {
        used[cur] = ++ptr;
        foreach (var id in g[cur]) {
            if (id == eid) continue;
            var t = E[id] ^ cur;
            if (used[t] != 0) {
                if (used[t] < used[cur]) {
                    val[cur]++;
                    val[t]--;
                }
            }
            else {
                dfs(id, t, ref ptr);
                val[cur] += val[t];
            }

        }

    }
    void efs(int eid, int cur, List<int> component, ref int ptr) {
        if (component == null) {
            component = new List<int>();
            Components.Add(component);
        }
        used[cur] = ++ptr;
        component.Add(cur);
        foreach (var id in g[cur]) {
            if (id == eid) continue;
            var t = E[id] ^ cur;
            if (used[t] != 0) continue;
            if (val[t] == 0) efs(id, t, null, ref ptr);
            else efs(id, t, component, ref ptr);
        }
    }
    public bool IsSame(int u, int v) { return group[u] == group[v]; }

}
#region HashMap<K,V>
public class HashMap<K, V>: Dictionary<K, V>
//where V : new()
{
    public HashMap() : base() { }
    public HashMap(int cap) : base(cap) { }
    new public V this[K i] {
        get {
            V v;
            return TryGetValue(i, out v) ? v :
                base[i] = default(V);
            //base[i] = new V();
        }
        set { base[i] = value; }
    }
}
#endregion


Measured memory_bytes: 10400