import java.io.*;
import java.util.*;

public class Main implements Runnable {

    public void _main() throws IOException {
        int n = nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        List[] graph = new List[n];
        for (int i = 0; i < n; i++)
            graph[i] = new ArrayList<Integer>();
        for (int i = 0; i < n - 1; i++) {
            a[i] = nextInt() - 1;
            b[i] = nextInt() - 1;
            graph[a[i]].add(b[i]);
            graph[b[i]].add(a[i]);
        }
        int res = 0;
        for (int i = 0; i < n; i++) {
            int[] dist = new int[n];
            int[] prev = new int[n];
            List<Integer> dummy = new ArrayList<Integer>();
            bfs(n, graph, i, dist, prev, dummy);
            for (int j = 0; j < n; j++) {
                if (i == j) continue;
                List[] edges = new List[n];
                for (int k = 0; k < n; k++)
                    edges[k] = new ArrayList<Integer>();
                boolean[] dead = new boolean[n];
                dead[i] = true;
                for (int k = j; k != i; k = prev[k])
                    dead[k] = true;
                for (int k = 0; k < n; k++)
                    if (!dead[a[k]] && !dead[b[k]]) {
                        edges[a[k]].add(b[k]);
                        edges[b[k]].add(a[k]);
                    }
                res = Math.max(res, (dist[j] - 1) * diameter(n, edges));
            }
        }
        out.print(res);
    }

    void bfs(int n, List[] graph, int start, int[] dist, int[] prev, List<Integer> comp) {
        dist[start] = 1;
        int[] q = new int[n];
        q[0] = start;
        int qt = 0, qh = 1;
        while (qt < qh) {
            int v = q[qt++];
            comp.add(v);
            for (int i = 0; i < graph[v].size(); i++) {
                int u = (Integer)graph[v].get(i);
                if (dist[u] == 0) {
                    dist[u] = 1 + dist[v];
                    prev[u] = v;
                    q[qh++] = u;
                }
            }
        }
    }

    int diameter(int n, List[] graph) { //the largest diameter of a connected component
        boolean[] was = new boolean[n];
        int[] dist = new int[n];
        int[] prev = new int[n];
        int res = 0;
        for (int i = 0; i < n; i++)
            if (dist[i] == 0) {
                List<Integer> comp = new ArrayList<Integer>();
                bfs(n, graph, i, dist, prev, comp);
                int best = 0;
                int bestAt = -1;
                for (int x : comp) {
                    if (dist[x] > best) {
                        best = dist[x];
                        bestAt = x;
                    }
                    dist[x] = 0;
                    prev[x] = 0;
                }
                comp = new ArrayList<Integer>();
                bfs(n, graph, bestAt, dist, prev, comp);
                for (int x : comp)
                    res = Math.max(res, dist[x] - 1);
            }
        return res;
    }


    private BufferedReader in;
    private PrintWriter out;
    private StringTokenizer st;

    private String next() throws IOException {
        while (st == null || !st.hasMoreTokens())
            st = new StringTokenizer(in.readLine());
        return st.nextToken();
    }

    private int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    private long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    public static void main(String[] args) {
        new Thread(new Main()).start();
    }

    public void run() {
        try {
            in = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);

            _main();

            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(202);
        }
    }

}