Problem: Teachers of one programming summer school decided to make a surprise for the students by giving them names in the style of the "Hobbit" movie. Each student must get a pseudonym maximally similar to his own name. The pseudonym must be a name of some character of the popular saga and now the teachers are busy matching pseudonyms to student names.

There are n students in a summer school. Teachers chose exactly n pseudonyms for them. Each student must get exactly one pseudonym corresponding to him. Let us determine the relevance of a pseudonym b to a student with name a as the length of the largest common prefix a and b. We will represent such value as <image>. Then we can determine the quality of matching of the pseudonyms to students as a sum of relevances of all pseudonyms to the corresponding students.

Find the matching between students and pseudonyms with the maximum quality.

Input

The first line contains number n (1 ≤ n ≤ 100 000) — the number of students in the summer school.

Next n lines contain the name of the students. Each name is a non-empty word consisting of lowercase English letters. Some names can be repeating.

The last n lines contain the given pseudonyms. Each pseudonym is a non-empty word consisting of small English letters. Some pseudonyms can be repeating.

The total length of all the names and pseudonyms doesn't exceed 800 000 characters.

Output

In the first line print the maximum possible quality of matching pseudonyms to students.

In the next n lines describe the optimal matching. Each line must have the form a b (1 ≤ a, b ≤ n), that means that the student who was number a in the input, must match to the pseudonym number b in the input.

The matching should be a one-to-one correspondence, that is, each student and each pseudonym should occur exactly once in your output. If there are several optimal answers, output any.

Examples

Input

5
gennady
galya
boris
bill
toshik
bilbo
torin
gendalf
smaug
galadriel


Output

11
4 1
2 5
1 3
5 2
3 4

Note

The first test from the statement the match looks as follows: 

  * bill  →  bilbo (lcp = 3) 
  * galya  →  galadriel (lcp = 3) 
  * gennady  →  gendalf (lcp = 3) 
  * toshik  →  torin (lcp = 2) 
  * boris  →  smaug (lcp = 0) 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:16777216")
const int inf = 0x3f3f3f3f;
const long long int INF = 100000000000001ll;
const string debug_line = "yolo";
const double PI = 4 * atan(1);
char s[800011];
int trie[800011][26];
int count1[800011];
int count2[800011];
vector<int> ispresent1[800011];
vector<int> ispresent2[800011];
int node_count = 1;
bool visited[800010];
int matched[800010];
vector<int> order1;
vector<int> order2;
void DFS(int u, int p) {
  for (int(i) = (0); (i) < (26); ++(i)) {
    if (trie[u][i] != -1) {
      DFS(trie[u][i], u);
    }
  }
  int index1 = (int)ispresent1[u].size() - 1;
  int index2 = (int)ispresent2[u].size() - 1;
  while (index1 >= 0 && index2 >= 0) {
    matched[ispresent1[u][index1]] = ispresent2[u][index2];
    index1--;
    index2--;
  }
  while (index1 >= 0) {
    ispresent1[p].push_back(ispresent1[u][index1]);
    index1--;
  }
  while (index2 >= 0) {
    ispresent2[p].push_back(ispresent2[u][index2]);
    index2--;
  }
}
void fill_num(int n) {
  for (int(i) = (1); (i) < (n + 1); ++(i)) {
    scanf("%s", s);
    int begin1 = 1;
    int l1 = strlen(s);
    for (int(j) = (0); (j) < (l1); ++(j)) {
      if (trie[begin1][s[j] - 'a'] == -1) {
        trie[begin1][s[j] - 'a'] = ++node_count;
        begin1 = node_count;
        if (j == l1 - 1) {
          ispresent1[begin1].push_back(i);
        }
        count1[begin1]++;
      } else {
        begin1 = trie[begin1][s[j] - 'a'];
        if (j == l1 - 1) {
          ispresent1[begin1].push_back(i);
        }
        count1[begin1]++;
      }
    }
  }
  for (int(i) = (1); (i) < (n + 1); ++(i)) {
    scanf("%s", s);
    int begin1 = 1;
    int l1 = strlen(s);
    for (int(j) = (0); (j) < (l1); ++(j)) {
      if (trie[begin1][s[j] - 'a'] == -1) {
        trie[begin1][s[j] - 'a'] = ++node_count;
        begin1 = node_count;
        if (j == l1 - 1) {
          ispresent2[begin1].push_back(i);
        }
        count2[begin1]++;
      } else {
        begin1 = trie[begin1][s[j] - 'a'];
        if (j == l1 - 1) {
          ispresent2[begin1].push_back(i);
        }
        count2[begin1]++;
      }
    }
  }
  long long answer1 = 0;
  for (int(i) = (0); (i) < (800001); ++(i)) {
    answer1 = answer1 + (long long)(min(count1[i], count2[i]));
  }
  printf("%lld\n", answer1);
  DFS(1, 1);
  for (int(i) = (1); (i) < (n + 1); ++(i)) {
    printf("%d %d\n", i, matched[i]);
  }
}
int main() {
  int n;
  scanf("%d", &n);
  for (int(i) = (0); (i) < (800001); ++(i)) {
    for (int(j) = (0); (j) < (26); ++(j)) {
      trie[i][j] = -1;
    }
  }
  fill_num(n);
  return 0;
}