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.util.*;
    import java.io.*;

     public class Codeforces {
         
        public static void main(String[] args) throws IOException {
            Reader.init(System.in);
            
            long a = Reader.nextLong();
            long b = Reader.nextLong();
            long m = Reader.nextLong();
            
            if(Math.max(a,b) >= m)
                System.out.println(0);
            
            else if(Math.max(a, b) < 1)
                System.out.println("-1");
            
            else{
                
                long min = Math.min(a,b);
                long max = Math.max(a,b);
                long ans = 0;
                
                if(min < 0){ 
                    ans += min*(-1 )/ max;
                    ans += (min % max != 0) ? 1 : 0;
                   
                    min = max * ans - (min*-1);
                }
                
                System.out.println(calc(min, max, m) + ans);
            }
        }
        
        static long calc(long a, long b, long m){
            if(a >= m || b >= m)
                return 0l;
            return calc(a+b, Math.max(a, b), m) + 1l;
        }
     }

    class  Pair implements Comparable<Pair>{

        int val;
        int index;

        Pair(int a, int b){
            val = a;
            index = b;
        }

        @Override
        public int compareTo(Pair t) {
            int a = val - t.val;
            if(a == 0)
                return index - t.index;
            return a;
        }

    }



    class Reader {

        static BufferedReader reader;
        static StringTokenizer tokenizer;

        public static int pars(String x) {
            int num = 0;
            int i = 0;
            if (x.charAt(0) == '-') {
                i = 1;
            }
            for (; i < x.length(); i++) {
                num = num * 10 + (x.charAt(i) - '0');
            }

            if (x.charAt(0) == '-') {
                return -num;
            }

            return num;
        }

        static void init(InputStream input) {
            reader = new BufferedReader(
                    new InputStreamReader(input));
            tokenizer = new StringTokenizer("");
        }

        static void init(FileReader input) {
            reader = new BufferedReader(input);
            tokenizer = new StringTokenizer("");
        }

        static String next() throws IOException {
            while (!tokenizer.hasMoreTokens()) {
                tokenizer = new StringTokenizer(
                        reader.readLine());
            }
            return tokenizer.nextToken();
        }

        static int nextInt() throws IOException {
            return pars(next());
        }

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

        static double nextDouble() throws IOException {
            return Double.parseDouble(next());
        }
    }