Problem: A widely known among some people Belarusian sport programmer Lesha decided to make some money to buy a one square meter larger flat. To do this, he wants to make and carry out a Super Rated Match (SRM) on the site Torcoder.com. But there's a problem — a severe torcoder coordinator Ivan does not accept any Lesha's problem, calling each of them an offensive word "duped" (that is, duplicated). And one day they nearely quarrelled over yet another problem Ivan wouldn't accept.

You are invited to act as a fair judge and determine whether the problem is indeed brand new, or Ivan is right and the problem bears some resemblance to those used in the previous SRMs.

You are given the descriptions of Lesha's problem and each of Torcoder.com archive problems. The description of each problem is a sequence of words. Besides, it is guaranteed that Lesha's problem has no repeated words, while the description of an archive problem may contain any number of repeated words.

The "similarity" between Lesha's problem and some archive problem can be found as follows. Among all permutations of words in Lesha's problem we choose the one that occurs in the archive problem as a subsequence. If there are multiple such permutations, we choose the one with the smallest number of inversions. Then the "similarity" of a problem can be written as <image>, where n is the number of words in Lesha's problem and x is the number of inversions in the chosen permutation. Note that the "similarity" p is always a positive integer.

The problem is called brand new if there is not a single problem in Ivan's archive which contains a permutation of words from Lesha's problem as a subsequence.

Help the boys and determine whether the proposed problem is new, or specify the problem from the archive which resembles Lesha's problem the most, otherwise.

Input

The first line contains a single integer n (1 ≤ n ≤ 15) — the number of words in Lesha's problem. The second line contains n space-separated words — the short description of the problem.

The third line contains a single integer m (1 ≤ m ≤ 10) — the number of problems in the Torcoder.com archive. Next m lines contain the descriptions of the problems as "k s1 s2 ... sk", where k (1 ≤ k ≤ 500000) is the number of words in the problem and si is a word of the problem description.

All words from all problem descriptions contain no more than 10 lowercase English letters. It is guaranteed that the total length of words in all problem descriptions does not exceed 500015.

Output

If Lesha's problem is brand new, print string "Brand new problem!" (without quotes). 

Otherwise, on the first line print the index of the archive problem which resembles Lesha's problem most. If there are multiple such problems, print the one with the smallest index. On the second line print a string consisting of characters [:, character | repeated p times, and characters :], where p is the "similarity" between this problem and Lesha's one. The archive problems are numbered starting from one in the order in which they are given in the input.

Examples

Input

4
find the next palindrome
1
10 find the previous palindrome or print better luck next time


Output

1
[:||||||:]


Input

3
add two numbers
3
1 add
2 two two
3 numbers numbers numbers


Output

Brand new problem!


Input

4
these papers are formulas
3
6 what are these formulas and papers
5 papers are driving me crazy
4 crazy into the night


Output

1
[:||||:]


Input

3
add two decimals
5
4 please two decimals add
5 decimals want to be added
4 two add decimals add
4 add one two three
7 one plus two plus three equals six


Output

3
[:|||:]

Note

Let us remind you that the number of inversions is the number of pairs of words that follow in the permutation not in their original order. Thus, for example, if the original problem is "add two numbers", then permutation "numbers add two" contains two inversions — pairs of words "numbers" and "add", "numbers" and "two". 

Sequence b1, b2, ..., bk is a subsequence of sequence a1, a2, ..., an if there exists such a set of indices 1 ≤ i1 < i2 < ... < ik ≤ n that aij = bj (in other words, if sequence b can be obtained from a by deleting some of its elements).

In the first test case the first problem contains the "find the palindrome next" permutation as a subsequence, in which the number of inversions equals 1 (words "palindrome" and "next").

In the second test case there is no problem that contains a permutation of words from Lesha's problem as a subsequence.

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.*;

public class P202B {

  private static void solve() {
    int n = nextInt();

    int[][][] order = {
        {
            { 1 }
        },
        {
            { 1, 2 },
            { 2, 1 }
        },

        {
            { 1, 2, 3 },
            { 1, 3, 2 },
            { 2, 1, 3 },
            { 2, 3, 1 },
            { 3, 1, 2 },
            { 3, 2, 1 }
        },
        {
            { 1, 2, 3, 4 },
            { 1, 2, 4, 3 },
            { 1, 3, 2, 4 },
            { 1, 3, 4, 2 },
            { 1, 4, 2, 3 },
            { 1, 4, 3, 2 },
            { 2, 1, 3, 4 },
            { 2, 1, 4, 3 },
            { 2, 3, 1, 4 },
            { 2, 3, 4, 1 },
            { 2, 4, 1, 3 },
            { 2, 4, 3, 1 },
            { 3, 1, 2, 4 },
            { 3, 1, 4, 2 },
            { 3, 2, 1, 4 },
            { 3, 2, 4, 1 },
            { 3, 4, 1, 2 },
            { 3, 4, 2, 1 },
            { 4, 1, 2, 3 },
            { 4, 1, 3, 2 },
            { 4, 2, 1, 3 },
            { 4, 2, 3, 1 },
            { 4, 3, 1, 2 },
            { 4, 3, 2, 1 }
        }
    };

    String[] words = new String[n];

    for (int i = 0; i < n; i++) {
      words[i] = next();
    }

    List<List<String>> archive = new ArrayList<>();

    int m = nextInt();
    for (int i = 0; i < m; i++) {
      int cnt = nextInt();
      List<String> line = new ArrayList<>();
      for (int j = 0; j < cnt; j++) {
        line.add(next());
      }
      archive.add(line);
    }

    List<List<String>> perms = new ArrayList<>();

    for (int i = 0; i < order[n - 1].length; i++) {
      List<String> perm = new ArrayList<>();
      for (int j = 0; j < order[n - 1][i].length; j++) {
        perm.add(words[order[n - 1][i][j] - 1]);
      }
      perms.add(perm);
    }

    int p = 0;
    int index = -1;

    if (n == 1) {
      for (int j = 0; j < archive.size() && p == 0; j++) {
        for (int i = 0; i < perms.size(); i++) {
          List<String> perm = perms.get(i);
          for (int k = 0; k < archive.get(j).size() && p == 0; k++) {
            if (perm.get(0).equals(archive.get(j).get(k))) {
              p = 1;
              index = j;
            }
          }
        }
      }
    } else if (n == 2) {
      int ansInv = 10;
      for (int j = 0; j < archive.size(); j++) {
        List<String> ar = archive.get(j);
        for (int i = 0; i < perms.size(); i++) {
          List<String> perm = perms.get(i);
          for (int k = 0; k < ar.size(); k++) {
            if (perm.get(0).equals(archive.get(j).get(k))) {
              for (int k1 = 0; k1 < ar.size(); k1++) {
                if (perm.get(1).equals(archive.get(j).get(k1))) {
                  int inv = 0;

                  Map<String, Integer> map1 = new HashMap<>();
                  Map<String, Integer> map2 = new HashMap<>();

                  for (int l = 0; l < 2; l++) {
                    map1.put(words[l], l);
                  }

                  for (int l = 0; l < 2; l++) {
                    map2.put(perm.get(l), l);
                  }

                  for (int l1 = 0; l1 < 2; l1++) {
                    for (int l2 = l1 + 1; l2 < 2; l2++) {
                      if (map1.get(words[l1]) < map1.get(words[l2]) && map2.get(words[l1]) > map2.get(words[l2])) {
                        inv++;
                      }
                      if (map1.get(words[l1]) > map1.get(words[l2]) && map2.get(words[l1]) < map2.get(words[l2])) {
                        inv++;
                      }
                    }
                  }

                  if (ansInv > inv) {
                    ansInv = inv;
                  }
                }
              }
            }
          }
        }
        if (p < 2 - ansInv) {
          p = 2 - ansInv;
          index = j;
        }
      }
    } else if (n == 3) {
      for (int j = 0; j < archive.size(); j++) {
        List<String> ar = archive.get(j);
        int ansInv = 10;
        for (int i = 0; i < perms.size(); i++) {
          List<String> perm = perms.get(i);
          for (int k = 0; k < ar.size(); k++) {
            if (perm.get(0).equals(ar.get(k))) {
              for (int k1 = k + 1; k1 < ar.size(); k1++) {
                if (perm.get(1).equals(ar.get(k1))) {
                  for (int k2 = k1 + 1; k2 < ar.size(); k2++) {
                    if (perm.get(2).equals(ar.get(k2))) {
                      int inv = 0;

                      Map<String, Integer> map1 = new HashMap<>();
                      Map<String, Integer> map2 = new HashMap<>();

                      for (int l = 0; l < 3; l++) {
                        map1.put(words[l], l);
                      }

                      for (int l = 0; l < 3; l++) {
                        map2.put(perm.get(l), l);
                      }

                      for (int l1 = 0; l1 < 3; l1++) {
                        for (int l2 = l1 + 1; l2 < 3; l2++) {
                          if (map1.get(words[l1]) < map1.get(words[l2]) && map2.get(words[l1]) > map2.get(words[l2])) {
                            inv++;
                          }
                          if (map1.get(words[l1]) > map1.get(words[l2]) && map2.get(words[l1]) < map2.get(words[l2])) {
                            inv++;
                          }
                        }
                      }

                      if (ansInv > inv) {
                        ansInv = inv;
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if (p < 4 - ansInv) {
          p = 4 - ansInv;
          index = j;
        }
      }
    } else {
      for (int j = 0; j < archive.size(); j++) {
        List<String> ar = archive.get(j);
        int ansInv = 10;
        for (int i = 0; i < perms.size(); i++) {
          List<String> perm = perms.get(i);
          for (int k = 0; k < ar.size(); k++) {
            if (perm.get(0).equals(archive.get(j).get(k))) {
              for (int k1 = k + 1; k1 < ar.size(); k1++) {
                if (perm.get(1).equals(archive.get(j).get(k1))) {
                  for (int k2 = k1 + 1; k2 < ar.size(); k2++) {
                    if (perm.get(2).equals(archive.get(j).get(k2))) {
                      for (int k3 = k2 + 1; k3 < ar.size(); k3++) {
                        if (perm.get(3).equals(archive.get(j).get(k3))) {
                          int inv = 0;

                          Map<String, Integer> map1 = new HashMap<>();
                          Map<String, Integer> map2 = new HashMap<>();

                          for (int l = 0; l < 4; l++) {
                            map1.put(words[l], l);
                          }

                          for (int l = 0; l < 4; l++) {
                            map2.put(perm.get(l), l);
                          }

                          for (int l1 = 0; l1 < 4; l1++) {
                            for (int l2 = l1 + 1; l2 < 4; l2++) {
                              if (map1.get(words[l1]) < map1.get(words[l2]) && map2.get(words[l1]) > map2.get(words[l2])) {
                                inv++;
                              }
                              if (map1.get(words[l1]) > map1.get(words[l2]) && map2.get(words[l1]) < map2.get(words[l2])) {
                                inv++;
                              }
                            }
                          }

                          if (ansInv > inv) {
                            ansInv = inv;
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
        if (p < 7 - ansInv) {
          p = 7 - ansInv;
          index = j;
        }
      }
    }

    if (p == 0) {
      System.out.println("Brand new problem!");
    } else {
      System.out.println(index + 1);
      System.out.print("[:");
      for (int i = 0; i < p; i++) {
        System.out.print("|");
      }
      System.out.println(":]");
    }
  }

  private static void run() {
    br = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);

    solve();

    out.close();
  }

  private static StringTokenizer st;
  private static BufferedReader br;
  private static PrintWriter out;

  private static String next() {
    while (st == null || !st.hasMoreElements()) {
      String s;
      try {
        s = br.readLine();
      } catch (IOException e) {
        return null;
      }
      st = new StringTokenizer(s);
    }
    return st.nextToken();
  }

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

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

  public static void main(String[] args) {
    run();
  }
}