Let us call a pair of integer numbers m-perfect, if at least one number in the pair is greater than or equal to m. Thus, the pairs (3, 3) and (0, 2) are 2-perfect while the pair (-1, 1) is not.

Two integers x, y are written on the blackboard. It is allowed to erase one of them and replace it with the sum of the numbers, (x + y).

What is the minimum number of such operations one has to perform in order to make the given pair of integers m-perfect?

Input

Single line of the input contains three integers x, y and m ( - 1018 ≤ x, y, m ≤ 1018).

Please, do not use the %lld specifier to read or write 64-bit integers in C++. It is preffered to use the cin, cout streams or the %I64d specifier.

Output

Print the minimum number of operations or "-1" (without quotes), if it is impossible to transform the given pair to the m-perfect one.

Examples

Input

1 2 5


Output

2


Input

-1 4 15


Output

4


Input

0 -1 5


Output

-1

Note

In the first sample the following sequence of operations is suitable: (1, 2) <image> (3, 2) <image> (5, 2).

In the second sample: (-1, 4) <image> (3, 4) <image> (7, 4) <image> (11, 4) <image> (15, 4).

Finally, in the third sample x, y cannot be made positive, hence there is no proper sequence of operations.
import java.io.DataInputStream;
import java.io.InputStream;
 
 
public class perfectPair {
    
    public static void main(String[] args) throws Exception {
    	
        Parsedoubt in = new Parsedoubt(System.in);
 
        long x = in.nextLong();
        long y = in.nextLong();
        long m = in.nextLong();
        
        solve( x , y, m);
        
     }
        
    
    public static void solve(long x, long y, long m){
    	
    		long step = 0;
    		
			if(Math.max(x , y) >= m){
				System.out.println(0);
				return;
			}
			
      
    		if( x <= 0 && y <= 0){
    			System.out.println(-1); 
    			return;
    		}
    		
    		if( x > 0 && y < 0){
 
    			step = (long) (step + Math.floor( (-y + x - 1) / x));
    			step = step + findStep(x, y + step*x, m);
    			System.out.println(step);
    			return;
    		}
    		
    		if( x < 0 && y > 0){
    			step = (long) (step + Math.floor( (-x + y - 1) / y));
    			step = step + findStep(x + step*y , y, m);
    			System.out.println(step);
    			return;
    		}
    		
    		step = findStep(x , y, m);
    		System.out.println(step);
    		
    }
    
    public static long findStep(long x, long y, long m){
    		
    	long step = 0;
    	while(Math.max(x, y) < m){
    		step++;
    		if( x < y)
    			x =  x + y;
    		else
    			y = x + y;
    	}
    	return step;
    }
   
}

class Parsedoubt {
	 
    final private int BUFFER_SIZE = 1 << 17;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Parsedoubt(InputStream in) {
        din = new DataInputStream(in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String nextString() throws Exception {
        StringBuffer sb = new StringBuffer("");
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        do {
            sb.append((char) c);
            c = read();
        } while (c > ' ');
        return sb.toString();
    }

    public char nextChar() throws Exception {
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        return (char) c;
    }

    public int nextInt() throws Exception {
        int ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    public long nextLong() throws Exception {
        long ret = 0;
        byte c = read();
        while (c <= ' ') {
            c = read();
        }
        boolean neg = c == '-';
        if (neg) {
            c = read();
        }
        do {
            ret = ret * 10 + c - '0';
            c = read();
        } while (c > ' ');
        if (neg) {
            return -ret;
        }
        return ret;
    }

    private void fillBuffer() throws Exception {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) {
            buffer[0] = -1;
        }
    }

    private byte read() throws Exception {
        if (bufferPointer == bytesRead) {
            fillBuffer();
        }
        return buffer[bufferPointer++];
    }
}

