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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.math.BigInteger;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author zodiacLeo
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        FastPrinter out = new FastPrinter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC
    {
        public void solve(int testNumber, FastScanner in, FastPrinter out)
        {
            long x = in.nextLong();
            long y = in.nextLong();
            long k = in.nextLong();

            long min = Math.min(x, y);
            long max = Math.max(x, y);

            if (k > 0)
            {
                if (max <= 0)
                {
                    out.println(-1);
                    return;
                } else if (max > 0 && max < k)
                {
                    //do nothing//
                } else if (max >= k)
                {
                    out.println(0);
                    return;
                }
            } else if (k == 0)
            {
                if (max < 0)
                {
                    out.println(-1);
                    return;
                } else if (max >= 0)
                {
                    out.println(0);
                    return;
                }
            } else
            {
                if (min >= 0)
                {
                    out.println(0);
                    return;
                } else if (max >= 0)
                {
                    out.println(0);
                    return;
                } else if (max >= k)
                {
                    out.println(0);
                    return;
                } else
                {
                    out.println(-1);
                    return;
                }
            }


            if ((min <= 0 && max <= 0 && k <= 0) || (min >= 0 && max >= 0 && k >= 0))
            {
                long a = min;
                long b = max;
                if (min < 0)
                {
                    min = -min;
                    max = -max;
                    k = -k;
                    a = Math.min(min, max);
                    b = Math.max(min, max);
                }

                long best = 0;
                while (true)
                {
                    best++;
                    long temp = a + b;
                    if (temp >= k)
                    {
                        out.println(best);
                        return;
                    }
                    a = Math.min(b, temp);
                    b = Math.max(b, temp);
                }
            } else

            {
                long a = 0;
                long b = 0;
                long best = 0;
                if (k >= max)
                {
                    a = min;
                    b = max;
                } else if (k < max && k >= min)
                {
                    out.println(0);
                    return;
                } else if (k < min)
                {
                    a = Math.min(-min, -max);
                    b = Math.max(-min, -max);
                    k = -k;
                }

                BigInteger low = BigInteger.valueOf(-1L);
                BigInteger high = BigInteger.valueOf(Long.MAX_VALUE);
                while (high.subtract(low).compareTo(BigInteger.ONE) > 0)
                {
                    BigInteger mid = low.add((high.subtract(low)).divide(BigInteger.valueOf(2L)));
                    if (BigInteger.valueOf(a).add(mid.multiply(BigInteger.valueOf(b))).compareTo(BigInteger.ZERO) >= 0)
                    {
                        high = mid;
                    } else
                    {
                        low = mid;
                    }
                }
                best = high.longValue();
                a = a + best * b;
                min = Math.min(a, b);
                max = Math.max(a, b);
                a = min;
                b = max;

                while (true)
                {
                    best++;
                    long temp = a + b;
                    if (temp >= k)
                    {
                        out.println(best);
                        return;
                    }
                    a = Math.min(b, temp);
                    b = Math.max(b, temp);
                }
            }
        }

    }

    static class FastScanner
    {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(InputStream is)
        {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        public String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                String s = null;
                try
                {
                    s = br.readLine();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

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

    }

    static class FastPrinter extends PrintWriter
    {
        public FastPrinter(OutputStream out)
        {
            super(out);
        }

        public FastPrinter(Writer out)
        {
            super(out);
        }

    }
}

