Problem: It's unbelievable, but an exam period has started at the OhWord University. It's even more unbelievable, that Valera got all the tests before the exam period for excellent work during the term. As now he's free, he wants to earn money by solving problems for his groupmates. He's made a list of subjects that he can help with. Having spoken with n of his groupmates, Valera found out the following information about them: what subject each of them passes, time of the exam and sum of money that each person is ready to pay for Valera's help.

Having this data, Valera's decided to draw up a timetable, according to which he will solve problems for his groupmates. For sure, Valera can't solve problems round the clock, that's why he's found for himself an optimum order of day and plans to stick to it during the whole exam period. Valera assigned time segments for sleep, breakfast, lunch and dinner. The rest of the time he can work.

Obviously, Valera can help a student with some subject, only if this subject is on the list. It happened, that all the students, to whom Valera spoke, have different, but one-type problems, that's why Valera can solve any problem of subject listi in ti minutes.

Moreover, if Valera starts working at some problem, he can break off only for sleep or meals, but he can't start a new problem, not having finished the current one. Having solved the problem, Valera can send it instantly to the corresponding student via the Internet.

If this student's exam hasn't started yet, he can make a crib, use it to pass the exam successfully, and pay Valera the promised sum. Since Valera has little time, he asks you to write a program that finds the order of solving problems, which can bring Valera maximum profit.

Input

The first line contains integers m, n, k (1 ≤ m, n ≤ 100, 1 ≤ k ≤ 30) — amount of subjects on the list, amount of Valera's potential employers and the duration of the exam period in days.

The following m lines contain the names of subjects listi (listi is a non-empty string of at most 32 characters, consisting of lower case Latin letters). It's guaranteed that no two subjects are the same.

The (m + 2)-th line contains m integers ti (1 ≤ ti ≤ 1000) — time in minutes that Valera spends to solve problems of the i-th subject. Then follow four lines, containing time segments for sleep, breakfast, lunch and dinner correspondingly.

Each line is in format H1:M1-H2:M2, where 00 ≤  H1, H2 ≤ 23, 00 ≤  M1, M2 ≤ 59. Time H1:M1 stands for the first minute of some Valera's action, and time H2:M2 stands for the last minute of this action. No two time segments cross. It's guaranteed that Valera goes to bed before midnight, gets up earlier than he has breakfast, finishes his breakfast before lunch, finishes his lunch before dinner, and finishes his dinner before midnight. All these actions last less than a day, but not less than one minute. Time of the beginning and time of the ending of each action are within one and the same day. But it's possible that Valera has no time for solving problems.

Then follow n lines, each containing the description of students. For each student the following is known: his exam subject si (si is a non-empty string of at most 32 characters, consisting of lower case Latin letters), index of the exam day di (1 ≤ di ≤ k), the exam time timei, and sum of money ci (0 ≤ ci ≤ 106, ci — integer) that he's ready to pay for Valera's help. Exam time timei is in the format HH:MM, where 00 ≤  HH ≤ 23, 00 ≤  MM ≤ 59. Valera will get money, if he finishes to solve the problem strictly before the corresponding student's exam begins.

Output

In the first line output the maximum profit that Valera can get. The second line should contain number p — amount of problems that Valera is to solve. In the following p lines output the order of solving problems in chronological order in the following format: index of a student, to whom Valera is to help; index of the time, when Valera should start the problem; time, when Valera should start the problem (the first minute of his work); index of the day, when Valera should finish the problem; time, when Valera should finish the problem (the last minute of his work). To understand the output format better, study the sample tests.

Examples

Input

3 3 4
calculus
algebra
history
58 23 15
00:00-08:15
08:20-08:35
09:30-10:25
19:00-19:45
calculus 1 09:36 100
english 4 21:15 5000
history 1 19:50 50


Output

150
2
1 1 08:16 1 09:29
3 1 10:26 1 10:40


Input

2 2 1
matan
codeforces
1 2
00:00-08:00
09:00-09:00
12:00-12:00
18:00-18:00
codeforces 1 08:04 2
matan 1 08:02 1


Output

3
2
2 1 08:01 1 08:01
1 1 08:02 1 08:03


Input

2 2 1
matan
codeforces
2 2
00:00-08:00
09:00-09:00
12:00-12:00
18:00-18:00
codeforces 1 08:04 2
matan 1 08:03 1


Output

2
1
1 1 08:01 1 08:02

Solution (in JAVA):

Solution:
import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.io.*;
import java.util.*;

public class Main {
    static boolean LOCAL = false;//System.getSecurityManager() == null;
    Scanner sc = new Scanner(System.in);
    
    int toi(String s) {
        return Integer.parseInt(s.substring(0, 2)) * 60 + Integer.parseInt(s.substring(3));
    }
    
    String tos(int i) {
        return String.format("%d %02d:%02d", i / (24 * 60) + 1, i / 60 % 24, i % 60);
    }
    
    int INF = 1 << 29;
    int N = 24 * 60 * 30 + 2;
    
    void run() {
        int m = sc.nextInt(), n = sc.nextInt(), k = sc.nextInt();
        String[] ss = new String[m];
        for (int i = 0; i < m; i++) ss[i] = sc.next();
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (int i = 0; i < m; i++) {
            map.put(ss[i], sc.nextInt());
        }
        int[] sum = new int[N];
        fill(sum, 1);
        for (int i = 0; i < 4; i++) {
            String s = sc.next();
            int from = toi(s.substring(0, 5));
            int to = toi(s.substring(6));
            while (to < N) {
                for (int j = from; j <= to; j++) {
                    sum[j] = 0;
                }
                from += 24 * 60;
                to += 24 * 60;
            }
        }
        for (int i = 1; i < N; i++) {
            sum[i] += sum[i - 1];
        }
        int M = sum[N - 1] + 2;
        int[] times = new int[M];
        times[M - 1] = INF;
        for (int i = N - 1; i >= 0; i--) times[sum[i]] = i;
        Entry[] es = new Entry[n];
        for (int i = 0; i < n; i++) {
            String s = sc.next();
            int t = 24 * 60 * (sc.nextInt() - 1) + toi(sc.next());
            int money = sc.nextInt();
            if (map.containsKey(s)) es[i] = new Entry(i + 1, map.get(s), t, money);
            else es[i] = new Entry(i + 1, INF, t, money);
        }
        sort(es);
        int[][] dp = new int[n + 1][M];
        int[][] prev = new int[n + 1][M];
        for (int i = 0; i < dp.length; i++) fill(dp[i], -1);
        dp[0][1] = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < M; j++) if (dp[i][j] >= 0) {
                if (dp[i + 1][j] < dp[i][j]) {
                    dp[i + 1][j] = dp[i][j];
                    prev[i + 1][j] = j;
                }
                int j2 = j + es[i].need - 1;
                if (j2 < times.length && times[j2] < es[i].until) {
                    if (dp[i + 1][j2 + 1] < dp[i][j] + es[i].money) {
                        dp[i + 1][j2 + 1] = dp[i][j] + es[i].money;
                        prev[i + 1][j2 + 1] = j;
                    }
                }
            }
        }
        int res = 0, j = 0;
        for (int i = 0; i < M; i++) if (res < dp[n][i]) {
            res = dp[n][i];
            j = i;
        }
        System.out.println(res);
        ArrayList<String> list = new ArrayList<String>();
        for (int i = n; i > 0; i--) {
            if (j > prev[i][j]) {
                list.add(String.format("%d %s %s", es[i - 1].id, tos(times[prev[i][j]]), tos(times[j - 1])));
            }
            j = prev[i][j];
        }
        System.out.println(list.size());
        Collections.reverse(list);
        for (String s : list) System.out.println(s);
    }
    
    class Entry implements Comparable<Entry> {
        int id;
        int need;
        int until;
        int money;
        Entry(int id, int need, int until, int money) {
            this.id = id;
            this.need = need;
            this.until = until;
            this.money = money;
        }
        public int compareTo(Entry o) {
            return until - o.until;
        }
    }
    
    class Scanner {
        BufferedReader br;
        StringTokenizer st;
        Scanner(InputStream in) {
            br = new BufferedReader(new InputStreamReader(in));
            eat("");
        }
        void eat(String s) {
            st = new StringTokenizer(s);
        }
        String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        boolean hasNext() {
            while (!st.hasMoreTokens()) {
                String s = nextLine();
                if (s == null) return false;
                eat(s);
            }
            return true;
        }
        String next() {
            hasNext();
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
    
    void debug(Object...os) {
        System.err.println(deepToString(os));
    }
    
    public static void main(String[] args) {
        if (LOCAL) {
            try {
                System.setIn(new FileInputStream("in.txt"));
            } catch (Throwable e) {
                LOCAL = false;
            }
        }
        if (!LOCAL) {
            try {
                System.setOut(new PrintStream(new BufferedOutputStream(System.out)));
            } catch (Throwable e) {
            }
        }
        new Main().run();
        System.out.flush();
    }
}