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;

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.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);
        }
    }
}