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.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.*;
import java.text.*;

public class cf318c {

    static BufferedReader br;
    static Scanner sc;
    static PrintWriter out;

    public static void initA() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            //br = new BufferedReader(new FileReader("input.txt"));
            sc = new Scanner(System.in);
            //out = new PrintWriter("output.txt");
            out = new PrintWriter(System.out);
        } catch (Exception e) {
        }
    }

    static boolean next_permutation(Integer[] p) {
        for (int a = p.length - 2; a >= 0; --a) {
            if (p[a] < p[a + 1]) {
                for (int b = p.length - 1;; --b) {
                    if (p[b] > p[a]) {
                        int t = p[a];
                        p[a] = p[b];
                        p[b] = t;
                        for (++a, b = p.length - 1; a < b; ++a, --b) {
                            t = p[a];
                            p[a] = p[b];
                            p[b] = t;
                        }
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public static void initB() {
        try {

            br = new BufferedReader(new FileReader("input.txt"));
            sc = new Scanner(new FileReader("input.txt"));
            out = new PrintWriter("output.txt");

        } catch (Exception e) {
        }
    }

    public static String getString() {
        try {
            return br.readLine();
        } catch (Exception e) {
        }
        return "";
    }

    public static Integer getInt() {
        try {
            return Integer.parseInt(br.readLine());
        } catch (Exception e) {
        }
        return 0;
    }

    public static Integer[] getIntArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            Integer temp2[] = new Integer[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = Integer.parseInt(temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static Long[] getLongArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            Long temp2[] = new Long[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = Long.parseLong(temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static String[] getStringArr() {
        try {
            StringTokenizer temp = new StringTokenizer(br.readLine());
            int n = temp.countTokens();
            String temp2[] = new String[n];
            for (int i = 0; i < n; i++) {
                temp2[i] = (temp.nextToken());
            }
            return temp2;
        } catch (Exception e) {
        }
        return null;
    }

    public static int getMax(Integer[] ar) {
        int t = ar[0];
        for (int i = 0; i < ar.length; i++) {
            if (ar[i] > t) {
                t = ar[i];
            }
        }
        return t;
    }

    public static void print(Object a) {
        out.println(a);
    }

    public static void print(String s, Object... a) {
        out.printf(s, a);
    }

    public static int nextInt() {
        return sc.nextInt();
    }

    public static double nextDouble() {
        return sc.nextDouble();
    }

    public static void main(String[] ar) {
        initA();
        solve();
        out.flush();
    }
    static double akar5 = Math.sqrt(5);

    static long f(int n) {
        double a = (1 / akar5) * Math.pow((1 + akar5) / 2, n);
        double b = (1 / akar5) * Math.pow((1 - akar5) / 2, n);
        return (long) (a - b);
    }

    public static void solve() {
        Long in[] = getLongArr();
        long x = Math.min(in[0], in[1]), y = Math.max(in[0], in[1]), m = in[2];

        if (x >= m || y >= m) {
            print(0);
            return;
        }
        if (x<=0 && y<=0 && m > 0) {
            print(-1);
            return;
        }

        /*
        if (x == 1 && y == 1) {
        int l = 1, r = Integer.MAX_VALUE/2;
        
        while (l != r) {
        int mid = (l + r) / 2;
        
        if (f(mid) >= m) {
        r = mid;
        } else {
        l = mid + 1;
        }
        
        }
        
        print(l-2);
        
        return;
        }
        if (x == 0 && y == 1) {
        int l = 1, r = Integer.MAX_VALUE/2;
        
        while (l != r) {
        int mid = (l + r) / 2;
        
        if (f(mid) >= m) {
        r = mid;
        } else {
        l = mid + 1;
        }
        
        }
        
        print(l-1);
        return;
        }
         * 
         */
        if (x < 0 && y < 0 && m <= 0) {
            print(-1);
            return;
        }
        long langkah = 0;
        if(x < 0){
            long temp = ((x*-1)+(y-1))/y;
            x+= (temp * y);
            langkah = temp;
        }
        //print(x+" "+y+" "+langkah);
        langkah++;
        long c = x + y;
        long temp[] = new long[]{x, y, c};
        Arrays.sort(temp);
        x = temp[1];
        y = temp[2];
        while (c < m) {
            c = x + y;
            temp = new long[]{x, y, c};
            Arrays.sort(temp);
            x = temp[1];
            y = temp[2];
            langkah++;

        }
        print(langkah);

    }
}