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.*;
        public class ProblemC {
            /**
             * @param args
             */
            public static void main(String[] args) {
                Scanner input=new Scanner(System.in);
            
                
                long x=input.nextLong();
                long y=input.nextLong();
                long m=input.nextLong();
                long smaller=0;
                long bigger=0;
                long result=0;
                
                if(x<y)
                {
                    smaller=x;
                    bigger=y;
                }else if (x>y)
                {
                  smaller=y;
                  bigger=x;
                }else
                {
                    smaller=x;
                    bigger=y;
                }
                if(x>=m||y>=m)
                {
                    System.out.println(result);
                    return;
                    
                }
                if(smaller<0&&bigger<0&&m>=0||bigger==0)
                {
                    System.out.println("-1");
                    return;
                }
                if (smaller<0&&bigger<0&&m<0&&bigger<m&&smaller<m) {
                    System.out.println(-1);
                    return;
                }
else
                {  
                    if(smaller<0&&-smaller>10000000)
                    {
                        result+=(-smaller)/bigger;
                         
                        long mod=(-smaller)%bigger;
                        if(mod==0)
                        {
                            smaller=0;
                            //smaller become 0  after nmber of operation =result
                        }else
                        {
                            result++;
                            //we need to another operation and smaller become >0 
                            //NewSmaller =
                            smaller=smaller+(result)*(bigger);
                        }
                        
                    }

                    while(smaller<m&&bigger<m)
                    {
                        if(smaller<=bigger)
                        {
                            smaller=smaller+bigger; 
                            
                        }else
                        {
                            bigger=bigger+smaller;
                        }
                        
                        
                        
                        result++;
                    }
                
                System.out.println(result);
                           
                }       
              
            }
        
        }
