Problem:
Score : 200 points

Problem Statement

Given are integers a,b,c and d.
If x and y are integers and a \leq x \leq b and c\leq y \leq d hold, what is the maximum possible value of x \times y?

Constraints

-10^9 \leq a \leq b \leq 10^9

-10^9 \leq c \leq d \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

a b c d

Output

Print the answer.

Sample Input 1

1 2 1 1

Sample Output 1

2

If x = 1 and y = 1 then x \times y = 1.
If x = 2 and y = 1 then x \times y = 2.
Therefore, the answer is 2.

Sample Input 2

3 5 -4 -2

Sample Output 2

-6

The answer can be negative.

Sample Input 3

-1000000000 0 -1000000000 0

Sample Output 3

1000000000000000000

Solution in C# (Mono-mcs 6.8.0.105) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography.X509Certificates;

    public class Program
    {
        public static void Main(string[] args)
        {
            new B().test();
        }
    }

    public class A
    {
        public void test()
        {
            // 普通の数値
            var zero = CommonRead.ReadInt();

            if (zero == 0)
            {
                Console.WriteLine(1);
            }
            else
            {
                Console.WriteLine(.0);
            }

        }
    }

    public class B
    {
        public void test()
        {
            // 普通の数値
            var abcd = CommonRead.ReadLongL();

            List<long> answer = new List<long>();

            for (int count = 0; count < 2; count++)
            {
                answer.Add(abcd[count] * abcd[2]);
                answer.Add(abcd[count] * abcd[3]);
            }

            var t = answer[0];

            for(int count =1; count < answer.Count; count++)
            {
                if (t < answer[count]) t = answer[count];
            }

                Console.WriteLine(t);

        }
    }


    public class C
    {
        public void test()
        {
            // 普通の数値
            var hwk = CommonRead.ReadIntL();

            var row = new List<List<string>>();

            for (int count = 0; count < hwk[0]; count++)
            {
                row.Add(CommonRead.ReadStrL());
            }

            // 答えの.数
            var equal = hwk[2];

            Console.WriteLine(0);


        }
    }

    public class D
    {
        public void test()
        {
            // 普通の数値
            var n = CommonRead.ReadLong();
            var a = CommonRead.ReadLongL().OrderByDescending(x => x).ToList();
            /*
            //.GroupBy(x => x).Select(x => new { key = x.Key, count = x.Count() });

            // 繰り返し
            long exec = 0;
            bool zenkai = false;

            for (int i = 1; i<n; i++)
            {

                if (zenkai)
                {
                    exec += a[i - 2];
                }
                else
                {
                    exec += a[i - 1];
                }

                if (a[i] == a[i-1])
                {
                    zenkai = true;
                }

            // 答えの数
            Console.WriteLine(exec);
            }
            */
            long ans = 0;
            for (int i = 0; i < n - 1; ++i)
            {
                ans += a[(i + 1) / 2];
            }
            Console.WriteLine(ans);




        }
    }


    static class CommonRead
    {
        public static string ReadStr()
        {
            return Console.ReadLine();
        }
        public static string[] ReadStrA()
        {
            return ReadStr().Split(' ');
        }
        public static List<string> ReadStrL()
        {
            return ReadStrA().ToList();
        }
        public static int ReadInt()
        {
            return Convert.ToInt32(ReadStr());
        }
        public static int[] ReadIntA()
        {
            return ReadStrA().Select(s => Convert.ToInt32(s)).ToArray();
        }
        public static List<int> ReadIntL()
        {
            return ReadStrA().Select(s => Convert.ToInt32(s)).ToList();
        }
        public static long ReadLong()
        {
            return Convert.ToInt64(ReadStr());
        }
        public static long[] ReadLongA()
        {
            return ReadStrA().Select(s => Convert.ToInt64(s)).ToArray();
        }
        public static List<long> ReadLongL()
        {
            return ReadStrA().Select(s => Convert.ToInt64(s)).ToList();
        }

        public static decimal ReadDecimal()
        {
            return Convert.ToDecimal(ReadStr());
        }
        public static decimal[] ReadDecimalA()
        {
            return ReadStrA().Select(s => Convert.ToDecimal(s)).ToArray();
        }
        public static List<decimal> ReadDecimalL()
        {
            return ReadStrA().Select(s => Convert.ToDecimal(s)).ToList();
        }

        public static double ReadDouble()
        {
            return Convert.ToDouble(ReadStr());
        }
        public static double[] ReadDoubleA()
        {
            return ReadStrA().Select(s => Convert.ToDouble(s)).ToArray();
        }
        public static List<double> ReadDoubleL()
        {
            return ReadStrA().Select(s => Convert.ToDouble(s)).ToList();
        }

    }