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.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;

import javax.print.attribute.standard.MediaSize.ISO;

public class Codeforces2 implements Runnable {

    private BufferedReader br = null;
    private PrintWriter pw = null;
    private StringTokenizer stk = new StringTokenizer("");

    public static void main(String[] args) {
        new Thread(new Codeforces2()).run();
    }

    public void run() {

        /*
         * try { br = new BufferedReader(new FileReader("/home/user/freshdb.sql")); pw = new PrintWriter("/home/user/freshdb_fix.sql"); } catch
         * (FileNotFoundException e) { e.printStackTrace(); }
         */

        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        solver();
        pw.close();

    }

    private void nline() {
        try {
            if (!stk.hasMoreTokens())
                stk = new StringTokenizer(br.readLine());
        } catch (IOException e) {
            throw new RuntimeException("KaVaBUnGO!!!", e);
        }
    }

    private String nstr() {
        while (!stk.hasMoreTokens())
            nline();
        return stk.nextToken();
    }

    private int ni() {
        return Integer.valueOf(nstr());
    }

    private long nl() {
        return Long.valueOf(nstr());
    }

    private double nd() {
        return Double.valueOf(nstr());
    }

    String nextLine() {
        try {
            return br.readLine();
        } catch (IOException e) {
        }
        return null;
    }

    class Point {
        int x;
        int y;
        Point(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
    
    private void bfs(int t, boolean[] using, int[][] g){
        Stack<Integer> st = new Stack<Integer>();
        int n = using.length;
        st.add(t);
        while(!st.empty()){
            int p = st.pop();
            for(int i=0; i<n; i++){
                if (g[p][i]==1 && !using[i]){
                    st.add(i);
                    using[i] = true;
                }
            }
        }
    }
    
    private void solver() {
        long x = nl(), y = nl(), m = nl();
        long ans = 0;
        if (x>=m || y >=m){
            System.out.println(0);
        }else if (x+y <= Math.min(x, y)){
            System.out.println(-1);
        }else {
            if (x<0){
                ans = Math.round((double)(((double)-x+y -1)/(double)y));
                x += ans*y;                
            }else if (y<0) {
                ans = Math.round((double)(((double)-y+x -1)/(double)x));
                y += ans*x;     
            }
            
            while (x<m && y<m){
                long t = x+y;
                if (x<y){
                    x = t;
                }else {
                    y = t;
                }
                ++ans;
            }
            System.out.println(ans);
        }

    }


    private BigInteger nbi() {
        return new BigInteger(nstr());
    }

    void exit() {
        pw.close();
        System.exit(0);
    }

}
