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 sys, math
def rs():
    return sys.stdin.readline().strip()
def ri():
    return int(sys.stdin.readline().strip())
def ras():
    return sys.stdin.readline().strip().split()
def rai():
    return map(int,sys.stdin.readline().strip().split())



def fib2(aa, bb, n):

    def m2x2pow(a,b):
        return [
            [a[0][0]*b[0][0] + a[0][1]*b[0][1], a[0][0]*b[1][0] + a[0][1]*b[1][1]],
            [a[1][0]*b[0][0] + a[1][1]*b[0][1], a[1][0]*b[1][0] + a[1][1]*b[1][1]],
        ]

    def binary_pow(a,n):
        r = [
            [1, 0],
            [0, 1]
        ]
        while n:
            if n % 2:
                n -= 1
                r = m2x2pow(r,a)
            a = m2x2pow(a,a)
            n /= 2

        return r

    if n == 1:
        return aa
    elif n== 2:
        return bb

    r = binary_pow([[0, 1], [1, 1]], n-3)


    return aa*r[0][1] + bb*r[1][1]


def bs(x,y,l,r,v):
    if l > r:
        return l
    m = (r + l) / 2

    t = fib2(x,y,m)
    if v == t:
        return m
    if v > t:
        return bs(x,y, m+1,r,v)
    else:
        return bs(x,y,l,m-1,v)



def solve():

    M = 1000

    x,y,m = rai()

    x,y = min(x,y), max(x,y)


    if y >= m:
        return 0

    if y <=0 and y < m:
        return -1

    count = 0

    if x < 0:
        count = (y - x) / y + 1
        x,y = y, x + y * count

    if y >= m:
        return count






    return bs(x,y,0,M,m) + count - 3



print solve()