Jamie loves sleeping. One day, he decides that he needs to wake up at exactly hh: mm. However, he hates waking up, so he wants to make waking up less painful by setting the alarm at a lucky time. He will then press the snooze button every x minutes until hh: mm is reached, and only then he will wake up. He wants to know what is the smallest number of times he needs to press the snooze button.

A time is considered lucky if it contains a digit '7'. For example, 13: 07 and 17: 27 are lucky, while 00: 48 and 21: 34 are not lucky.

Note that it is not necessary that the time set for the alarm and the wake-up time are on the same day. It is guaranteed that there is a lucky time Jamie can set so that he can wake at hh: mm.

Formally, find the smallest possible non-negative integer y such that the time representation of the time x·y minutes before hh: mm contains the digit '7'.

Jamie uses 24-hours clock, so after 23: 59 comes 00: 00.

Input

The first line contains a single integer x (1 ≤ x ≤ 60).

The second line contains two two-digit integers, hh and mm (00 ≤ hh ≤ 23, 00 ≤ mm ≤ 59).

Output

Print the minimum number of times he needs to press the button.

Examples

Input

3
11 23


Output

2


Input

5
01 07


Output

0

Note

In the first sample, Jamie needs to wake up at 11:23. So, he can set his alarm at 11:17. He would press the snooze button when the alarm rings at 11:17 and at 11:20.

In the second sample, Jamie can set his alarm at exactly at 01:07 which is lucky.
import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
    long MOD = 1000000007L;
    public class Obj implements Comparable<Obj>{
        public int t;
        public int h;
        
        public Obj(int t_, int h_){
            t = t_;
            h = h_;
        }
        
        public int compareTo(Obj other){
            return t - other.t;
        }
        
    }
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
        Codechef cf = new Codechef();
        cf.Solve();
	}
	
	int[][] tree;
	int[] lazy;
	
	public int GCD(int a, int b){
	    while (b > 0){
	        int tmp = b;
	        b = a % b;
	        a = tmp;
	    }
	    return a;
	}
	
	public void Solve(){
        MyScanner sc = new MyScanner();
        int x = sc.nextInt();
        int hh = sc.nextInt();
        int mm = sc.nextInt();
        int z = 0;
        while(!lucky(hh,mm)){
            mm -= x;
            int k = 0;
            if (mm < 0){
                k = 1;
                mm = 60 + mm;
            }
            hh = hh - k;
            if (hh < 0){
                hh = 24 + hh;
            }
            // System.out.println(hh + " " + mm);
            z++;
        }
            
        out = new PrintWriter(new BufferedOutputStream(System.out));
        out.println(z);
        out.close();
	}
	
	public boolean lucky(int hh, int mm){
	    int h = hh % 10;
	    int m = mm % 10;
	    return (h == 7 || m == 7);
	}
	
	public void BuildTree(int node, int l, int r){
	   // System.out.println(node + " " + l + " " + r);
	    if (l == r){
	        tree[node][0] = 1;
	        return;
	    }
	    int mid = l + (r - l) / 2;
	    BuildTree(node * 2, l, mid);
	    BuildTree(node * 2 + 1, mid + 1, r);
	    tree[node][0] = tree[node*2][0] + tree[node*2 + 1][0];
	}
	
	public void UpdateRange(int node, int st, int ed, int l, int r, int diff){
	    if (lazy[node] != 0){
	        int k = lazy[node] % 3;
	        if (k == 2){
	            int tmp = tree[node][0];
	            tree[node][0] = tree[node][1];
	            tree[node][1] = tree[node][2];
	            tree[node][2] = tmp;
	        }else if (k == 1){
	            int tmp = tree[node][0];
	            tree[node][0] = tree[node][2];
	            tree[node][2] = tree[node][1];
	            tree[node][1] = tmp;
	        }
	        
	        if (st != ed){
	            lazy[node*2] += lazy[node];
	            lazy[node*2 + 1] += lazy[node];
	        }
	        lazy[node] = 0;
	    }
	    
	    if (st > ed || st > r || ed < l) return;
	    
	    if (l <= st && ed <= r){
	        int tmp = tree[node][0];
	        tree[node][0] = tree[node][2];
	        tree[node][2] = tree[node][1];
	        tree[node][1] = tmp;
	        if (st != ed){
	            lazy[node * 2] += diff;
	            lazy[node * 2 + 1] += diff;
	        }
	        return;
	    }
	    int mid = st + (ed - st) / 2;
	    UpdateRange(node * 2, st, mid, l, r, diff);
	    UpdateRange(node * 2 + 1, mid + 1, ed, l, r, diff);
	    for (int i = 0; i < 3; ++i){
	        tree[node][i] = tree[node*2][i] + tree[node*2 + 1][i];
	    }
	}
	
	public int QueryRange(int node, int st, int ed, int l, int r){
	   // System.out.println(node + " " + st + " " + ed);
	    if (lazy[node] != 0){
	        int k = lazy[node] % 3;
	        if (k == 2){
	            int tmp = tree[node][0];
	            tree[node][0] = tree[node][1];
	            tree[node][1] = tree[node][2];
	            tree[node][2] = tmp;
	        }else if (k == 1){
	            int tmp = tree[node][0];
	            tree[node][0] = tree[node][2];
	            tree[node][2] = tree[node][1];
	            tree[node][1] = tmp;
	        }
	        
	        if (st != ed){
	            lazy[node*2] += lazy[node];
	            lazy[node*2 + 1] += lazy[node];
	        }
	        lazy[node] = 0;
	    }
	    
	    if (st > ed || st > r || ed < l) return 0;
	    if (l <= st && ed <= r){
	       return tree[node][0]; 
	    }
	    int mid = st + (ed - st) / 2;
	    int p1 = QueryRange(node * 2, st, mid, l, r);
	    int p2 = QueryRange(node * 2 + 1, mid + 1, ed, l, r);
	    return (p1 + p2);
	}
	

	//-----------PrintWriter for faster output---------------------------------
   public static PrintWriter out;
      
   //-----------MyScanner class for faster input----------
   public static class MyScanner {
      BufferedReader br;
      StringTokenizer st;
 
      public MyScanner() {
         br = new BufferedReader(new InputStreamReader(System.in));
      }
 
      String next() {
          while (st == null || !st.hasMoreElements()) {
              try {
                  st = new StringTokenizer(br.readLine());
              } catch (IOException e) {
                  e.printStackTrace();
              }
          }
          return st.nextToken();
      }
 
      int nextInt() {
          return Integer.parseInt(next());
      }
 
      long nextLong() {
          return Long.parseLong(next());
      }
 
      double nextDouble() {
          return Double.parseDouble(next());
      }
 
      String nextLine(){
          String str = "";
      try {
         str = br.readLine();
      } catch (IOException e) {
         e.printStackTrace();
      }
      return str;
      }

   }
}