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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.StringTokenizer;

public class Div3_724 {

	static class pair {
		long first;
		long second;

		public pair(long first, long second) {
			this.first = first;
			this.second = second;
		}

	}

	static void sort(int[] a) {
		ArrayList<Integer> l = new ArrayList<>();
		for (int i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

	static long power(int x, int y, int p) {
		if (y == 0)
			return 1;
		else if (y % 2 == 0) {
			long a = power(x, y / 2, p) % p;
			return (a * a) % p;
		}

		else {
			long a = power(x, y / 2, p) % p;
			return (x * (a * a) % p) % p;
		}

	}

	public static void main(String[] args) {
		FastReader sc = new FastReader();

		long x = sc.nextLong();
		long y = sc.nextLong();
		long m = sc.nextLong();

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

		long ans = 0;

		if (m <= min || m <= max) {
			System.out.println(0);
		} else {
			if (min <= 0 && max <= 0) {
				if (m <= min || m <= max) {
					System.out.println(0);
				} else {
					System.out.println(-1);
				}
			} else if (min < 0 && max > 0) {
				long c = (long) Math.ceil(Math.abs(min) / (double) max);
				min = min + c * max;
				ans += c;

				ans += count(min, max, m);
				System.out.println(ans);
			} else {
				ans = count(min, max, m);
				System.out.println(ans);
			}
		}

	}

	static long count(long min, long max, long m) {
		long count = 0;
		while (max < m) {
			long a = min + max;
			min = max;
			max = a;
			count++;
		}
		return count;
	}

}

class multiset {
	final private HashMap<Integer, ArrayList<Integer>> mset = new HashMap<>();

	public void add(int value, int index) {
		if (mset.containsKey(value)) {
			mset.get(value).add(index);
		}
	}

	public int delete(int value) {
		if (mset.containsKey(value)) {
			ArrayList<Integer> arr = mset.get(value);
			int ret = arr.get(arr.size() - 1);
			arr.remove(arr.size() - 1);
			if (arr.size() == 0) {
				mset.remove(value);
			}
			return ret;
		} else {
			return -1;
		}
	}

	public boolean contains(int value) {
		return mset.containsKey(value);
	}
}

class FastReader {
	BufferedReader br;
	StringTokenizer st;

	public FastReader() {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

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

	int nextInt() {
		return Integer.parseInt(next());
	}

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

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

	int[] readArray(int n) {
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = nextInt();
		return a;
	}

	String nextLine() {
		String str = "";
		try {
			str = br.readLine();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return str;
	}
}
