Qwerty the Ranger took up a government job and arrived on planet Mars. He should stay in the secret lab and conduct some experiments on bacteria that have funny and abnormal properties. The job isn't difficult, but the salary is high.

At the beginning of the first experiment there is a single bacterium in the test tube. Every second each bacterium in the test tube divides itself into k bacteria. After that some abnormal effects create b more bacteria in the test tube. Thus, if at the beginning of some second the test tube had x bacteria, then at the end of the second it will have kx + b bacteria.

The experiment showed that after n seconds there were exactly z bacteria and the experiment ended at this point.

For the second experiment Qwerty is going to sterilize the test tube and put there t bacteria. He hasn't started the experiment yet but he already wonders, how many seconds he will need to grow at least z bacteria. The ranger thinks that the bacteria will divide by the same rule as in the first experiment. 

Help Qwerty and find the minimum number of seconds needed to get a tube with at least z bacteria in the second experiment.

Input

The first line contains four space-separated integers k, b, n and t (1 ≤ k, b, n, t ≤ 106) — the parameters of bacterial growth, the time Qwerty needed to grow z bacteria in the first experiment and the initial number of bacteria in the second experiment, correspondingly.

Output

Print a single number — the minimum number of seconds Qwerty needs to grow at least z bacteria in the tube.

Examples

Input

3 1 3 5


Output

2

Input

1 4 4 7


Output

3

Input

2 2 4 100


Output

0
import java.io.*;
import java.math.BigInteger;
import java.util.*;

 public class Main {
    static int arr[], N, K;
    static boolean adj[][];
    static BigInteger dp[][];
    static boolean reach[][];
    static  String str1 [];
     static String str2 [];
     public static void main(String[] args) throws IOException {
         Scanner sc = new Scanner(System.in);
         double k = sc.nextDouble();
         double b = sc.nextDouble();
         double n = sc.nextDouble();
         double t = sc.nextDouble();
         if(k==1){
             double z = 1 + b*n;
             n = Math.ceil((z-t)/b);
             System.out.println((n<=0) ? "0" : (long) n);
         }else{
             double diff = Math.log((t*(k-1) +b ) / (k-1+b)) / Math.log(k);
             System.out.println((n - diff <= 0) ? "0" : (long)Math.ceil(n - diff));
         }
     }
















     static class Point
     {
         int x;
         int y;

         public Point(int x, int y)
         {
             this.x = x;
             this.y = y;
         }

     };

     // Given three colinear points p, q, r, the function checks if
// point q lies on line segment 'pr'
     static boolean onSegment(Point p, Point q, Point r)
     {
         if (q.x <= Math.max(p.x, r.x) && q.x >= Math.min(p.x, r.x) &&
                 q.y <= Math.max(p.y, r.y) && q.y >= Math.min(p.y, r.y))
             return true;

         return false;
     }

     // To find orientation of ordered triplet (p, q, r).
// The function returns following values
// 0 --> p, q and r are colinear
// 1 --> Clockwise
// 2 --> Counterclockwise
     static int orientation(Point p, Point q, Point r)
     {
         // See https://www.geeksforgeeks.org/orientation-3-ordered-points/
         // for details of below formula.
         int val = (q.y - p.y) * (r.x - q.x) -
                 (q.x - p.x) * (r.y - q.y);

         if (val == 0) return 0; // colinear

         return (val > 0)? 1: 2; // clock or counterclock wise
     }

     // The main function that returns true if line segment 'p1q1'
// and 'p2q2' intersect.
     static boolean doIntersect(Point p1, Point q1, Point p2, Point q2)
     {
         // Find the four orientations needed for general and
         // special cases
         int o1 = orientation(p1, q1, p2);
         int o2 = orientation(p1, q1, q2);
         int o3 = orientation(p2, q2, p1);
         int o4 = orientation(p2, q2, q1);

         // General case
         if (o1 != o2 && o3 != o4)
             return true;

         // Special Cases
         // p1, q1 and p2 are colinear and p2 lies on segment p1q1
         if (o1 == 0 && onSegment(p1, p2, q1)) return true;

         // p1, q1 and q2 are colinear and q2 lies on segment p1q1
         if (o2 == 0 && onSegment(p1, q2, q1)) return true;

         // p2, q2 and p1 are colinear and p1 lies on segment p2q2
         if (o3 == 0 && onSegment(p2, p1, q2)) return true;

         // p2, q2 and q1 are colinear and q1 lies on segment p2q2
         if (o4 == 0 && onSegment(p2, q1, q2)) return true;

         return false; // Doesn't fall in any of the above cases
     }
/*
     static class Scanner
     {
         StringTokenizer st;
         BufferedReader br;

         public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
         public Scanner(String s) throws FileNotFoundException {
             br = new BufferedReader(new FileReader(s));
         }
         public String next() throws IOException
         {
             while (st == null || !st.hasMoreTokens())
                 st = new StringTokenizer(br.readLine());
             return st.nextToken();
         }

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

         public String nextLine() throws IOException {return br.readLine();}

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

         public boolean ready() throws IOException {return br.ready();}
     }

 */
 }

