import java.io.BufferedReader;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.HashSet;
import java.util.Set;

/**
 *
 * @author cteam01
 */
public class bus {

    enum Opt {
        MON,
        TUE,
        WED,
        THU,
        FRI,
        SAT,
        SUN,
        T,
        W,
        A
    }
    
    static Set<Integer> svatkyNL = new HashSet<Integer>();
    static Set<Integer> svatkyL = new HashSet<Integer>();
    
    static int[] NL = {
        31,28,31,30,31,30,31,31,30,31,30,31
    };
    static int[] L = {
        31,29,31,30,31,30,31,31,30,31,30,31
    };
    
    static {
        svatkyL.add(toDays(1, 0, true));
        svatkyL.add(toDays(1, 4, true));
        svatkyL.add(toDays(8, 4, true));
        svatkyL.add(toDays(5, 6, true));
        svatkyL.add(toDays(6, 6, true));
        svatkyL.add(toDays(28, 9, true));
        svatkyL.add(toDays(28, 8, true));
        svatkyL.add(toDays(17, 10, true));
        svatkyL.add(toDays(24, 11, true));
        svatkyL.add(toDays(25, 11, true));
        svatkyL.add(toDays(26, 11, true));
        
        
        
        svatkyNL.add(toDays(1, 0, false));
        svatkyNL.add(toDays(1, 4, false));
        svatkyNL.add(toDays(8, 4, false));
        svatkyNL.add(toDays(5, 6, false));
        svatkyNL.add(toDays(6, 6, false));
        svatkyNL.add(toDays(28, 9, false));
        svatkyNL.add(toDays(28, 8, false));
        svatkyNL.add(toDays(17, 10, false));
        svatkyNL.add(toDays(24, 11, false));
        svatkyNL.add(toDays(25, 11, false));
        svatkyNL.add(toDays(26, 11, false));
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws Exception {
//        System.out.println(getDay(2010));
//        System.exit(0);
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line;
        int n;
        int sum;
        boolean leap;
        int weekDay;
        int easter;
        while ((line = br.readLine()) != null) {
            sum = 0;
            String[] p = line.split(" ");
            Set<Character> opts = new HashSet<Character>();
            char[] chs = p[0].toCharArray();
            for (char c : chs) {
                opts.add(c);
            }
            
            int year = Integer.parseInt(p[2]);
            leap = isLeap(year);
            weekDay = getDay(year);
            easter = easterMon(year, leap);
            String[] intervals = p[1].split(",");
            int len = intervals.length;
            int[][] days = new int[4][len]; // DM start, DM end
            for (int i = 0; i < len; i++) {
                String[] sten = intervals[i].split("-");
                String[] st = sten[0].split("\\.");
                days[0][i] = Integer.parseInt(st[0]);
                days[1][i] = Integer.parseInt(st[1]) - 1;
                
                if (sten.length == 1) {
                    if (days[0][i] == 29 && days[1][i] == 1 && !leap) {
                        days[2][i] = 28;
                        days[3][i] = 1;
                    } else {
                    days[2][i] = days[0][i];
                    days[3][i] = days[1][i];
                    }
                } else {
                    if (days[0][i] == 29 && days[1][i] == 1 && !leap) {
                        days[0][i] = 1;
                        days[1][i] = 2;
                    }
                    
                    String[] en = sten[1].split("\\.");

                    days[2][i] = Integer.parseInt(en[0]);
                    days[3][i] = Integer.parseInt(en[1]) - 1;
                    
                    if (days[2][i] == 29 && days[3][i] == 1 && !leap) {
                        days[2][i]--;
                    }
                }
            }
            
            int start, end;
            for (int i = 0; i < len; i++) {
                start = toDays(days[0][i], days[1][i], leap);
                end = toDays(days[2][i], days[3][i], leap);
                for (int d = start; d <= end; d++) {
                       int dw = (d + weekDay) % 7;
                       
                       if (opts.contains('1') && dw == 0) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('2') && dw == 1) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('3') && dw == 2) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('4') && dw == 3) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('5') && dw == 4) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('6') && dw == 5) {
                           sum++;
                               continue;
                       }
                       if (opts.contains('7') && dw == 6) {
                           sum++;
                               continue;
                       }
                       
                       if (opts.contains('t')) {
                           if (dw == 6 || easter == d) {
                               sum++;
                               continue;
                           }
                           
                           if (leap) {
                               if (svatkyL.contains(d)) {
                                   sum++;
                                   continue;
                               } 
                           } else {
                               if (svatkyNL.contains(d)) {
                                   sum++;
                                   continue;
                               }
                           }
                       }
                       
                       if (opts.contains('a') && dw < 5) {
                           boolean next = true;
                           if (leap) {
                               if (svatkyL.contains(d)) {
                                   next = false;
                               } 
                           } else {
                               if (svatkyNL.contains(d)) {
                                   next = false;
                               }
                           }
                           
                           if (easter == d) {
                              next = false;
                           }
                           
                           if (next) {
                           if (easter == (d - 1)) {
                               sum++;
                               continue;
                           }
                           
                           if (dw == 0) {
                               sum++;
                               continue;
                           }
                           
                           if (leap) {
                               if (svatkyL.contains(d - 1)) {
                                   sum++;
                                   continue;
                               } 
                           } else {
                               if (svatkyNL.contains(d - 1)) {
                                   sum++;
                                   continue;
                               }
                           }
                           }
                       }
                       
                       if (opts.contains('w') && dw < 5) {
                           boolean next = true;
                           if (leap) {
                               if (svatkyL.contains(d)) {
                                   next = false;
                               } 
                           } else {
                               if (svatkyNL.contains(d)) {
                                   next = false;
                               }
                           }
                           
                           if (easter == d) {
                               next = false;
                           }
                           if (next)
                           sum++;
                       }
                }
                
                
            }
            System.out.println(sum);
            
        }
    }
    
    private static int toDays(int d, int m, boolean leap) {
        int sum = 0;
        for (int i = 0; i < m; i++) {
            sum += leap ? L[i] : NL[i];
        }
        return sum + d;
    }
    
    private static boolean isLeap(int year) {
        return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0);
    }
    
    private static int easterMon(int y, boolean leap) {
        int golden, solar, lunar, p;
        
        golden = (y % 19) + 1;
        solar = (y - 1600) / 100 - (y - 1600) / 400;
        lunar = (((y - 1400) / 100) * 8) / 25;
        p = (3003 - (11 * golden) + solar - lunar) % 30;
        if (p == 29 || (p == 28 && golden > 11)) p--;
        
        int pdd = toDays(21, 2, leap) + p;
        
        int dw = getDay(y);
        
        for (int dx = pdd+1; dx < 365; dx++) {
            int dw2 = (dx + dw) % 7;
            if (dw2 == 0) {
                return dx;
            }
        }
        return pdd;
        
    }
    
    private static int getDay(int year) {
        Calendar c = new GregorianCalendar(year, 0, 1);
        int d = c.get(Calendar.DAY_OF_WEEK);
        if (d == 1) {
            return 6;
        } else {
            return d - 2;
        }
    }
   
}