Problem:
Score : 300 points

Problem Statement

Takahashi, Aoki and Snuke love cookies. They have A, B and C cookies, respectively. Now, they will exchange those cookies by repeating the action below:

Each person simultaneously divides his cookies in half and gives one half to each of the other two persons.

This action will be repeated until there is a person with odd number of cookies in hand.

How many times will they repeat this action?
Note that the answer may not be finite.

Constraints

1 ≤ A,B,C ≤ 10^9

Input

Input is given from Standard Input in the following format:

A B C

Output

Print the number of times the action will be performed by the three people, if this number is finite.
If it is infinite, print -1 instead.

Sample Input 1

4 12 20

Sample Output 1

3

Initially, Takahashi, Aoki and Snuke have 4, 12 and 20 cookies. Then,

After the first action, they have 16, 12 and 8.

After the second action, they have 10, 12 and 14.

After the third action, they have 13, 12 and 11.

Now, Takahashi and Snuke have odd number of cookies, and therefore the answer is 3.

Sample Input 2

14 14 14

Sample Output 2

-1

Sample Input 3

454 414 444

Sample Output 3

1

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

//#pragma warning disable

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;

public class Test
{
    public class Tree
    {
        public Node Root;
        public Node[] Leaves;  // 注意：根はLeavesに含まれません

        public Tree(IEnumerable<long>[] adjacency_list)
        {
            Root = Node.FromAdjacencyList(adjacency_list, 0, null);

            Leaves = SearchLeaves(Root).ToArray();
        }

        private IEnumerable<Node> SearchLeaves(Node v)
        {
            if (v.Children.Length == 0)
            {
                return new[] { v };
            }

            var ret = new List<Node>();

            foreach (var c in v.Children)
            {
                ret.AddRange(SearchLeaves(c));
            }

            return ret;
        }

        public class Node
        {
            public Node Parent;
            public Node[] Children;
            public long Id;
            public int Degree { get { return Children.Length; } }

            public Node(Node parent, Node[] children, long id) { Parent = parent; Children = children; Id = id; }

            public override string ToString()
            {
                return Id + (Children.Length == 0 ? "" : "[" + string.Join(",", Children.Select(x => x.ToString())) + "]");
            }

            public static Node FromAdjacencyList(IEnumerable<long>[] adjacency_list, long rootIndex = 0, long? parentIndex = null)
            {
                var arr = (adjacency_list[rootIndex] as long[]) ?? adjacency_list[rootIndex].ToArray();

                var children = arr.Where(x => x != parentIndex).Select(x => FromAdjacencyList(adjacency_list, x, rootIndex)).ToArray();

                var root = new Node(null, children, rootIndex);

                foreach (var c in children)
                {
                    c.Parent = root;
                }

                return root;
            }
        }

        public override string ToString()
        {
            return Root.ToString();
        }
    }

    public static void Main()
    {
        var N = long.Parse(Console.ReadLine());

        var adj = new List<long>[N];
        for (int i = 0; i < N; i++)
        {
            adj[i] = new List<long>();
        }

        for (var i = 0; i < N - 1; i++)
        {
            var line1 = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();

            adj[line1[0] - 1].Add(line1[1] - 1);
            adj[line1[1] - 1].Add(line1[0] - 1);
        }

        var tree = new Tree(adj);
        //Console.WriteLine(new Tree(adj).ToString());
        //Console.WriteLine(String.Join(",", new Tree(adj).Leaves.Select(x => x.Id)));

        var q = new Queue<Tree.Node>();
        foreach (var v in tree.Leaves)
        {
            q.Enqueue(v);
        }

        while (q.Count != 0)
        {
            var next = q.Dequeue();

            if (next.Parent == null)
            {
                // 根の子が0個
                Console.WriteLine("First");
                return;
            }

            if (next.Parent.Degree == 1)
            {
                if (next.Parent.Parent == null)
                {
                    // 全消し
                    Console.WriteLine("Second");
                    return;
                }

                // next と next.Parent のノードを除去
                next.Parent.Parent.Children = next.Parent.Parent.Children.Where(x => x != next.Parent).ToArray();
                if (next.Parent.Parent.Degree == 0)
                {
                    q.Enqueue(next.Parent.Parent);
                }
            }
            else
            {
                if (next.Parent.Children.All(x => x.Degree == 0))
                {
                    // next.Parentの子供が2個以上あり、全部 葉
                    Console.WriteLine("First");
                    return;
                }
                else
                {
                    // 後回し
                    q.Enqueue(next);
                }
            }
        }
    }
}