import java.util.*;

/**
 * Count the spaces and tabs on each line and keep track of depth.
 * We get n equations of the form:
 *  depth[i] * indent = spaces[i] + tabs[i] * tabWidth
 * Try solving each pair of them for tabWidth and indent. If any pair
 * is inconsistent return -1. If all pairs have infinite solutions, then
 * try tabWidth=1. If any pair has a unique non-integer or non-positive 
 * solution, then return -1. After finding a solution for tabWidth, indent
 * for one pair of equations, check the solution against all other solutions.
 *
 * @author Finn Lidbetter
 */

public class space_alignment_finn {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();
        int[] depth = new int[n];
        int[] spaces = new int[n];
        int[] tabs = new int[n];
        int currDepth = -1;
        for (int i=0; i<n; i++) {
            char[] seq = sc.nextLine().toCharArray();
            int currSpaces = 0;
            int currTabs = 0;
            for (int j=0; j<seq.length - 1; j++) {
                if (seq[j] == 's') {
                    currSpaces++;
                }
                if (seq[j] == 't') {
                    currTabs++;
                }
            }
            if (seq[seq.length - 1] == '{') {
                currDepth++;
            }

            spaces[i] = currSpaces;
            tabs[i] = currTabs;
            depth[i] = currDepth;
            
            if (seq[seq.length - 1] == '}') {
                currDepth--;
            }
        }
        int indent = -1;
        int tabWidth = -1;
        boolean consistent = true;
        for (int i=0; i<n; i++) {
            for (int j=i+1; j<n; j++) {
                int d1 = depth[i];
                int d2 = depth[j];
                int a1 = spaces[i];
                int a2 = spaces[j];
                int b1 = tabs[i];
                int b2 = tabs[j];

                if (d1 == 0 || d2 == 0) {
                    continue;
                }
                
                if (d1*b2 == d2*b1) {
                    if (d1*a2 == d2*a1) {
                        continue;
                    } else {
                        consistent = false;
                        break;
                    }
                }
                tabWidth = (d2*a1 - d1*a2)/(d1*b2 - d2*b1);
                if (tabWidth * (d1*b2 - d2*b1) != d2*a1 - d1*a2 || tabWidth <= 0) {
                    // tabWidth is not an integer or nonpositive.
                    consistent = false;
                    break;
                }
                indent = (a1 + b1 * tabWidth) / d1;
            }
            if (!consistent) {
                break;
            }
        }
        if (!consistent) {
            System.out.println(-1);
            return;
        }
        if (tabWidth == -1) {
            tabWidth = 1;
            for (int i=0; i<n; i++) {
                if (depth[i] > 0) {
                    int a = spaces[i];
                    int b = tabs[i];
                    int d = depth[i];
                    indent = (a + b * tabWidth) / d;
                    break;
                }
            }
        }
        for (int i=0; i<n; i++) {
            if (depth[i] * indent != spaces[i] + tabs[i] * tabWidth) {
                System.out.println(-1);
                return;
            }
        }
        System.out.println(tabWidth);

    }
}