Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one. Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime. You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r. More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair (a, c) is not coprime.

The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).

Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.  If the counterexample does not exist, print the single number -1.

NoteIn the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are. In the second sample you cannot form a group of three distinct integers, so the answer is -1. In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.

using System;

namespace CSharp
{
    public class _483A
    {
        public static void Main()
        {
            string[] tokens = Console.ReadLine().Split();

            long l = long.Parse(tokens[0]);
            long r = long.Parse(tokens[1]);

            for (long a = l; a <= r; a++)
            {
                for (long b = a + 1; b <= r; b++)
                {
                    if (GCD(a, b) == 1)
                    {
                        for (long c = b + 1; c <= r; c++)
                        {
                            if (GCD(b, c) == 1 && GCD(a, c) != 1)
                            {
                                Console.WriteLine($"{a} {b} {c}");
                                return;
                            }
                        }
                    }
                }
            }

            Console.WriteLine(-1);
        }

        private static long GCD(long x, long y)
        {
            return x == 0 ? y : GCD(y % x, x);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _275_Task_A
{
    class Program
    {
        static void Main(string[] args)
        {
            long r, l, d;
            string[] str = Console.ReadLine().Split(' ');
            l = long.Parse(str[0]);
            r = long.Parse(str[1]);
            d=r-l;
    if(d>2)
    {
        if(l%2==0)
            Console.WriteLine("{0} {1} {2}\n",l,l+1,l+2);
        else
            Console.WriteLine("{0} {1} {2}\n", l + 1, l + 2, l + 3);
    }
    else if(d<2)
        Console.WriteLine("-1\n");
    else
    {
        if(l%2==0)
            Console.WriteLine("{0} {1} {2}\n", l, l + 1, l + 2);
        else
            Console.WriteLine("-1\n");
    }
        }
    }
}

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

namespace CodeForce
{
    class Program
    {
        static void Main(string[] args)
        {
            string []In = Console.ReadLine().Split(' ');
            long l = long.Parse(In[0]);
            long r = long.Parse(In[1]);
            for (long i = l; i <= r; i++)
            {
                for (long j = i + 1; j <= r; j++)
                {
                    for (long u = i; u < j & __(i, j); u++)
                    {
                        if (!__(i, u) & !__(u, j)) { Console.WriteLine("{0} {1} {2}", i, u, j); return; }
                    }
                }
            }
            Console.WriteLine(-1);
        }
        static bool __(long num1, long num2)
        {
            if (num1 % num2 == 0) return true;
            if (num1 % num2 == 1) return false;
            return __(num2, num1 % num2);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Counterexample
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] nums = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
            if(nums[0]%2 !=0)
            {
                nums[0]++;
            }
            if(Math.Abs(nums[1]-nums[0])<2)
            {
                Console.WriteLine(-1);
            }
            else
            {
                Console.WriteLine("{0} {1} {2}",nums[0],nums[0]+1,nums[0]+2);
            }

        }

    }
}

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

namespace SolvingAlgorithms
{
    class Program
    {
        static void Main(string[] args)
        {

            string input;
            input = Console.ReadLine();
            string[] inp = input.Split(' ');
            Int64 a = Convert.ToInt64(inp[0]);
            Int64 c = Convert.ToInt64(inp[1]);
            Int64 counter = c - a;
            Boolean breaking = false;
            if (counter >=2 )
            {
                for (Int64 i = 0; i < counter-1 && !breaking; i++)
                {
                    for (Int64 j = 0; j < counter-1  && !breaking; j++)
                    {
                        for (Int64 x = i+1; x < counter-i+1 &&!breaking; x++)
                        {
                            Int64 o = a + i;
                            Int64 u = a + x;
                            Int64 q = c - j;
                            if (GCD(o,u)==1 && GCD(u, q)==1 && GCD(o,q)!=1)
                            {
                                breaking = true;

                                Console.WriteLine(o + " " + u + " " + q);
                            }
                        }
                    }

                }
            }
            else
            {
                Console.WriteLine("-1");
                breaking = true;
            }
            if (!breaking)
            {
                Console.WriteLine("-1");
            }
        }

        private static Int64 GCD(Int64 a, Int64 b)
        {
            while (a != 0 && b != 0)
            {
                if (a > b)
                    a %= b;
                else
                    b %= a;
            }

            return a == 0 ? b : a;
        }
    }
}

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Sharp
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b, c = 0;
            var s = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
            a = Int64.Parse(s[0]);
            b = Int64.Parse(s[1]);
            for (var i = a; i <= b; i++)
            {
                for(var j = i;j<=b;++j)
                    for (var k = j; k <= b; ++k)
                    {
                        if (GCD(i, j) != 1 || GCD(j, k) != 1 || GCD(i, k) == 1) continue;
                        Console.WriteLine("{0} {1} {2}", i, j, k);
                        return;
                    }
            }
            Console.WriteLine(-1);
        }

        public static long GCD(long a, long b)
        {
            while (true)
            {
                if (b == 0) return a;
                var a1 = a;
                a = b;
                b = a1%b;
            }
        }
    }
}

using System;
using System.Collections.Generic;

public class Test
{
    public static Dictionary<ulong, int> Factors(ulong N)
    {
        ulong max = ((ulong)Math.Sqrt(N)) + 1;
        Dictionary<ulong, int> facts = new Dictionary<ulong, int>();
    	for(ulong n = 2; n * n < N; n++)
        {
            int power = 0;
            while(N % n == 0)
            {
               N = N / n;
               power++;
            }
            if(power > 0)
               facts.Add(n, power);
        }
        return facts;
    }

    public static int SmallFacts(ulong N)
    {
        int factorsMask = 0;
        ulong[] primes = {2,3,5,7,9,11,13,17,19,23,29,31,37,41,43,47};
    	for(int n = 0; n < primes.Length; n++)
        {
             int pwr = 0;
             while(N % primes[n] == 0)
             {
             	pwr++; N = N / primes[n];
             }
             if(pwr > 0) factorsMask |= (1 << n);
             if(N <= 1) break;
        }
        return factorsMask;
    }

    public static string PrintMask(int mask)
    {
         string r= "";
         for(int i = 0; i < 32; i++)
             r += ((mask & (1 << i)) != 0) ? "1" : "0";
         return r;
    }

	public static void Main()
	{
		string[] tok = Console.ReadLine().Split(' ');
        ulong l = UInt64.Parse(tok[0]);
        ulong r = UInt64.Parse(tok[1]);

        int D = (int)(r - l) + 1;
        int[] factors = new int[D];
        for(ulong i = l; i <= r; i++)
		{
            factors[(int)(i - l)] = SmallFacts(i);
            //Console.WriteLine("{0} -> {1}", i, PrintMask(factors[(int)(i -l)]));
        }

        int found = -1;
        for(int i = 0; i < D; i++)
        {
            for(int j = i + 1; j < D; j++)
            {
                if((factors[i] & factors[j]) != 0)
                {
                    //Console.WriteLine("found {0} and {1}", i, j);
                	for(int k = 1; k < D; k++)
                	{
                        if((k != i) && (k != j) && (factors[k] & factors[i]) == 0 && (factors[k] & factors[j]) == 0)
                        {
                             Console.WriteLine("{0} {1} {2}", (ulong)i + l, (ulong)k + l, (ulong)j + l);
                             return;
                        }
                	}
                }
            }
        }
        Console.WriteLine("-1");

	}
}

using System;

namespace Counterexample
{
    class Program
    {

        private static bool isPrime(long k){
            for (long i=2; i<=Math.Sqrt(k); i++){
                if (k%i == 0){
                    return false;
                }
            }
            return true;
        }

        private static long gcd(long a, long b){
            if (b==0){
                return a;
            }
            return gcd(b, a%b);
        }

        static void Main(string[] args)
        {
            string [] input = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.None);

            long l = long.Parse(input[0]);
            long r = long.Parse(input[1]);

            long a = l, b=0, c=0;
            bool foundB = false, foundC = false;

            long i = l;

            while(i<=r){
                if (foundC){
                    break;
                }

                a = i;
                long j = a;
                while(j<= r){
                    if (gcd(a, j) ==1){
                        b = j;
                        foundB = true;
                        break;
                    }
                    j++;
                }
                if (foundB){
                    long k = b;
                    while( k<= r){
                        if (gcd(b, k) == 1 && gcd(a, k) > 1){
                            c = k;
                            foundC = true;
                            break;
                        }
                        k++;
                    }
                }
                i++;
            }

            if (foundB && foundC){
                Console.WriteLine(a+" "+b+" "+c);
            }else{
                Console.WriteLine(-1);
            }
        }
    }
}

using System;

namespace Counterexample
{
    class Program
    {

        private static long gcd(long a, long b){
            if (b==0){
                return a;
            }
            return gcd(b, a%b);
        }

        static void Main(string[] args)
        {
            string [] input = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.None);

            long l = long.Parse(input[0]);
            long r = long.Parse(input[1]);

            long a = l, b=0, c=0;
            bool foundB = false, foundC = false;

            long i = l;

            while(i<=r){
                if (foundC){
                    break;
                }

                a = i;
                long j = a;
                while(j<= r){
                    if (gcd(a, j) ==1){
                        b = j;
                        foundB = true;
                        break;
                    }
                    j++;
                }
                if (foundB){
                    long k = b;
                    while( k<= r){
                        if (gcd(b, k) == 1 && gcd(a, k) > 1){
                            c = k;
                            foundC = true;
                            break;
                        }
                        k++;
                    }
                }
                i++;
            }

            if (foundB && foundC){
                Console.WriteLine(a+" "+b+" "+c);
            }else{
                Console.WriteLine(-1);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Xsl;

namespace Codeforces
{
	class Program
	{
		static void Main(string[] args)
		{
			string input1 = Console.ReadLine();
			//string input2 = Console.ReadLine();

			//string input3 = Console.ReadLine();
			//string input4 = Console.ReadLine();

			var inputs1 = input1.Split(new[] { ' ', '}', '{' , ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs2 = input2.Split(new[] { ' ', '}', '{', ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs3 = input3.Split(new[] { ' ', '}', '{', ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();
			//var inputs4 = input4.Split(new[] { ' ', '}', '{', ',' }, StringSplitOptions.RemoveEmptyEntries).Select(long.Parse).ToArray();

			long l = inputs1[0];
			long r = inputs1[1];

			if (r - l < 2)
			{
				Console.WriteLine(-1);
				return;
			}

			if (r - l == 2)
			{
				if (l % 2 > 0)
				{
					Console.WriteLine(-1);
				}
				else
				{
					Console.WriteLine($"{l} {l + 1} {l + 2}");
				}

				return;
			}

			if (l % 2 > 0)
			{
				Console.WriteLine($"{l + 1} {l + 2} {l + 3}");
			}
			else
			{
				Console.WriteLine($"{l} {l + 1} {l + 2}");
			}
		}

		static long Factorial(long a)
		{
			return a > 1 ? a * Factorial(a - 1) : 1;
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Counterexample483A
{
    class Program
    {
        static void Main(string[] args)
        {

            var line = Console.ReadLine();
            var numbers = line.Split(' ');
            long l = Convert.ToInt64(numbers[0]);
            long r = Convert.ToInt64(numbers[1]);
            if ( l % 2 != 0)
            {
                l++;
            }

            if (Math.Abs(r-l) < 2)
            {
                Console.WriteLine("-1");
            }
            else
            {
                Console.WriteLine(l + " " + (l+1) + " " + (l + 2));
            }

            //Console.ReadKey();

        }
    }
}

using System;

class A {
	static void Main() {
		string s = Console.ReadLine();
		string[] t = s.Split(' ');
		long a = Convert.ToInt64(t[0]);
		long b = Convert.ToInt64(t[1]);
		if (a % 2 == 1) a++;
		if (b-a<=1) {
			Console.WriteLine(-1);
			return;
		}
		Console.WriteLine("{0} {1} {2}", a, a+1, a+2);
	}
}

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

namespace ConsoleApplication1
{
    class Program
    {
        static int[] Plustoarray(int[] array, int plus)//changes array and sends new array
        {
            array[array.Length - 1] += plus;
            for (int i = array.Length - 1; i > 0; i--)
            {
                while (array[i] > 9)
                {
                    array[i] -= 10;
                    array[i - 1]++;
                }
            }
            if (array[0] > 9)
            {
                int[] newarray = new int[array.Length + 1];
                for (int i = 0; i < array.Length; i++)
                {
                    newarray[1 + i] = array[i];
                }
                while (newarray[1] > 9)
                {
                    newarray[1] -= 10;
                    newarray[0]++;
                }
                return newarray;
            }
            else
                return array;
        }
        static void MinusTwoArrays(int[] small, int[] big)//changes big to be big-small
        {
            for (int i = 0; i < small.Length; i++)
            {
                if (small.Length != big.Length)
                    big[big.Length - small.Length + i] -= small[i];
                else
                    big[i] -= small[i];
            }
            for (int i = 1; i < big.Length; i++)
            {
                if (big[i] < 0)
                {
                    big[i] += 10;
                    big[i - 1]--;
                }
            }
        }
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string small = "", big = "";
            for (int i = 1; i < s.Length; i++)
            {
                if (s[i] == ' ')
                {
                    small = s.Substring(0, i);
                    big = s.Substring(i + 1);
                    break;
                }
            }
            int[] min = new int[small.Length];
            int[] max = new int[big.Length];
            for (int i = 0; i < min.Length; i++)
            {
                min[i] = small[i] - 48;
            }
            for (int i = 0; i < max.Length; i++)
            {
                max[i] = big[i] - 48;
            }
            MinusTwoArrays(min, max);
            int length = max[max.Length - 1];
            if(max.Length>1)
                length+=max[max.Length - 2] * 10;
            if (length < 2)
                Console.WriteLine("-1");
            else
            {
                if (length == 2 && min[min.Length - 1] % 2 == 1)
                    Console.WriteLine("-1");
                else
                {
                    if (min[min.Length - 1] % 2 == 1)
                    {
                        min = Plustoarray(min, 1);
                    }
                    for (int i = 0; i < min.Length; i++)
                    {
                        Console.Write(min[i]);
                    }
                    Console.Write(" ");
                    min = Plustoarray(min, 1);
                    for (int i = 0; i < min.Length; i++)
                    {
                        Console.Write(min[i]);
                    }
                    Console.Write(" ");
                    min = Plustoarray(min, 1);
                    for (int i = 0; i < min.Length; i++)
                    {
                        Console.Write(min[i]);
                    }
                }
            }
        }
    }
}

using System;
using System.Linq;
class Solution
{
    public static void Main()
    {
        long[] minp = Console.ReadLine().Split().Select(Int64.Parse).ToArray();
        long l = minp[0], r = minp[1], j =0, i= 0;
        bool check = true;
        if (r - l > 1)
        {
            for (i = l; i <= r - 2; i++)
            {
                j = i + 2;
                if (co_prime(i, i + 1))
                {
                    do
                    {
                        if (co_prime(i + 1, j))
                        {
                            if (!co_prime(i, j))
                            { check = false; break; }
                        }
                        j++;
                    } while (j <= r);
                    if (!check)
                        break;
                }
            }
        }
        else
            check = true;
        if (check == false) Console.WriteLine(i + " " + (i + 1) + " " + j);
        else
            Console.WriteLine("-1");

    }
    public static bool co_prime(long a, long b)
    {
        bool primeness = true;
        long div = Math.Min(a, b);
        for(long i = 2; i <= 9; i++)
        {
            if (a % i == 0 && b % i == 0)
            { primeness = false; break; }
        }
        return primeness;
    }
}

using System;
class Program
    {
        public static void Main(string[] args)
        {
            long l, r;
            {
                string[] input = Console.ReadLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                l = long.Parse(input[0]);
                r = long.Parse(input[1]);
            }
            if (r - l < 2L || r-l==2L && l%2L==1) Console.WriteLine("-1");
            else
            {
                if (l % 2L == 0) Console.WriteLine("{0} {1} {2}", l, l + 1L, l + 2L);
                else Console.WriteLine("{0} {1} {2}", l + 1L, l + 2L, l + 3L);
            }
        }
    }

using System;
using System.Collections.Generic;
using System.Linq;
using Solver.Ex;
using Debug = System.Diagnostics.Debug;
using Watch = System.Diagnostics.Stopwatch;
using StringBuilder = System.Text.StringBuilder;
namespace Solver
{
    public class Solver
    {
        public void Solve()
        {
            var l = sc.Long();
            var r = sc.Long();
            for (long a = l; a <= r; a++)
                for (long b = a + 1; b <= r; b++)
                    for (long c = b + 1; c <= r; c++)
                    {
                        var ab = MathEx.GCD(a, b);
                        var bc = MathEx.GCD(b, c);
                        var ac = MathEx.GCD(a, c);
                        if (ab == 1 && bc == 1 && ac > 1)
                        {
                            IO.Printer.Out.WriteLine("{0} {1} {2}", a, b, c);
                            return;
                        }
                    }
            IO.Printer.Out.WriteLine(-1);
        }
        internal IO.StreamScanner sc;
    }
    #region Main and Settings
    static class Program
    {
        static void Main(string[] arg)
        {
#if DEBUG
            var errStream = new System.IO.FileStream(@"..\..\dbg.out", System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.ReadWrite);
            Debug.Listeners.Add(new System.Diagnostics.TextWriterTraceListener(errStream, "debugStream"));
            Debug.AutoFlush = false;
            var sw = new Watch(); sw.Start();
            try
            {
#endif
                IO.Printer.Out.AutoFlush = true;
                var solver = new Solver();
                solver.sc = new IO.StreamScanner(Console.OpenStandardInput());
                solver.Solve();
#if DEBUG
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine(ex.Message);
                Console.Error.WriteLine(ex.StackTrace);
            }
            finally
            {
                sw.Stop();
                Console.ForegroundColor = ConsoleColor.Green;
                Console.Error.WriteLine("Time:{0}ms", sw.ElapsedMilliseconds);
                Debug.Close();
                System.Threading.Thread.Sleep(System.Threading.Timeout.Infinite);
            }
#endif
        }

    }
    #endregion
}
#region IO Helper
namespace Solver.IO
{
    public class Printer : System.IO.StreamWriter
    {
        static Printer() { Out = new Printer(Console.OpenStandardOutput()) { AutoFlush = false }; }
        public static Printer Out { get; set; }
        public override IFormatProvider FormatProvider { get { return System.Globalization.CultureInfo.InvariantCulture; } }
        public Printer(System.IO.Stream stream) : base(stream, new System.Text.UTF8Encoding(false, true)) { }
        public Printer(System.IO.Stream stream, System.Text.Encoding encoding) : base(stream, encoding) { }
        public void Write<T>(string format, IEnumerable<T> source) { Write(format, source.OfType<object>().ToArray()); }
        public void WriteLine<T>(string format, IEnumerable<T> source) { WriteLine(format, source.OfType<object>().ToArray()); }
    }
    public class StreamScanner
    {
        public StreamScanner(System.IO.Stream stream) { iStream = stream; }
        private readonly System.IO.Stream iStream;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        private bool eof = false;
        public bool IsEndOfStream { get { return eof; } }
        const byte lb = 33, ub = 126, el = 10, cr = 13;
        public byte read()
        {
            if (eof) throw new System.IO.EndOfStreamException();
            if (ptr >= len) { ptr = 0; if ((len = iStream.Read(buf, 0, 1024)) <= 0) { eof = true; return 0; } }
            return buf[ptr++];
        }
        public char Char() { byte b = 0; do b = read(); while (b < lb || ub < b);            return (char)b; }
        public char[] Char(int n) { var a = new char[n]; for (int i = 0; i < n; i++) a[i] = Char(); return a; }
        public char[][] Char(int n, int m) { var a = new char[n][]; for (int i = 0; i < n; i++) a[i] = Char(m); return a; }
        public string Scan()
        {
            if (eof) throw new System.IO.EndOfStreamException();
            StringBuilder sb = null;
            var enc = System.Text.UTF8Encoding.Default;
            do
            {
                for (; ptr < len && (buf[ptr] < lb || ub < buf[ptr]); ptr++) ;
                if (ptr < len) break;
                ptr = 0;
                if ((len = iStream.Read(buf, 0, 1024)) <= 0) { eof = true; return ""; }
            } while (true);
            do
            {
                var f = ptr;
                for (; ptr < len; ptr++)
                    //if (buf[ptr] < lb || ub < buf[ptr])
                    if (buf[ptr] == cr || buf[ptr] == el)
                    {
                        string s;
                        if (sb == null) s = enc.GetString(buf, f, ptr - f);
                        else { sb.Append(enc.GetChars(buf, f, ptr - f)); s = sb.ToString(); }
                        ptr++; return s;
                    }
                if (sb == null) sb = new StringBuilder(enc.GetString(buf, f, len - f));
                else sb.Append(enc.GetChars(buf, f, len - f));
                ptr = 0;

            }
            while (!eof && (len = iStream.Read(buf, 0, 1024)) > 0);
            eof = true; return (sb != null) ? sb.ToString() : "";
        }
        public long Long()
        {
            long ret = 0; byte b = 0; bool isMynus = false;
            const byte zr = 48, nn = 57, my = 45;
            do b = read();
            while (b != my && (b < zr || nn < b));
            if (b == my) { isMynus = true; b = read(); }
            for (; true; b = read())
                if (b < zr || nn < b)
                    return isMynus ? -ret : ret;
                else ret = ret * 10 + b - zr;
        }
        public int Integer()
        {
            int ret = 0; byte b = 0; bool isMynus = false;
            const byte zr = 48, nn = 57, my = 45;
            do b = read();
            while (b != my && (b < zr || nn < b));
            if (b == my) { isMynus = true; b = read(); }
            for (; true; b = read())
                if (b < zr || nn < b)
                    return isMynus ? -ret : ret;
                else ret = ret * 10 + b - zr;
        }
        public double Double() { return double.Parse(Scan(), System.Globalization.CultureInfo.InvariantCulture); }
        public string[] Scan(int n) { var a = new string[n]; for (int i = 0; i < n; i++) a[i] = Scan(); return a; }
        public double[] Double(int n) { var a = new double[n]; for (int i = 0; i < n; i++) a[i] = Double(); return a; }
        public int[] Integer(int n) { var a = new int[n]; for (int i = 0; i < n; i++) a[i] = Integer(); return a; }
        public long[] Long(int n) { var a = new long[n]; for (int i = 0; i < n; i++)a[i] = Long(); return a; }
        public void Flush() { iStream.Flush(); }
    }
}
#endregion
#region Extension
namespace Solver.Ex
{
    static public partial class EnumerableEx
    {
        static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
        static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") { return string.Join(st, ie); }
        static public T[] Enumerate<T>(this int n, Func<int, T> f) { var a = new T[n]; for (int i = 0; i < n; i++) a[i] = f(i); return a; }
    }
}
#endregion
#region gcd,lcm
static public partial class MathEx
{

    static public long GCD(long x, long y)
    {
        byte i = 0;
        while (x != 0 && y != 0)
        {
            if (i == 0)
                y %= x;
            else x %= y;
            i ^= 1;
        }
        return x == 0 ? y : x;
    }

}
#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
            var init = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var l = init[0];
            var r = init[1];

            var candidates = new List<long>();

            for (long i = l; i <= r; i++)
            {
                for (long j = i + 1; j <= r; j++)
                {
                    for (long k = j + 1; k <= r; k++)
                    {
                        if (coprime(j, k) && coprime(i, j) && !coprime(i, k))
                        {
                            Console.WriteLine("{0} {1} {2}", i, j, k);
                            return;
                        }
                    }
                }
            }

                Console.WriteLine(-1);
            Console.ReadLine();
        }

        public static long GCD(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return GCD(b, a % b);
        }

        public static bool coprime(long a, long b)
        {
            return GCD(a, b) == 1;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication26
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            long l = Int64.Parse(input[0]);
            long r = Int64.Parse(input[1]);
            if (r - l + 1 < 3) Console.WriteLine(-1);
            else
                if (l % 2 == 0) Console.WriteLine("{0} {1} {2}", l, l + 1, l + 2);
                else
                    if (r - l + 1 > 3) Console.WriteLine("{0} {1} {2}", l + 1, l + 2, l + 3);
                    else
                        Console.WriteLine(-1);
            Console.ReadLine();
        }
    }
}

using System;

class A483 {
    public static void Main() {
        var line = Console.ReadLine().Split();
        var l = long.Parse(line[0]);
        var r = long.Parse(line[1]);
        switch (r - l) {
            case 0L: case 1L: l = -1; break;
            case 2L: if ((l & 1) != 0) l = -1; break;
            default: if ((l & 1) != 0) ++l; break;
        }
        if (l == -1L) Console.WriteLine(-1);
        else Console.WriteLine($"{l} {l + 1} {l + 2}");
    }
}

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

namespace Counterexample
{
    class Program
    {
        static void Main(string[] args)
        {
            string str_Inputs = Console.ReadLine();
            string[] arr_Inputs = str_Inputs.Split(' ');
            long num_L = Convert.ToInt64(arr_Inputs[0]);
            long num_R = Convert.ToInt64(arr_Inputs[1]);
            bool flag = false;

            for (long i = num_L; i <= num_R; i++)
            {
                for (long j = i + 1; j <= num_R; j++)
                {
                    for (long k = j + 1; k <= num_R; k++)
                    {
                        if (Coprime(i, j) && Coprime(j, k) && !Coprime(i, k))
                        {
                            flag = true;
                            Console.Write( i + " " + j + " " + k);
                            return;
                        }
                    }
                }
            }
            if (!flag)
            {
                Console.Write("-1");
            }

            Console.Read();
        }

        public static bool Coprime(long x, long y)
        {
            while(y!=0)
            {
                long temp = y;
                y = x % y;
                x = temp;
            }
            return (x == 1);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Numerics;

public static class solver
{
    static long GCD(long a, long b)
    {
        while (b != 0) {
            var rem = a % b;
            a = b;
            b = rem;
        }
        return a;
    }

    public static void Main()
    {
        var input = Console.ReadLine().Split(null);
        var l = long.Parse(input[0]);
        var r = long.Parse(input[1]);

        long a = 0, b = 0, c = 0;
        bool found = false;
        for (a = l; a <= r; a++) {
            for (b = a + 1; b <= r; b++) {
                for (c = b + 1; c <= r; c++) {
                    if (GCD(a, b) == 1 && GCD(b, c) == 1 && GCD(a, c) > 1) {
                        found = true;
                        goto brk;
                    }
                }
            }
        }
        brk:

        if (found)
            Console.WriteLine("{0} {1} {2}", a, b, c);
        else {
            Console.WriteLine(-1);
        }

#if !ONLINE_JUDGE
        Console.ReadLine();
#endif
    }
}

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

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = Console.ReadLine();
            ulong n = ulong.Parse(a.Split(' ')[0]);
            ulong p = ulong.Parse(a.Split(' ')[1]);

            for(ulong i=n;i<p;i++)
            {
                for (ulong j = i + 1; j < p; j++)
                {
                    for (ulong k = j + 1; k <= p; k++)
                    {
                        if (check(i, j, k))
                        {
                            Console.WriteLine(i.ToString() + " " + j.ToString() + " " + k.ToString());
                            return;
                        }
                    }
                }
            }

            Console.WriteLine("-1");

        }

        static bool check(ulong a,ulong b,ulong c)
        {
            if(gcd(a,b)==1 && gcd(b,c)==1 && gcd(a,c)!=1)
                return true;
            return false;
        }

        static ulong gcd(ulong x, ulong y)
        {
            if (y == 0)
            {
                return x;
            }
            else
            {
                return gcd(y, x % y);
            }
        }
    }
}

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

namespace a
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] str = Console.ReadLine().Split(' ');
            long l = long.Parse(str[0]);
            long r = long.Parse(str[1]);
            for (long i = l+2; i <= r; i++)
            {
                for (long j = l + 1; j < i; j++)
                {
                    for (long k = l; k < i; k++)
                    {
                        if (Gcd(i, j) == 1 && Gcd(j, k) == 1 && Gcd(i, k) != 1)
                        {
                            Console.WriteLine("{0} {1} {2}", k, j, i);
                            return;
                        }
                    }
                }
            }
            Console.WriteLine("-1");
        }
        static long Gcd(long a, long b)
        {
            if (a < b)
            {
                long tmp = a;
                a = b;
                b = tmp;
            }
            if (b == 0)
            {
                return a;
            }
            else return (Gcd(b, a % b));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Counterexample
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] nums = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
            if(nums[0]%2 !=0)
            {
                nums[0]++;
            }
            if(Math.Abs(nums[1]-nums[0])<2)
            {
                Console.WriteLine(-1);
            }
            else
            {
                Console.WriteLine("{0} {1} {2}",nums[0],nums[0]+1,nums[0]+2);
            }

        }

    }
}

using System;
using System.IO;
using System.Text;

namespace Counterexample
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            long l = Next();
            long r = Next();

            if (l%2 == 0 && l + 2 <= r)
            {
                writer.WriteLine("{0} {1} {2}", l, l + 1, l + 2);
            }
            else if (l%2 == 1 && l + 3 <= r)
            {
                writer.WriteLine("{0} {1} {2}", l + 1, l + 2, l + 3);
            }
            else
            {
                writer.WriteLine("-1");
            }
            writer.Flush();
        }

        private static long Next()
        {
            int c;
            long res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
using System.Linq;
public class Test
{
    public static void Main()
    {
        // your code goes here
        long[] num = Console.ReadLine().Trim().Split().Select(x => long.Parse(x)).ToArray();
        long len = num[1] - num[0] + 1;
        if( len <= 2){
            Console.WriteLine(-1);
        } else {
            if(len == 3){
                long a1 = GCD(num[0] , num[0] + 1);
                long a2 = GCD(num[0] + 1 , num[0] + 2);
                long a3 = GCD(num[0]  , num[0] + 2);
                if(a1 == 1 && a2 == 1 && a3 > 1){
                    Console.WriteLine(num[0] + " " + (num[0] + 1) + " " + (num[0] + 2));
                } else {
                    Console.WriteLine(-1);
                }
            } else {
                if(num[0] % 2 == 0)
                  Console.WriteLine((num[0]) + " " + (num[0] + 1) + " " + (num[0] + 2));
                else
                  Console.WriteLine((num[0] + 1) + " " + (num[0] + 2) + " " + (num[0] + 3));
            }
        }
    }

    public static long GCD(long a , long b){
        if(b == 0)
           return a;
        return GCD(b , a % b );
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;
using System.IO;
using System.Numerics;
using System.Globalization;
using System.Threading;

namespace probleme {
    class Program {
        static void Main(string[] args) {
            //Console.SetIn(new StreamReader("file.txt"));
            string[] s = Console.ReadLine().Split(' ');
            long l = long.Parse(s[0]), r = long.Parse(s[1]);
            long diff = r - l + 1;
            if (diff < 3) {
                Console.WriteLine(-1);
            } else {
                int[,] m = new int[55, 55];
                for (int p = 2; p < diff; p++) {
                    int start = (int)(p - (l % p));
                    if (start == p) {
                        start = 0;
                    }
                    for (int i = start; i < diff; i += p) {
                        for (int j = i + p; j < diff; j += p) {
                            m[i, j] = 1;
                        }
                    }
                }
                int a = 0, b = 0, c = 0;
                for (a = 0; a < diff; a++) {
                    for (b = a + 1; b < diff; b++) {
                        if (m[a, b] == 0) {
                            for (c = b + 1; c < diff; c++) {
                                if (m[b, c] == 0 && m[a, c] == 1) {
                                    goto Final;
                                }
                            }
                        }
                    }
                }
            Final:
                if (a == diff) {
                    Console.WriteLine(-1);
                } else {
                    Console.WriteLine("{0} {1} {2}", l + a, l + b, l + c);
                }
            }
            //Console.ReadKey();
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;

namespace prA {

    class Program {
#if ONLINE_JUDGE
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
#else
        private static readonly StreamWriter writer = new StreamWriter("output");
        private static readonly StreamReader reader = new StreamReader("input");
#endif
        static long gcd(long a, long b) {
            while(b != 0) {
                long c = a % b;
                a = b;
                b = c;
            }
            return a;
        }

        static void Main(string[] args) {
            long l = Next();
            long r = Next();
            bool flag = false;
            for(long a = l; !flag && a <= r; a++) {
                for(long b = a + 1; !flag && b <= r; b++) {
                    for(long c = b + 1; !flag && c <= r; c++) {
                        if(gcd(a, b) == 1 && gcd(b, c) == 1 && gcd(a, c) != 1) {
                            writer.WriteLine("{0} {1} {2}", a, b, c);
                            flag = true;
                        }
                    }
                }
            }
            if(!flag)
                writer.Write(-1);

            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static long Next() {
            long c;
            long res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            int sign = 1;
            if(c == '-') {
                sign = -1;
                c = reader.Read();
            }
            res = c - '0';
            while(true) {
                c = reader.Read();
                if(c < '0' || c > '9')
                    return res * sign;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;

// (づ°ω°)づﾐ★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    public object Solve()
    {
        long l = ReadLong();
        long r = ReadLong();
        if (l > r - 2 || l == r - 2 && l % 2 == 1)
            return -1;

        if (l % 2 == 1)
            l++;
        Write(l, l + 1, l + 2);

        return null;
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;

    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("exchange.in");
        //writer = new StreamWriter("exchange.out");
#endif
        try
        {
            object result = new Solver().Solve();
            if (result != null)
                writer.WriteLine(result);
        }
        catch (Exception ex)
        {
#if DEBUG
            Console.WriteLine(ex);
#else
            Console.WriteLine(ex);
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write

    private static Queue<string> currentLineTokens = new Queue<string>();

    private static string[] ReadAndSplitLine()
    {
        return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public static string ReadToken()
    {
        while (currentLineTokens.Count == 0)
            currentLineTokens = new Queue<string>(ReadAndSplitLine());
        return currentLineTokens.Dequeue();
    }

    public static int ReadInt()
    {
        return int.Parse(ReadToken());
    }

    public static long ReadLong()
    {
        return long.Parse(ReadToken());
    }

    public static double ReadDouble()
    {
        return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public static int[] ReadIntArray()
    {
        return ReadAndSplitLine().Select(int.Parse).ToArray();
    }

    public static long[] ReadLongArray()
    {
        return ReadAndSplitLine().Select(long.Parse).ToArray();
    }

    public static double[] ReadDoubleArray()
    {
        return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();
    }

    public static int[][] ReadIntMatrix(int numberOfRows)
    {
        int[][] matrix = new int[numberOfRows][];
        for (int i = 0; i < numberOfRows; i++)
            matrix[i] = ReadIntArray();
        return matrix;
    }

    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows);
        int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++)
        {
            ret[i] = new int[numberOfRows];
            for (int j = 0; j < numberOfRows; j++)
                ret[i][j] = matrix[j][i];
        }
        return ret;
    }

    public static string[] ReadLines(int quantity)
    {
        string[] lines = new string[quantity];
        for (int i = 0; i < quantity; i++)
            lines[i] = reader.ReadLine().Trim();
        return lines;
    }

    public static void WriteArray<T>(IEnumerable<T> array)
    {
        writer.WriteLine(string.Join(" ", array));
    }

    public static void Write<T>(params T[] array)
    {
        WriteArray(array);
    }

    public static void WriteLines<T>(IEnumerable<T> array)
    {
        foreach (var a in array)
            writer.WriteLine(a);
    }

    #endregion
}

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

class Element:IComparable<Element>
{

    public int a, index;
    public Element()
    {
        a = index = 0;
    }
    public Element(int a, int i)
    {
        this.a = a;
        index = i;
    }

    public int CompareTo(Element other)
    {
        return other.a.CompareTo(this.a);
    }
}
class PairVariable : IComparable<PairVariable>
{
    public int a, b;
    public PairVariable()
    {
        a = b = 0;
    }
    public PairVariable(string s)
    {
        string[] q = s.Split();
        a = int.Parse(q[0]);
        b = int.Parse(q[1]);
    }
    public PairVariable(int a, int b)
    {
        this.a = a;
        this.b = b;
    }
    public int CompareTo(PairVariable pv)
    {
        if (this.a > pv.a)
        {
            return 1;
        }
        else if (this.a < pv.a)
        {
            return -1;
        }
        else
        {
            if (this.b >= pv.b)
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }
    }

}
    namespace ConsoleApplication254
    {
        class Program
        {
            static Dictionary<int, List<int>> d = new Dictionary<int, List<int>>();
            static int[] mark;
            static Dictionary<int, int> cnt;
            static int[] color;
            static int size = 0;
            static void dfs(int v)
            {
                size++;
                mark[v] = 1;
                bool w = false;
                if (cnt.ContainsKey(color[v]))
                {
                    cnt[color[v]]++;
                }
                else
                {
                    cnt.Add(color[v], 1);
                }
                for (int i = 0; i < d[v].Count; i++)
                {
                    if (mark[d[v][i]] == 0)
                    {

                        dfs(d[v][i]);
                    }

                }

            }
            static void Main(string[] args)
            {
                string[] ss = Console.ReadLine().Split();
                long a = long.Parse(ss[0]);
                long b = long.Parse(ss[1]);
                if (a % 2 == 0)
                {
                    if (b - a + 1 <= 2)
                    {
                        Console.WriteLine(-1);
                        return;
                    }
                    Console.WriteLine(a + " " + (a + 1) + " " + (a + 2));

                }
                else
                {
                    if (b - a + 1 <= 3)
                    {
                        Console.WriteLine(-1);
                        return;
                    }
                    Console.WriteLine(a+1 + " " + (a + 2) + " " + (a + 3));
                }
            }
        }
    }

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

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = Console.ReadLine();
            string[] splitStr = str.Split(' ');
            long l = long.Parse(splitStr[0]);
            long r = long.Parse(splitStr[1]);
            if ((r - l + 1) < 3)
            {
                Console.WriteLine("-1");
                Environment.Exit(0);
            }
            if (l % 2 == 0)
            {
                Console.WriteLine(l + " " + (l + 1) + " " + (l + 2));
                Environment.Exit(0);
            }
            if ((r - l + 1) > 3)
            {
                Console.WriteLine((l + 1) + " " + (l + 2) + " " + (l + 3));
                Environment.Exit(0);
            }
            Console.WriteLine("-1");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ASM
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] line = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray<long>();
            long l = line[0];
            long r = line[1];
            if (l % 2 != 0) l++;
            if (r - l < 2) Console.WriteLine(-1);
            else
            {
                long f1 = l;
                long f2 = l + 1;
                long f3 = l + 1 + 1;
                Console.WriteLine(f1 + " " + f2 + " " + f3);
            }

        }
        static long gcd(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return gcd(b, a%b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading.Tasks;

namespace fun
{
    class Program
    {
        private static TextReader cin = Console.In;
        private static TextWriter cout = Console.Out;
        static void Main(string[] args)
        {
            string s = cin.ReadLine() ;
            long l = long.Parse(s.Split(' ')[0]);
            long r = long.Parse(s.Split(' ')[1]);
            if (r-l<2||r - l < 3 && l % 2 == 1) cout.WriteLine(-1);
            else if (l % 2 == 1) cout.WriteLine((l + 1) + " " + (l + 2) + " " + (l + 3));
            else cout.WriteLine(l + " " + (l + 1) + " " + (l + 2));

            //cin.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CF_275
{
    class Program
    {
        public class IO
        {
            public static void Read(string inputString, out Int32 n)
            {
                bool succeded = Int32.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Int64 n)
            {
                bool succeded = Int64.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Single n)
            {
                bool succeded = Single.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Double n)
            {
                bool succeded = Double.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Char n)
            {
                bool succeded = Char.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out string outputString)
            {
                outputString = inputString;
            }

            public static void Read(string inputString, out List<Int32> result)
            {
                Int32 n = 0;
                result = new List<Int32>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        result.Add(n);
                        n = 0;
                    }

                if (n != 0)
                    result.Add(n);
            }

            public static void Read(string inputString, out List<Int64> result)
            {
                Int64 n = 0;
                result = new List<Int64>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        result.Add(n);
                        n = 0;
                    }

                if (n != 0)
                    result.Add(n);
            }

            public static void Read(string inputString, out List<Single> result)
            {
                Int32 integer = 0;
                Int32 rational = 0;

                Boolean ReadingInteger = true;

                result = new List<Single>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == ' ')
                    {
                        result.Add(MergeSingle(integer, rational));

                        integer = 0;
                        rational = 0;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (integer != 0 || rational != 0)
                    result.Add(MergeSingle(integer, rational));
            }

            public static void Read(string inputString, out List<Double> result)
            {
                Int64 integer = 0;
                Int64 rational = 0;

                Boolean ReadingInteger = true;

                result = new List<Double>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == ' ')
                    {
                        result.Add(MergeDouble(integer, rational));

                        integer = 0;
                        rational = 0;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (integer != 0 || rational != 0)
                    result.Add(MergeDouble(integer, rational));
            }

            public static void Read(string inputString, out List<Int32> result, Boolean readNegatives)
            {
                Int32 n = 0;
                Boolean plus = true;

                result = new List<Int32>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        if (plus == true)
                            result.Add(n);
                        else
                            result.Add(-n);

                        n = 0;
                        plus = true;
                    }
                }

                if (plus == true)
                    result.Add(n);
                else
                    result.Add(-n);
            }

            public static void Read(string inputString, out List<Int64> result, Boolean readNegatives)
            {
                Int64 n = 0;
                Boolean plus = true;

                result = new List<Int64>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        if (plus == true)
                            result.Add(n);
                        else
                            result.Add(-n);

                        n = 0;
                        plus = true;
                    }
                }

                if (plus == true)
                    result.Add(n);
                else
                    result.Add(-n);
            }

            public static void Read(string inputString, out List<Single> result, Boolean readNegatives)
            {
                Int32 integer = 0;
                Int32 rational = 0;
                Boolean plus = true;

                Boolean ReadingInteger = true;

                result = new List<Single>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] == ' ')
                    {
                        if (plus == true)
                            result.Add(MergeSingle(integer, rational));
                        else
                            result.Add(-MergeSingle(integer, rational));

                        integer = 0;
                        rational = 0;
                        plus = true;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (plus == true)
                    result.Add(MergeSingle(integer, rational));
                else
                    result.Add(-MergeSingle(integer, rational));
            }

            public static void Read(string inputString, out List<Double> result, Boolean readNegatives)
            {
                Int64 integer = 0;
                Int64 rational = 0;
                Boolean plus = true;

                Boolean ReadingInteger = true;

                result = new List<Double>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] == ' ')
                    {
                        if (plus == true)
                            result.Add(MergeDouble(integer, rational));
                        else
                            result.Add(-MergeDouble(integer, rational));

                        integer = 0;
                        rational = 0;
                        plus = true;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (plus == true)
                    result.Add(MergeDouble(integer, rational));
                else
                    result.Add(-MergeDouble(integer, rational));
            }

            public static void Read(string inputString, out List<Char> result)
            {
                result = inputString.ToList<char>();
            }

            public static void FormatString<T>(T n, ref string result, bool newLine = true)
            {
                if (newLine == true)
                    result += n.ToString() + Environment.NewLine;
                else
                    result += n.ToString() + " ";
            }

            public static void FormatString<T>(List<T> n, ref string result, bool newLine = false)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(result);

                if (newLine == false)
                    foreach (var item in n)
                        sb.Append(item + " ");
                else
                    foreach (var item in n)
                        sb.Append(item + Environment.NewLine);

                result = sb.ToString();
            }

            private static Single MergeSingle(Int32 integer, Int32 rational)
            {
                Func<Int32, Int32> nrCifre = n => { Int32 cnt = 0; while (n != 0) { n /= 10; cnt++; } return cnt; };
                Func<Int32, Int32> zecePow = n => { Int32 p = 1; for (int j = 0; j < n; j++) p *= 10; return p; };
                Func<Int32, Single> parteFract = n => { Int32 cateCifre = nrCifre(n); return (Single)n / (Single)zecePow(cateCifre); };

                Single f = integer + parteFract(rational);
                return f;
            }

            private static Double MergeDouble(Int64 integer, Int64 rational)
            {
                Func<Int64, Int32> nrCifre = n => { Int32 cnt = 0; while (n != 0) { n /= 10; cnt++; } return cnt; };
                Func<Int32, Int64> zecePow = n => { Int64 p = 1; for (int j = 0; j < n; j++) p *= 10; return p; };
                Func<Int64, Double> parteFract = n => { int cateCifre = nrCifre(n); return (Double)n / (Double)zecePow(cateCifre); };

                Double d = integer + parteFract(rational);
                return d;
            }
        }

        public class Math
        {
            public static List<Int64> PrimeNumbers(Int64 upperBound)
            {
                List<Int64> listOfPrimes = new List<Int64>();
                Int64 sqrtUB = (Int64)System.Math.Sqrt(upperBound) + 1;

                Boolean[] isNotPrime = new Boolean[upperBound + 1];
                isNotPrime[1] = true;
                isNotPrime[2] = false;

                for (Int64 i = 2; i < sqrtUB; i++)
                    if (isNotPrime[i] == false)
                        for (Int64 j = i * i; j <= upperBound; j += i)
                            isNotPrime[j] = true;

                for (int i = 2; i <= upperBound; i++)
                    if (isNotPrime[i] == false)
                        listOfPrimes.Add(i);

                return listOfPrimes;
            }

            public static Boolean IsPrime(Int64 n)
            {
                if (n < 2)
                    return false;

                for (Int64 i = 2; i * i < n; i++)
                    if (n % i == 0)
                        return false;

                return true;
            }

            public static Int64 GCD (Int64 a, Int64 b)
            {
                Int64 c;

                while ( a != 0 ) {
                    c = a; a = b % a;  b = c;
                }

                return b;
            }
        }

        static void Main(string[] args)
        {
            List<Int64> v;
            IO.Read(Console.ReadLine(), out v);

            Int64 l = v[0];
            Int64 r = v[1];

            Boolean ok = false;
            for (Int64 i = l; i <= r; i++)
            {
                for (Int64 j = i + 1; j <= r; j++)
                {
                    for (Int64 k = j + 1; k <= r; k++)
                    {
                        if (Math.GCD(i, j) == 1 && Math.GCD(j, k) == 1 && Math.GCD(k, i) != 1)
                        {
                            Console.WriteLine(i + " " + j + " " + k);
                            ok = true;
                            goto label;
                        }
                    }
                }
            }

            label:
            if (ok == false)
                Console.WriteLine("-1");
        }
    }
}

using System;
using System.Linq;
class Program
{
    public static long Gcd(long a, long b)
    {
        if (a < 0)
            a = -a;
        if (b < 0)
            b = -b;
        if (a == 0)
            return b;
        while (b != 0)
        {
            long c = a;
            a = b;
            b = c % b;
        }
        return a;
    }
    static void Main()
    {
        var lr = Console.ReadLine().Split().Select(long.Parse).ToArray();
        if (lr[1] - lr[0] < 2)
        {
            Console.WriteLine(-1);
            return;
        }
        for (var i = lr[0]; i <= lr[1]; i++)
        {
            for (var j = i + 1; j <= lr[1]; j++)
            {
                for (var k = j + 1; k <= lr[1]; k++)
                {
                    if (Gcd(i, j) == 1 && Gcd(j, k) == 1 && Gcd(i, k) != 1)
                    {
                        Console.WriteLine("{0} {1} {2}", i, j, k);
                        return;
                    }
                }
            }
        }
        Console.WriteLine(-1);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication6
{
    class Program
    {
        public static long NOD(long a, long b)
        {
            while (b != 0)
                b = a % (a = b);
            return a;
        }
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] s1 = s.Split(' ');
            long l = long.Parse(s1[0]);
            long r = long.Parse(s1[1]);
            for (long i = l; i<=r;i++)
                for (long j = l+1;j<=r;j++)
                    for (long k = l+2;k<=r;k++)
                    {
                        if ((NOD(i,k)!=1)&&(NOD(i,j)==1)&&(NOD(j,k)==1)&&(i<j)&&(j<k))
                        {
                            Console.WriteLine("{0} {1} {2}",i,j,k);
                            return;
                        }
                    }
            Console.WriteLine("-1");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Xml;

namespace codeforces
{
	class Program
	{
		public class User
		{
			public int c;

			public int r;
		}

		public class Comparer : IComparer<User>
		{
			public int Compare(User x, User y)
			{
				if (x.c < y.c || (x.c == y.c && x.r < y.r))
					return -1;
				return 1;
			}
		}

		public static long getGcd(long a, long b)
		{
			if (b == 0)
				return a;
			return getGcd(b, a % b);
		}

		public static void WriteYESNO(bool x, string yes = "YES", string no = "NO")
		{
			if (x)
				Console.WriteLine(yes);
			else
			{
				Console.WriteLine(no);
			}
		}

		public static string GetString()
		{
			return Console.ReadLine();
		}

		public static List<int> getList()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(int.Parse).ToList();
		}

		public static int Min(int x, int y)
		{
			return Math.Min(x, y);
		}

		public static int Max(int x, int y)
		{
			return Math.Max(x, y);
		}

		public static int Abs(int x)
		{
			return Math.Abs(x);
		}

		public static int getInt()
		{
			var s = Console.ReadLine();
			return int.Parse(s);
		}

		public static bool Equal(int x, int y, int x1, int y1)
		{
			return x == x1 && y == y1;
		}

		public class Vertex
		{
			public List<int> edges;

			public int ct;

			public Vertex()
			{
				ct = 0;
				edges = new List<int>();
				for (var i = 0; i < 26; ++i)
					edges.Add(0);
			}
		}

		private static void Main(string[] args)
		{
/*			var input = new StreamReader("input.txt");
			var output = new StreamWriter("output.txt");*/
			var l = Console.ReadLine().Split(' ').Select(long.Parse).ToList();
			if (l[1] - l[0] < 2 || (l[1] - l[0] == 2 && l[0] % 2 == 1))
				Console.WriteLine(-1);
			else
			{
				if (l[0] % 2 == 1)
					l[0]++;
				Console.WriteLine("{0} {1} {2}", l[0], l[0] + 1, l[0] + 2);
			}
			/*			input.Close();
			output.Close();*/
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces._275
{
    class ProblemA
    {
        public static void Main(string[] varg)
        {
            string[] tokens = System.Console.ReadLine().Split(new char[] { ' ' });
            Int64 a = Int64.Parse(tokens[0]);
            Int64 b = Int64.Parse(tokens[1]);

            for (Int64 i=a;i<=b;i++)
            {
                for (Int64 j=i+1;j<=b;j++)
                {
                    for (Int64 k = j+1;k<=b;k++)
                    {
                        if (isCoprime(i,j) && isCoprime(j,k) && !isCoprime(i,k))
                        {
                            System.Console.WriteLine(String.Format("{0} {1} {2}", i,j,k));
                            return;
                        }
                    }
                }
            }
            System.Console.WriteLine("-1");
            return;

        }
        private static bool isCoprime(Int64 a, Int64 b)
        {
            HashSet<int> fact1 = new HashSet<int>();
            for (Int64 i=2;i<50;i++)
            {
                if (a % i == 0 && b % i == 0)
                    return false;
            }
            return true;

        }
    }
}

using System;
using System.Linq;

namespace _483A
{
    class Program
    {
        static void Main(string[] args)
        {
            var s = Console.ReadLine().Split().Select(long.Parse).ToArray();
            var l = s[0];
            var r = s[1];
            for (long a = l; a <= r; a++)
            {
                for (long b = a + 1; b <= r; b++)
                {
                    for (long c = b + 1; c <= r; c++)
                    {
                        if (gcd(a, b) == 1 && gcd(b, c) == 1 && gcd(a, c) != 1)
                        {
                            Console.WriteLine(a + " " + b + " " + c);
                            return;
                        }
                    }
                }
            }
            Console.WriteLine(-1);
        }

        static long gcd(long a, long b)
        {
            if (b == 0) return a;
            return gcd(b, a % b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace task
{
    class Program
    {

        private static long GCD(long a, long b)
        {
            if (b == 0) return a;
            return GCD(b, a % b);
        }

        static void Main(string[] args)
        {

            string input = Console.ReadLine();
            string[] parts = input.Split(' ');

            long l = long.Parse(parts[0]);
            long r = long.Parse(parts[1]);

            if((r-l + 1) < 3)
            {
                Console.WriteLine("-1");
                return;
            }

            string result = "-1";

            for(long a=l; a<=r-2;a++)
            {
                for(long b=a+1;b<=r-1;b++)
                {
                    if(GCD(a,b)==1)
                    {
                        for(long c=b+1;c<=r;c++)
                        {
                            if(GCD(b,c)==1 && GCD(a,c)!=1)
                            {
                                result = a + " " + b + " " + c;
                                Console.WriteLine(result);
                                //Console.ReadLine();
                                return;
                            }
                        }

                    }
                }
            }

            Console.WriteLine(result);
            //Console.ReadLine();

        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForcesTemplate
{
    class Program
    {
        static long l, r;
        static Dictionary<Tuple<long, long>, long> Memory = new Dictionary<Tuple<long, long>, long>();

        static void Main(string[] args)
        {
            LoadInput();
            Solve();
        }

        private static void Solve()
        {
            for (long i = l; i <= r - 2; i++)
            {
                for (long j = i + 1; j <= r - 1; j++)
                {
                    for (long k = j + 1; k <= r; k++)
                    {
                        if (Gcd(i, j) == 1 && Gcd(j, k) == 1 && Gcd(i, k) != 1)
                        {
                            Console.WriteLine("{0} {1} {2}", i, j, k);
                            return;
                        }
                    }
                }
            }
            Console.WriteLine(-1);
        }

        private static void LoadInput()
        {
            var inp = GetInputLineLong();
            l = inp[0];
            r = inp[1];
        }

        static long Gcd(long a, long b)
        {
            var key = Tuple.Create(a, b);
            if (Memory.ContainsKey(key))
            {
                return Memory[key];
            }
            if (b == 0)
            {
                Memory.Add(key, a);
                return a;
            }
            else
            {
                long result = Gcd(b, a % b);
                Memory.Add(key, result);
                return result;
            }
        }

        static int[] GetInputLine()
        {
            return Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        }

        static long[] GetInputLineLong()
        {
            return Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        }
    }

    static class Helpers
    {
        public static void Print<T>(this IEnumerable<T> source)
        {
            foreach (var item in source)
            {
                Console.Write("{0} ", item.ToString());
            }
            Console.WriteLine();
        }
    }
}

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

namespace SolvingAlgorithms
{
    class Program
    {
        static void Main(string[] args)
        {

            string input;
            input = Console.ReadLine();
            string[] inp = input.Split(' ');
            Int64 a = Convert.ToInt64(inp[0]);
            Int64 c = Convert.ToInt64(inp[1]);
            Int64 counter = c - a;
            Boolean breaking = false;
            if (counter >=2 )
            {
                for (Int64 i = 0; i < counter && !breaking; i++)
                {
                    for (Int64 j = 0; j < counter-i  && !breaking; j++)
                    {
                        for (Int64 x = i+1; x < counter-i &&!breaking; x++)
                        {
                            if (GCD(a + i, a+x) == 1 && GCD(a+x, c-j ) == 1 && GCD(a + i,c-j) > 1)
                            {
                                breaking = true;
                                Int64 o= a+i;
                                Int64 u= a+x;
                                Int64 q= c-j;
                                Console.WriteLine(o + " " + u + " " + q);
                            }
                        }
                    }

                }
            }
            else
            {
                Console.WriteLine("-1");
                breaking = true;
            }
            if (!breaking)
            {
                Console.WriteLine("-1");
            }
        }

        private static Int64 GCD(Int64 a, Int64 b)
        {
            while (a != 0 && b != 0)
            {
                if (a > b)
                    a %= b;
                else
                    b %= a;
            }

            return a == 0 ? b : a;
        }
    }
}

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

namespace SolvingAlgorithms
{
    class Program
    {
        static void Main(string[] args)
        {

            string input;
            input = Console.ReadLine();
            string[] inp = input.Split(' ');
            Int64 a = Convert.ToInt64(inp[0]);
            Int64 c = Convert.ToInt64(inp[1]);
            Int64 counter = c - a;
            Boolean breaking = false;
            if (counter >=2 )
            {
                for (Int64 i = 0; i < counter && !breaking; i++)
                {
                    for (Int64 j = 0; j < counter  && !breaking; j++)
                    {
                        for (Int64 x = 0; x < counter &&!breaking; x++)
                        {
                            if (GCD(a + i, c - j) == 1 && GCD(c - j, c - x) == 1 && GCD(a + i, c - x) > 1)
                            {
                                breaking = true;
                                Int64 o= a+i;
                                Int64 u= c-j;
                                Int64 q= c-x;
                                Console.WriteLine(o + " " + u + " " + q);
                            }
                        }
                    }

                }
            }
            else
            {
                Console.WriteLine("-1");
                breaking = true;
            }
            if (!breaking)
            {
                Console.WriteLine("-1");
            }
        }

        private static Int64 GCD(Int64 a, Int64 b)
        {
            while (a != 0 && b != 0)
            {
                if (a > b)
                    a %= b;
                else
                    b %= a;
            }

            return a == 0 ? b : a;
        }
    }
}

using System;
using System.Collections.Generic;

public class Test
{
    public static Dictionary<ulong, int> Factors(ulong N)
    {
        ulong max = ((ulong)Math.Sqrt(N)) + 1;
        Dictionary<ulong, int> facts = new Dictionary<ulong, int>();
    	for(ulong n = 2; n * n < N; n++)
        {
            int power = 0;
            while(N % n == 0)
            {
               N = N / n;
               power++;
            }
            if(power > 0)
               facts.Add(n, power);
        }
        return facts;
    }

    public static int SmallFacts(ulong N)
    {
        int factorsMask = 0;
        ulong[] primes = {2,3,5,7,9,11,13,17,19,23,29,31,37,41,43,47};
    	for(int n = 0; n < primes.Length; n++)
        {
             int pwr = 0;
             while(N % primes[n] == 0)
             {
             	pwr++; N = N / primes[n];
             }
             if(pwr > 0) factorsMask |= (1 << n);
             if(N <= 1) break;
        }
        return factorsMask;
    }

    public static string PrintMask(int mask)
    {
         string r= "";
         for(int i = 0; i < 32; i++)
             r += ((mask & (1 << i)) != 0) ? "1" : "0";
         return r;
    }

	public static void Main()
	{
		string[] tok = Console.ReadLine().Split(' ');
        ulong l = UInt64.Parse(tok[0]);
        ulong r = UInt64.Parse(tok[1]);

        int D = (int)(r - l) + 1;
        int[] factors = new int[D];
        for(ulong i = l; i <= r; i++)
		{
            factors[(int)(i - l)] = SmallFacts(i);
            //Console.WriteLine("{0} -> {1}", i, PrintMask(factors[(int)(i -l)]));
        }

        int found = -1;
        for(int i = 0; i < D; i++)
        {
            for(int j = i + 1; j < D; j++)
            {
                if((factors[i] & factors[j]) != 0)
                {
                    //Console.WriteLine("found {0} and {1}", i, j);
                	for(int k = 1; k < D; k++)
                	{
                        if((k != i) && (k != j) && (factors[k] & factors[i]) == 0 && (factors[k] & factors[j]) == 0)
                        {
                             Console.WriteLine("{0} {1} {2}", (ulong)i + l, (ulong)j + l, (ulong)k + l);
                             return;
                        }
                	}
                }
            }
        }
        Console.WriteLine("-1");

	}
}

using System;

namespace Counterexample
{
    class Program
    {

        private static bool isPrime(long k){
            for (long i=2; i<=Math.Sqrt(k); i++){
                if (k%i == 0){
                    return false;
                }
            }
            return true;
        }

        private static long gcd(long a, long b){
            if (b==0){
                return a;
            }
            return gcd(b, a%b);
        }

        static void Main(string[] args)
        {
            string [] input = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.None);

            long l = long.Parse(input[0]);
            long r = long.Parse(input[1]);

            long a = l, b=0, c=0;
            bool foundB = false, foundC = false;

            long i = l;

            while(i<=r){
                if (foundC){
                    break;
                }

                a = i;
                long j = a;
                while(j<= r){
                    if (gcd(a, j) ==1){
                        b = j;
                        foundB = true;
                        break;
                    }
                    j++;
                }
                if (foundB){
                    long k = b;
                    while( k<= r){
                        if (gcd(b, k) == 1 && gcd(a, k) > 1){
                            c = k;
                            foundC = true;
                            break;
                        }
                        k++;
                    }
                }
                i++;
            }

            Console.WriteLine(a+" "+b);

            i = b;
            if (foundB && foundC){
                Console.WriteLine(a+" "+b+" "+c);
            }else{
                Console.WriteLine(-1);
            }
        }
    }
}

using System;

namespace Counterexample
{
    class Program
    {

        private static long gcd(long a, long b){
            if (b==0){
                return a;
            }
            return gcd(b, a%b);
        }

        static void Main(string[] args)
        {
            string [] input = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.None);

            long l = long.Parse(input[0]);
            long r = long.Parse(input[1]);

            long a = l, b=0, c=0;
            bool foundB = false, foundC = false;

            long i = a;
            while( !foundB && i<= r){
                if (gcd(a, i) ==1){
                    b = i;
                    foundB = true;
                }
                i++;
            }

            i = b;
            while( !foundC && i<= r){
                if (gcd(b, i) == 1 && gcd(a, i) > 1){
                    c = i;
                    foundC = true;
                }
                i++;
            }
            if (foundB && foundC){
                Console.WriteLine(a+" "+b+" "+c);
            }else{
                Console.WriteLine(-1);
            }
        }
    }
}

using System;
using System.Linq;
class Solution
{
    public static void Main()
    {
        long[] minp = Console.ReadLine().Split().Select(Int64.Parse).ToArray();
        long l = minp[0], r = minp[1], j =0, i= 0;
        bool check = true;
        if (r - l > 1)
        {
            for (i = l; i <= r; i++)
            {
                j = i + 2;
                if (co_prime(i, i + 1))
                {
                    do
                    {
                        if (co_prime(i + 1, j))
                        {
                            if (!co_prime(i, j))
                            { check = false; break; }
                        }
                        j++;
                    } while (j <= r);
                    if (!check)
                        break;
                }
            }
        }
        else
            check = true;
        if (check == false) Console.WriteLine(i + " " + (i + 1) + " " + j);
        else
            Console.WriteLine("-1");

    }
    public static bool co_prime(long a, long b)
    {
        bool primeness = true;
        long div = Math.Min(a, b);
        for(long i = 2; i <= 9; i++)
        {
            if (a % i == 0 && b % i == 0)
            { primeness = false; break; }
        }
        return primeness;
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
            var init = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var l = init[0];
            var r = init[1];

            var candidates = new List<long>();

            for (long i = l; i <= r; i++)
            {
                for (long j = i; j <= r; j++)
                {
                    if (coprime(i,j))
                    {
                        //Start searching for a second pair of comprimes
                        for (long k = j; k <= r; k++)
                        {
                            if(coprime(j,k))
                            {
                                if (!coprime(i,k))
                                {
                                    candidates.Add(i);
                                    candidates.Add(j);
                                    candidates.Add(k);
                                    break;

                                }
                            }

                        }
                        break;
                    }
                }
                break;
            }

            if (candidates.Count == 3)
            {
                string ans = candidates[0] + " " + candidates[1] + " " + candidates[2];
                Console.WriteLine(ans);
                //return;
            }
            else{
                Console.WriteLine(-1);
                //return;
            }

            Console.ReadLine();
        }

        public static long GCD(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return GCD(b, a % b);
        }

        public static bool coprime(long a, long b)
        {
            return GCD(a, b) == 1;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
            var init = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var l = init[0];
            var r = init[1];

            var candidates = new List<long>();

            for (long i = l; i <= r; i++)
            {
                for (long j = i + 1; j <= r; j++)
                {
                    if (coprime(i,j))
                    {
                        //Start searching for a second pair of comprimes
                        for (long k = j + 1; k <= r; k++)
                        {
                            if(coprime(j,k))
                            {
                                if (!coprime(i,k))
                                {
                                    candidates.Add(i);
                                    candidates.Add(j);
                                    candidates.Add(k);
                                }
                            }
                        }
                    }
                }
            }

            if (candidates.Count == 3)
            {
                string ans = candidates[0] + " " + candidates[1] + " " + candidates[2];
                Console.WriteLine(ans);
                return;
            }
            else{
                Console.WriteLine(-1);
                return;
            }

            Console.ReadLine();
        }

        public static long GCD(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return GCD(b, a % b);
        }

        public static bool coprime(long a, long b)
        {
            return GCD(a, b) == 1;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
            var init = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var l = init[0];
            var r = init[1];

            var candidates = new List<long>();

            for (long i = l; i <= r; i++)
            {
                for (long j = i; j <= r; j++)
                {
                    if (coprime(i,j))
                    {
                        //Start searching for a second pair of comprimes
                        for (long k = j; k <= r; k++)
                        {
                            if(coprime(j,k))
                            {
                                if (!coprime(i,k))
                                {
                                    candidates.Add(i);
                                    candidates.Add(j);
                                    candidates.Add(k);
                                }
                            }
                        }
                    }
                }
            }

            if (candidates.Count == 3)
            {
                string ans = candidates[0] + " " + candidates[1] + " " + candidates[2];
                Console.WriteLine(ans);
                return;
            }
            else{
                Console.WriteLine(-1);
                return;
            }

            Console.ReadLine();
        }

        public static long GCD(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return GCD(b, a % b);
        }

        public static bool coprime(long a, long b)
        {
            return GCD(a, b) == 1;
        }
    }
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;

namespace ConsoleApplication25
{
    class Program
    {
        static void Main(string[] args)
        {
            var init = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
            var l = init[0];
            var r = init[1];

            var candidates = new List<long>();

            for (long i = l; i <= r; i++)
            {
                for (long j = i + 1; j <= r; j++)
                {
                    if (coprime(i,j))
                    {
                        //Start searching for a second pair of comprimes
                        for (long k = j + 1; k <= r; k++)
                        {
                            if(coprime(j,k))
                            {
                                if (!coprime(i,k))
                                {
                                    candidates.Add(i);
                                    candidates.Add(j);
                                    candidates.Add(k);
                                    break;

                                }
                            }

                        }
                        break;
                    }
                }
                break;
            }

            if (candidates.Count == 3)
            {
                string ans = candidates[0] + " " + candidates[1] + " " + candidates[2];
                Console.WriteLine(ans);
                //return;
            }
            else{
                Console.WriteLine(-1);
                //return;
            }

            Console.ReadLine();
        }

        public static long GCD(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return GCD(b, a % b);
        }

        public static bool coprime(long a, long b)
        {
            return GCD(a, b) == 1;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Numerics;
namespace ConsoleApplication25
{
    class Program
    {

        static BigInteger GCD(BigInteger a, BigInteger b)
        {
            if (b != 0)
            {
                return GCD(b, a % b);
            }
            else
            {
                return a;
            }
        }

        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' '); // comment
            BigInteger qwertt = BigInteger.Parse(input[0]);
            BigInteger asdf = BigInteger.Parse(input[1]);
            BigInteger[] result = new BigInteger[3];
            bool rezultatu = false;
            for (BigInteger i = qwertt; i <= asdf; i++)
            {
                for (BigInteger j = qwertt + 1; j < asdf; j++)
                {
                    if (GCD(i, j) == 1)
                    {
                        if (GCD(j, j + 1) == 1)
                        {
                            if (GCD(i, j + 1) != 1)
                            {
                                result[0] = i;
                                result[1] = j;
                                result[2] = j + 1;
                                rezultatu = true;
                                break;
                            }
                        }
                    }
                }
                if (rezultatu) break;

            }
            if (rezultatu)
            {
                for (int i = 0; i < 3; i++)
                {
                    Console.Write(result[i]);
                    Console.Write(' ');
                }

            }
            else
            {
                Console.Write(-1);
            }
            Console.Read();
        }
    }
}

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

namespace Counterexample
{
    class Program
    {
        static void Main(string[] args)
        {
            string str_Inputs = Console.ReadLine();
            string[] arr_Inputs = str_Inputs.Split(' ');
            long num_L = Convert.ToInt64(arr_Inputs[0]);
            long num_R = Convert.ToInt64(arr_Inputs[1]);
            bool flag = false;

            for (long i = num_L; i <= num_R; i++)
            {
                for (long j = i + 1; j <= num_R; j++)
                {
                    for (long k = j + 1; k <= num_R; k++)
                    {
                        if (Coprime(i, j) && Coprime(j, k) && !Coprime(i, k))
                        {
                            flag = true;
                            Console.Write( i + " " + j + " " + k);
                            break;
                        }
                    }
                }
            }
            if (!flag)
            {
                Console.Write("-1");
            }

            Console.Read();
        }

        public static bool Coprime(long x, long y)
        {
            while(y!=0)
            {
                long temp = y;
                y = x % y;
                x = temp;
            }
            return (x == 1);
        }
    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            string ss = Console.ReadLine();
            ulong n = ulong.Parse(ss.Split(' ')[0]);
            ulong p = ulong.Parse(ss.Split(' ')[1]);

            ulong res = 0;
            for(ulong i=n+1;i<p;i++)
            {
                for (ulong j = i + 1; j <= p; j++)
                {
                    if (check(n, i, j))
                    {
                        Console.WriteLine(n.ToString() + " " + i.ToString() + " " + j.ToString());
                        return;
                    }
                }
            }
            Console.WriteLine("-1");
            Console.ReadLine();

        }

        static bool check(ulong a, ulong b, ulong c)
        {
            ulong res1 = 0;
            ulong res2 = 0;
            ulong res3 = 0;
            for (ulong i = 2; i <= 5000; i++)
                if (a % i == 0 && b % i == 0)
                {
                    res1 = i;
                    break;
                }
            for (ulong i = 2; i <= 5000; i++)
                if (b % i == 0 && c % i == 0)
                {
                    res2 = i;
                    break;
                }
            for (ulong i = 2; i <= 5000; i++)
                if (a % i == 0 && c % i == 0)
                {
                    res3 = i;
                    break;
                }

            if (res1 == 0 && res2 == 0 && res3 != 0)
                return true;

            return false;

        }

    }
}

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

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            string a = Console.ReadLine();
            ulong n = ulong.Parse(a.Split(' ')[0]);
            ulong p = ulong.Parse(a.Split(' ')[1]);

            for(ulong i=n+1;i<p;i++)
            {
                for (ulong j = i + 1; j <= p; j++)
                {
                    if (check(n, i, j))
                    {
                        Console.WriteLine(n.ToString() + " " + i.ToString() + " " + j.ToString());
                        return;
                    }
                }
            }

            Console.WriteLine("-1");

        }

        static bool check(ulong a,ulong b,ulong c)
        {
            if(gcd(a,b)==1 && gcd(b,c)==1 && gcd(a,c)!=1)
                return true;
            return false;
        }

        static ulong gcd(ulong x, ulong y)
        {
            if (y == 0)
            {
                return x;
            }
            else
            {
                return gcd(y, x % y);
            }
        }
    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            string ss = Console.ReadLine();
            ulong n = ulong.Parse(ss.Split(' ')[0]);
            ulong p = ulong.Parse(ss.Split(' ')[1]);

            ulong res = 0;
            for(ulong i=n+1;i<p;i++)
            {
                for (ulong j = i + 1; j <= p; j++)
                {
                    if (check(n, i, j))
                    {
                        Console.WriteLine(n.ToString() + " " + i.ToString() + " " + p.ToString());
                        return;
                    }
                }
            }
            Console.WriteLine("-1");

        }

        static bool check(ulong a,ulong b,ulong c)
        {
            if (Math.Max(a, b) / a == 1 && Math.Max(a, b) / b == 1 &&
              Math.Max(b, c) / b == 1 && Math.Max(b, c) / c == 1 &&
              (
              Math.Max(a, c) / a != 1 || Math.Max(a, c) / c != 1
              )

                )
                return true;
            return false;

        }

    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            string ss = Console.ReadLine();
            ulong n = ulong.Parse(ss.Split(' ')[0]);
            ulong p = ulong.Parse(ss.Split(' ')[1]);

            ulong res = 0;
            for(ulong i=n+1;i<p;i++)
            {
                for (ulong j = i + 1; j <= p; j++)
                {
                    if (check((int)(n%51), (int)(i%51), (int)(j%51)))
                    {
                        Console.WriteLine(n.ToString() + " " + i.ToString() + " " + p.ToString());
                        return;
                    }
                }
            }
            Console.WriteLine("-1");
            Console.ReadLine();

        }

        static bool check(int a,int b,int c)
        {
            int res1 = 0;
            int res2 = 0;
            int res3 = 0;
            for (int i = 2; i <= 50; i++)
                if (a % i == 0 && b % i == 0)
                {
                    res1 = i;
                    break;
                }
            for (int i = 2; i <= 50; i++)
                if (b % i == 0 && c % i == 0)
                {
                    res2 = i;
                    break;
                }
            for (int i = 2; i <= 50; i++)
                if (a % i == 0 && c % i == 0)
                {
                    res3 = i;
                    break;
                }

            if (res1 == 0 && res2 == 0 && res3 != 0)
                return true;

            return false;

        }

    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            string ss = Console.ReadLine();
            ulong n = ulong.Parse(ss.Split(' ')[0]);
            ulong p = ulong.Parse(ss.Split(' ')[1]);

            ulong res = 0;

            for (ulong i = n; i < p; i++)
            {
                if(check(i,p)!="-1")
                {
                    Console.WriteLine(check(i,p));
                    return;
                }
            }
            Console.WriteLine("-1");

        }

        static string check(ulong a,ulong p)
        {

            for (ulong i = 2; i <= Math.Min(50,a); i++)
                if (a % i == 0 && a+i<=p)
                {

                    return a.ToString() + " " + (a + 1).ToString() + " " + (a + i).ToString();

                }

            return "-1";

        }

    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {

            string ss = Console.ReadLine();
            ulong n = ulong.Parse(ss.Split(' ')[0]);
            ulong p = ulong.Parse(ss.Split(' ')[1]);

            ulong res = 0;
            for(ulong i=n+1;i<p;i++)
            {
                for (ulong j = i + 1; j <= p; j++)
                {
                    if (check(n, i, j))
                    {
                        Console.WriteLine(n.ToString() + " " + i.ToString() + " " + j.ToString());
                        return;
                    }
                }
            }
            Console.WriteLine("-1");
            Console.ReadLine();

        }

        static bool check(ulong a, ulong b, ulong c)
        {
            ulong res1 = 0;
            ulong res2 = 0;
            ulong res3 = 0;

            for (ulong i = 2; i < 50; i++)
                if ((b-a) % i == 0)
                {
                    res1 = i;
                    break;
                }

            for (ulong i = 2; i < 50; i++)
                if ((c - b)% i == 0)
                {
                    res2 = i;
                    break;
                }

            for (ulong i = 2; i < 50; i++)
                if ((c-a) % i ==0)
                {
                    res3 = i;
                    break;
                }

            if (res1 == 0 && res2 == 0 && res3 != 0)
                return true;

            return false;

        }

    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;

// (づ°ω°)づﾐ★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜
public class Solver
{
    public object Solve()
    {
        long l = ReadLong();
        long r = ReadLong();
        if (l > r - 2)
            return -1;

        Write(l, l + 1, l + 2);

        return null;
    }

    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;

    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
        reader = new StreamReader(Console.OpenStandardInput());
        writer = new StreamWriter(Console.OpenStandardOutput());
        //reader = new StreamReader("exchange.in");
        //writer = new StreamWriter("exchange.out");
#endif
        try
        {
            object result = new Solver().Solve();
            if (result != null)
                writer.WriteLine(result);
        }
        catch (Exception ex)
        {
#if DEBUG
            Console.WriteLine(ex);
#else
            Console.WriteLine(ex);
            throw;
#endif
        }
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write

    private static Queue<string> currentLineTokens = new Queue<string>();

    private static string[] ReadAndSplitLine()
    {
        return reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public static string ReadToken()
    {
        while (currentLineTokens.Count == 0)
            currentLineTokens = new Queue<string>(ReadAndSplitLine());
        return currentLineTokens.Dequeue();
    }

    public static int ReadInt()
    {
        return int.Parse(ReadToken());
    }

    public static long ReadLong()
    {
        return long.Parse(ReadToken());
    }

    public static double ReadDouble()
    {
        return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public static int[] ReadIntArray()
    {
        return ReadAndSplitLine().Select(int.Parse).ToArray();
    }

    public static long[] ReadLongArray()
    {
        return ReadAndSplitLine().Select(long.Parse).ToArray();
    }

    public static double[] ReadDoubleArray()
    {
        return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();
    }

    public static int[][] ReadIntMatrix(int numberOfRows)
    {
        int[][] matrix = new int[numberOfRows][];
        for (int i = 0; i < numberOfRows; i++)
            matrix[i] = ReadIntArray();
        return matrix;
    }

    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows);
        int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++)
        {
            ret[i] = new int[numberOfRows];
            for (int j = 0; j < numberOfRows; j++)
                ret[i][j] = matrix[j][i];
        }
        return ret;
    }

    public static string[] ReadLines(int quantity)
    {
        string[] lines = new string[quantity];
        for (int i = 0; i < quantity; i++)
            lines[i] = reader.ReadLine().Trim();
        return lines;
    }

    public static void WriteArray<T>(IEnumerable<T> array)
    {
        writer.WriteLine(string.Join(" ", array));
    }

    public static void Write<T>(params T[] array)
    {
        WriteArray(array);
    }

    public static void WriteLines<T>(IEnumerable<T> array)
    {
        foreach (var a in array)
            writer.WriteLine(a);
    }

    #endregion
}

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

namespace ConsoleApplication14
{
    class Program
    {
        static void Main(string[] args)
        {
            string str = Console.ReadLine();
            string[] splitStr = str.Split(' ');
            long l = long.Parse(splitStr[0]);
            long r = long.Parse(splitStr[1]);
            if ((r - l + 1) < 3)
            {
                Console.WriteLine("-1");
            }
            if (l % 2 == 0)
            {
                Console.WriteLine(l + " " + (l + 1) + " " + (l + 2));
            }
            if ((r - l + 1) > 3)
            {
                Console.WriteLine((l + 1) + " " + (l + 2) + " " + (l + 3));
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ASM
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] line = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray<long>();
            long l = line[0];
            long r = line[1];
            long f1 = l;
            long f2 = l + 1;
            long f3 = 0;
            for(long i= l+2;i<= r; i++)
            {
                if (gcd(f1, i) > 1)
                {
                    f3 = i;
                    break;
                }
            }
            if (f3 == 0)
            {
                Console.WriteLine(-1);
            }
            else
            {
                Console.WriteLine(f1 + " " + f2 + " " + f3);
            }

        }
        static long gcd(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return gcd(b, a%b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ASM
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] line = Console.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray<long>();
            long l = line[0];
            long r = line[1];
            long f1 = l;
            long f2 = l + 1;
            long f3 = 0;
            for(long i= l+2;i<= r; i++)
            {
                if (gcd(f1, i) > 1 && gcd(f2, i) == 1)
                {
                    f3 = i;
                    break;
                }
            }
            if (f3 == 0)
            {
                Console.WriteLine(-1);
            }
            else
            {
                Console.WriteLine(f1 + " " + f2 + " " + f3);
            }

        }
        static long gcd(long a, long b)
        {
            if (b == 0)
                return a;
            else
                return gcd(b, a%b);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CF_275
{
    class Program
    {
        public class IO
        {
            public static void Read(string inputString, out Int32 n)
            {
                bool succeded = Int32.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Int64 n)
            {
                bool succeded = Int64.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Single n)
            {
                bool succeded = Single.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Double n)
            {
                bool succeded = Double.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out Char n)
            {
                bool succeded = Char.TryParse(inputString, out n);
                if (succeded == false)
                    throw new FormatException("Input string was not in correct form");
            }

            public static void Read(string inputString, out string outputString)
            {
                outputString = inputString;
            }

            public static void Read(string inputString, out List<Int32> result)
            {
                Int32 n = 0;
                result = new List<Int32>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        result.Add(n);
                        n = 0;
                    }

                if (n != 0)
                    result.Add(n);
            }

            public static void Read(string inputString, out List<Int64> result)
            {
                Int64 n = 0;
                result = new List<Int64>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        result.Add(n);
                        n = 0;
                    }

                if (n != 0)
                    result.Add(n);
            }

            public static void Read(string inputString, out List<Single> result)
            {
                Int32 integer = 0;
                Int32 rational = 0;

                Boolean ReadingInteger = true;

                result = new List<Single>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == ' ')
                    {
                        result.Add(MergeSingle(integer, rational));

                        integer = 0;
                        rational = 0;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (integer != 0 || rational != 0)
                    result.Add(MergeSingle(integer, rational));
            }

            public static void Read(string inputString, out List<Double> result)
            {
                Int64 integer = 0;
                Int64 rational = 0;

                Boolean ReadingInteger = true;

                result = new List<Double>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == ' ')
                    {
                        result.Add(MergeDouble(integer, rational));

                        integer = 0;
                        rational = 0;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (integer != 0 || rational != 0)
                    result.Add(MergeDouble(integer, rational));
            }

            public static void Read(string inputString, out List<Int32> result, Boolean readNegatives)
            {
                Int32 n = 0;
                Boolean plus = true;

                result = new List<Int32>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        if (plus == true)
                            result.Add(n);
                        else
                            result.Add(-n);

                        n = 0;
                        plus = true;
                    }
                }

                if (plus == true)
                    result.Add(n);
                else
                    result.Add(-n);
            }

            public static void Read(string inputString, out List<Int64> result, Boolean readNegatives)
            {
                Int64 n = 0;
                Boolean plus = true;

                result = new List<Int64>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] != ' ')
                        n = n * 10 + (inputString[i] - '0');
                    else
                    {
                        if (plus == true)
                            result.Add(n);
                        else
                            result.Add(-n);

                        n = 0;
                        plus = true;
                    }
                }

                if (plus == true)
                    result.Add(n);
                else
                    result.Add(-n);
            }

            public static void Read(string inputString, out List<Single> result, Boolean readNegatives)
            {
                Int32 integer = 0;
                Int32 rational = 0;
                Boolean plus = true;

                Boolean ReadingInteger = true;

                result = new List<Single>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] == ' ')
                    {
                        if (plus == true)
                            result.Add(MergeSingle(integer, rational));
                        else
                            result.Add(-MergeSingle(integer, rational));

                        integer = 0;
                        rational = 0;
                        plus = true;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (plus == true)
                    result.Add(MergeSingle(integer, rational));
                else
                    result.Add(-MergeSingle(integer, rational));
            }

            public static void Read(string inputString, out List<Double> result, Boolean readNegatives)
            {
                Int64 integer = 0;
                Int64 rational = 0;
                Boolean plus = true;

                Boolean ReadingInteger = true;

                result = new List<Double>();

                Int32 strSize = inputString.Length;
                for (Int32 i = 0; i < strSize; i++)
                {
                    if (inputString[i] == '-')
                    {
                        plus = false;
                        continue;
                    }

                    if (inputString[i] == ' ')
                    {
                        if (plus == true)
                            result.Add(MergeDouble(integer, rational));
                        else
                            result.Add(-MergeDouble(integer, rational));

                        integer = 0;
                        rational = 0;
                        plus = true;

                        ReadingInteger = true;

                        continue;
                    }

                    if (inputString[i] == '.')
                    {
                        ReadingInteger = false;
                        continue;
                    }

                    if (ReadingInteger == true)
                        checked { integer = integer * 10 + inputString[i] - '0'; }
                    else
                        checked { rational = rational * 10 + inputString[i] - '0'; }
                }

                if (plus == true)
                    result.Add(MergeDouble(integer, rational));
                else
                    result.Add(-MergeDouble(integer, rational));
            }

            public static void Read(string inputString, out List<Char> result)
            {
                result = inputString.ToList<char>();
            }

            public static void FormatString<T>(T n, ref string result, bool newLine = true)
            {
                if (newLine == true)
                    result += n.ToString() + Environment.NewLine;
                else
                    result += n.ToString() + " ";
            }

            public static void FormatString<T>(List<T> n, ref string result, bool newLine = false)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(result);

                if (newLine == false)
                    foreach (var item in n)
                        sb.Append(item + " ");
                else
                    foreach (var item in n)
                        sb.Append(item + Environment.NewLine);

                result = sb.ToString();
            }

            private static Single MergeSingle(Int32 integer, Int32 rational)
            {
                Func<Int32, Int32> nrCifre = n => { Int32 cnt = 0; while (n != 0) { n /= 10; cnt++; } return cnt; };
                Func<Int32, Int32> zecePow = n => { Int32 p = 1; for (int j = 0; j < n; j++) p *= 10; return p; };
                Func<Int32, Single> parteFract = n => { Int32 cateCifre = nrCifre(n); return (Single)n / (Single)zecePow(cateCifre); };

                Single f = integer + parteFract(rational);
                return f;
            }

            private static Double MergeDouble(Int64 integer, Int64 rational)
            {
                Func<Int64, Int32> nrCifre = n => { Int32 cnt = 0; while (n != 0) { n /= 10; cnt++; } return cnt; };
                Func<Int32, Int64> zecePow = n => { Int64 p = 1; for (int j = 0; j < n; j++) p *= 10; return p; };
                Func<Int64, Double> parteFract = n => { int cateCifre = nrCifre(n); return (Double)n / (Double)zecePow(cateCifre); };

                Double d = integer + parteFract(rational);
                return d;
            }
        }

        public class Math
        {
            public static List<Int64> PrimeNumbers(Int64 upperBound)
            {
                List<Int64> listOfPrimes = new List<Int64>();
                Int64 sqrtUB = (Int64)System.Math.Sqrt(upperBound) + 1;

                Boolean[] isNotPrime = new Boolean[upperBound + 1];
                isNotPrime[1] = true;
                isNotPrime[2] = false;

                for (Int64 i = 2; i < sqrtUB; i++)
                    if (isNotPrime[i] == false)
                        for (Int64 j = i * i; j <= upperBound; j += i)
                            isNotPrime[j] = true;

                for (int i = 2; i <= upperBound; i++)
                    if (isNotPrime[i] == false)
                        listOfPrimes.Add(i);

                return listOfPrimes;
            }

            public static Boolean IsPrime(Int64 n)
            {
                if (n < 2)
                    return false;

                for (Int64 i = 2; i * i < n; i++)
                    if (n % i == 0)
                        return false;

                return true;
            }

            public static Int64 GCD (Int64 a, Int64 b)
            {
                Int64 c;

                while ( a != 0 ) {
                    c = a; a = b % a;  b = c;
                }

                return b;
            }
        }

        static void Main(string[] args)
        {
            List<Int64> v;
            IO.Read(Console.ReadLine(), out v);

            Int64 l = v[0];
            Int64 r = v[1];

            Console.WriteLine(l + " " + r);

            Boolean ok = false;
            for (Int64 i = l; i <= r; i++)
            {
                for (Int64 j = i + 1; j <= r; j++)
                {
                    for (Int64 k = j + 1; k <= r; k++)
                    {
                        if (Math.GCD(i, j) == 1 && Math.GCD(j, k) == 1 && Math.GCD(k, i) != 1)
                        {
                            Console.WriteLine(i + " " + j + " " + k);
                            ok = true;
                            goto label;
                        }
                    }
                }
            }

            label:
            if (ok == false)
                Console.WriteLine("-1");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication6
{
    class Program
    {
        public static long NOD(long a, long b)
        {
            while (b != 0)
                b = a % (a = b);
            return a;
        }
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] s1 = s.Split(' ');
            long l = long.Parse(s1[0]);
            long r = long.Parse(s1[1]);
            for (long i = l; i<=r;i++)
                for (long j = l+1;j<=r;j++)
                    for (long k = l+2;k<=r;k++)
                    {
                        if ((NOD(i,k)!=1)&&(NOD(i,j)==1)&&(NOD(j,k)==1))
                        {
                            Console.WriteLine("{0} {1} {2}",i,j,k);
                            return;
                        }
                    }
            Console.WriteLine("-1");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces275
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            string[] s1 = s.Split(' ');
            long l = long.Parse(s1[0]);
            long r = long.Parse(s1[1]);
            long min;
            if (l>r) min = r;
            else min = l;
            for (int i = 1;i<=min; i++)
            {
                if ((l % i == 0)&&(r % i == 0))
                {
                    l += 1;
                    if (l+1<r)
                    {
                        Console.WriteLine("{0} {1} {2}",l, l + 1, r);
                    }
                    else
                    {
                        Console.WriteLine("-1");
                    }
                }
                else
                {
                    if (l + 1 < r)
                    {
                        Console.WriteLine("{0} {1} {2}", l, l + 1, r);
                    }
                    else
                    {
                        Console.WriteLine("-1");
                    }

                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Runtime.Remoting.Messaging;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Xml;

namespace codeforces
{
	class Program
	{
		public class User
		{
			public int c;

			public int r;
		}

		public class Comparer : IComparer<User>
		{
			public int Compare(User x, User y)
			{
				if (x.c < y.c || (x.c == y.c && x.r < y.r))
					return -1;
				return 1;
			}
		}

		public static long getGcd(long a, long b)
		{
			if (b == 0)
				return a;
			return getGcd(b, a % b);
		}

		public static void WriteYESNO(bool x, string yes = "YES", string no = "NO")
		{
			if (x)
				Console.WriteLine(yes);
			else
			{
				Console.WriteLine(no);
			}
		}

		public static string GetString()
		{
			return Console.ReadLine();
		}

		public static List<int> getList()
		{
			var s = Console.ReadLine();
			return s.Split(' ').Select(int.Parse).ToList();
		}

		public static int Min(int x, int y)
		{
			return Math.Min(x, y);
		}

		public static int Max(int x, int y)
		{
			return Math.Max(x, y);
		}

		public static int Abs(int x)
		{
			return Math.Abs(x);
		}

		public static int getInt()
		{
			var s = Console.ReadLine();
			return int.Parse(s);
		}

		public static bool Equal(int x, int y, int x1, int y1)
		{
			return x == x1 && y == y1;
		}

		public class Vertex
		{
			public List<int> edges;

			public int ct;

			public Vertex()
			{
				ct = 0;
				edges = new List<int>();
				for (var i = 0; i < 26; ++i)
					edges.Add(0);
			}
		}

		private static void Main(string[] args)
		{
/*			var input = new StreamReader("input.txt");
			var output = new StreamWriter("output.txt");*/
			var l = Console.ReadLine().Split(' ').Select(long.Parse).ToList();
			if (l[1] - l[0] < 2)
				Console.WriteLine(-1);
			else
			{
				Console.WriteLine("{0} {1} {2}", l[0], l[0] + 1, l[0] + 2);
			}
			/*			input.Close();
			output.Close();*/
		}
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces._275
{
    class ProblemA
    {
        public static void Main(string[] varg)
        {
            string[] tokens = System.Console.ReadLine().Split(new char[] { ' ' });
            Int64 a = Int64.Parse(tokens[0]);
            Int64 b = Int64.Parse(tokens[1]);

            for (Int64 i=a;i<=b;i++)
            {
                for (Int64 j=i+1;j<=b;j++)
                {
                    for (Int64 k = j+1;j<=b;j++)
                    {
                        if (isCoprime(i,j) && isCoprime(j,k) && !isCoprime(i,k))
                        {
                            System.Console.WriteLine(String.Format("{0} {1} {2}", i,j,k));
                            return;
                        }
                    }
                }
            }
            System.Console.WriteLine("-1");
            return;

        }
        private static bool isCoprime(Int64 a, Int64 b)
        {
            HashSet<int> fact1 = new HashSet<int>();
            for (Int64 i=2;i<50;i++)
            {
                if (a % i == 0 && b % i == 0)
                    return true;
            }
            return false;

        }
    }
}

using System;
using System.Linq;

namespace _483A
{
    class Program
    {
        static void Main(string[] args)
        {
            var s = Console.ReadLine().Split().Select(long.Parse).ToArray();
            var l = s[0];
            var r = s[1];
            for (long a = l; a <= r; a++)
            {
                for (long b = l + 1; b <= r; b++)
                {
                    for (long c = l + 2; c <= r; c++)
                    {
                        if (gcd(a, b) == 1 && gcd(b, c) == 1 && gcd(a, c) != 1)
                        {
                            Console.WriteLine(a + " " + b + " " + c);
                            return;
                        }
                    }
                }
            }
            Console.WriteLine(-1);
        }

        static long gcd(long a, long b)
        {
            if (b == 0) return a;
            return gcd(b, a % b);
        }
    }
}