A recently found Ancient Prophesy is believed to contain the exact Apocalypse date. The prophesy is a string that only consists of digits and characters "-".

We'll say that some date is mentioned in the Prophesy if there is a substring in the Prophesy that is the date's record in the format "dd-mm-yyyy". We'll say that the number of the date's occurrences is the number of such substrings in the Prophesy. For example, the Prophesy "0012-10-2012-10-2012" mentions date 12-10-2012 twice (first time as "0012-10-2012-10-2012", second time as "0012-10-2012-10-2012").

The date of the Apocalypse is such correct date that the number of times it is mentioned in the Prophesy is strictly larger than that of any other correct date.

A date is correct if the year lies in the range from 2013 to 2015, the month is from 1 to 12, and the number of the day is strictly more than a zero and doesn't exceed the number of days in the current month. Note that a date is written in the format "dd-mm-yyyy", that means that leading zeroes may be added to the numbers of the months or days if needed. In other words, date "1-1-2013" isn't recorded in the format "dd-mm-yyyy", and date "01-01-2013" is recorded in it.

Notice, that any year between 2013 and 2015 is not a leap year.

Input

The first line contains the Prophesy: a non-empty string that only consists of digits and characters "-". The length of the Prophesy doesn't exceed 105 characters.

Output

In a single line print the date of the Apocalypse. It is guaranteed that such date exists and is unique.

Examples

Input

777-444---21-12-2013-12-2013-12-2013---444-777


Output

13-12-2013
import java.util.*;
import java.io.*;

public class Codeforces {

    
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        HashMap<String, Integer> map = new HashMap();
        String line = Reader.next();
        String arr[] = line.split("-");
        int days[] = {31,28,31,30,31,30,31,31,30,31,30,31}, max = 0;
        
        for(int i = 0; i < arr.length - 2; i++){
            if(arr[i].length() < 2 || arr[i+1].length() < 2 || arr[i+2].length() < 4)
                continue;
            
            int day = Integer.parseInt(arr[i].substring(arr[i].length() - 2));
            int mon = Integer.parseInt(arr[i+1].substring(arr[i+1].length() - 2));
            int year = Integer.parseInt(arr[i + 2].substring(0, 4));
            
            if(year < 2013 || year > 2015)
                continue;
            if(mon > 12 || mon < 1)
                continue;
            if(day > days[mon - 1] || day < 1)
                continue;
           
            String date = arr[i].substring(arr[i].length() - 2) + "-" + arr[i+1].substring(arr[i+1].length() - 2) + "-" + year;
            Integer c = map.get(date);
            
            if(c == null){
                map.put(date, 0);
                c = 0;
            }
            max = Math.max(++c, max);
            map.put(date, c);
        }
        
        for(Map.Entry<String, Integer> entry : map.entrySet()){
            if(entry.getValue() == max){
                System.out.println(entry.getKey());
                return;
            }
        }
    }
}

class Reader {

    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /**
     * call this method to initialize reader for InputStream
     */
    static void init(InputStream input) {
        reader = new BufferedReader(
                new InputStreamReader(input));
        tokenizer = new StringTokenizer("");
    }

    /**
     * get next word
     */
    static String next() throws IOException {
        while (!tokenizer.hasMoreTokens()) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                    reader.readLine());
        }
        return tokenizer.nextToken();
    }

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

    static byte nextByte() throws IOException {

        return Byte.parseByte(next());
    }

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

    static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}