codeparrot/codecomplex huggingface dataset:
// Problem: 483_A. Counterexample 
// Time complexity: constant

import java.util.Scanner;

public class A {
    static long l, r, A, B, C;

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

    static boolean gcd(long a, long b) {
        return GCD(a, b) == 1;
    }

    static boolean found(long a, long b, long c) {
        if (b <= a || c <= b)
            return false;
        if (a > r || b > r || c > r)
            return false;
        if (gcd(a, b) && gcd(b, c) && !gcd(a, c)) {
            A = a;
            B = b;
            C = c;
            return true;
        }
        if (found(a + 1, b + 1, c + 1))
            return true;
        if (found(a + 1, b, c + 1))
            return true;
        if (found(a + 1, b + 1, c))
            return true;
        if (found(a, b, c + 1))
            return true;
        if (found(a, b + 1, c + 1))
            return true;
        if (found(a, b + 1, c))
            return true;
        return found(a + 1, b, c);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        l = sc.nextLong();
        r = sc.nextLong();
        if (found(l, l + 1, l + 2))
            System.out.println(A + " " + B + " " + C);
        else
            System.out.println(-1);
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;


public class BB {
public static void main(String[] args) {
	Scanner sc=new Scanner(System.in);
	long a=sc.nextLong();
	long b=sc.nextLong();
	
	if(b-a>(long)2){
		if(a%(long)2==0){
			System.out.print(a+" "+(a+1)+" "+(a+2));
			return;
		}else{
			System.out.print(a+1+" "+(a+2)+" "+(a+3));
			return;
		}
		
	}else{
		if(b-a<=(long)1){
		System.out.println(-1);
		return;
		}
		if(b-a==(long)2){
			if(a%(long)2==0){
				System.out.print(a+" "+(a+1)+" "+(a+2));
				return;
			}else{
				System.out.print(-1);
				return;
			}	
			
			}
	}

}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

/**
 * Created by Egor on 24/10/14.
 */
public class TaskA {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter writer = new PrintWriter(System.out);
        String[] input = reader.readLine().split(" ");

        long l = Long.parseLong(input[0]);
        long r = Long.parseLong(input[1]);
        if (l % 2 == 0) {
            if (r >= l + 2) {
                writer.println(l + " " + (l + 1) + " " + (l + 2));
            } else {
                writer.println(-1);
            }
        } else {
            if (r >= l + 3) {
                writer.println((l + 1) + " " + (l + 2) + " " + (l + 3));
            } else {
                writer.println(-1);
            }
        }

        writer.close();
    }

}
// Problem: 483_A. Counterexample 
// Time complexity: constant

import java.util.Scanner;


public class A {
    public static void main(String[] args) {
       
        Scanner in = new Scanner(System.in);
        
        long l = in.nextLong();
        long r = in.nextLong();
        
        if(r-l < 2 ){
            System.out.println("-1");
        }
        
        else if(r-l == 2 && l %2 ==1){
            System.out.println("-1");
        }
        else{
            
            
            if(l%2 == 0){
                System.out.println(l+ " "+(l+1)+" "+(l+2));
                
            }
            else{
                System.out.println((l+1)+ " "+(l+2)+" "+(l+3));
            }
        }
            
        }
    }
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


public class CodeForce275A {
    
    public static void main(String[] args) throws IOException {

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer token = new StringTokenizer(in.readLine());
        long l = Long.parseLong(token.nextToken());
        long r = Long.parseLong(token.nextToken());
        
        
        if(r-l<2) {
            System.out.println(-1);
            return;
        }
        if(l%2==1&&r-l<3) {
            System.out.println(-1);
            return;
        }
        if(l%2==0) {
            System.out.println(l+" "+(l+1)+" "+(l+2));
            return;
        }
        if(l%2==1) {
            System.out.println((l+1)+" "+(l+2)+" "+(l+3));
        }
    }

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;

public class p481a {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long l = sc.nextLong();
        long r = sc.nextLong();
        if (r - l <= 1) {
            System.out.println("-1");
        } else if (r - l >= 3) {
            if (l % 2 == 0) {
                System.out.println(l + " " + (l + 1) + " " + (l + 2));
            } else {
                System.out.println((l + 1) + " " + (l + 2) + " " + (l + 3));
            }
        } else {
            long g1 = GCD(l, (l + 1));
            long g2 = GCD((l + 1), (l + 2));
            long g3 = GCD(l, r);
            if (g1 == 1 && g2 == 1 && g3 != 1) {
                System.out.println(l + " " + (l + 1) + " " + r);
            } else {
                System.out.println("-1");
            }
        }
    }

    public static long GCD(long a, long b) {
        if (b == 0) return a;
        return GCD(b, a % b);
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Scanner;
import java.util.TreeSet;

/**
 *
 * @author таня
 */
public class KF {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException {
  B jk = new B();
    }
}


class B {

    PrintWriter out = new PrintWriter(System.out);
    Scanner in = new Scanner(System.in);
    long l = in.nextLong();
    long r=in.nextLong();
B(){
if(Math.abs(r-l)>=2){
if(l%2==0){
out.print(l+" "+(l+1)+" "+(l+2));
}
else{
if(Math.abs(r-l)==2){
out.print("-1");
}else{
out.print((l+1)+" "+(l+2)+" "+(l+3));
}
}
}else{
out.print("-1");
}
out.flush();
}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.util.*;
public class A{
	public static BufferedReader k;
	public static BufferedWriter z;
	

	
	public static void main(String [] args)throws IOException{
		k = new BufferedReader(new InputStreamReader(System.in));
		z = new BufferedWriter(new OutputStreamWriter(System.out));
		
		
	        String[] dat = k.readLine().split(" ");

	        long l = Long.parseLong(dat[0]);
	        long r = Long.parseLong(dat[1]);
			
			if(r-l<=1){
				z.write(-1+"\n");
			}
			else if(r-l == 2){
				
				
				if((l&1)!=0){
					z.write(-1+"\n");
				}
				else{
					z.write(l+" "+(l+1)+" "+r+"\n");
				}
				
			}
			else{
				if((l&1)==0){
					z.write(l+" "+(l+1)+" "+(l+2)+"\n");
				}
				else{
					z.write((l+1)+" "+(l+2)+" "+(l+3)+"\n");
				}
			}
			
			
			
			
		
		z.flush();

	}

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;

public class a {
    public static class Pair implements Comparable<Pair> {
        int f, s;

        public Pair(int f, int s) {
            this.f = f;
            this.s = s;
        }

        @Override
        public int compareTo(Pair o) {
            return s - o.s;
        }

    };

    public static void main(String[] args) throws IOException {
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s[] = in.readLine().split(" ");
        long r = Long.parseLong(s[0]);
        long l = Long.parseLong(s[1]);
        if (r % 2 == 0) {
            if (l - r+1 < 3) {
                out.println(-1);
            } else {
                out.println(r + " " + (r + 1) + " " + (r + 2));
            }
        } else {
            if (l - r+1 < 4) {
                out.println(-1);
            } else {
                out.println((r + 1) + " " + (r + 2) + " " + (r + 3));
            }

        }
        out.close();

    }

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.math.*;
import java.util.*;


public class Main {


	public static class pair implements Comparable<pair>
	{
		int a;
		int b;
		public pair(int pa, int pb)
		{
			a = pa; b= pb;
		}
		@Override
		public int compareTo(pair o) {
			if(this.a < o.a)
				return -1;
			if(this.a > o.a)
				return 1;
			return Integer.compare(o.b, this.b);
		}
	}


	//int n = Integer.parseInt(in.readLine());
	//int n = Integer.parseInt(spl[0]);
	//String[] spl = in.readLine().split(" ");
		
	public static void main (String[] args) throws Exception
	{	
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		String[] spl = in.readLine().split(" ");
		long l = Long.parseLong(spl[0]);
		long r = Long.parseLong(spl[1]);
		if(l+2 <= r && l%2==0)
		{
			System.out.println(l+" "+(l+1)+" "+(l+2));
		}
		else if(l+3<=r && (l+1)%2==0)
		{
			System.out.println((l+1)+" "+(l+2)+" "+(l+3));
		}
		else System.out.println(-1);
	}

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Task483A {

    public static void main(String... args) throws NumberFormatException,
            IOException {
        Solution.main(System.in, System.out);
    }

    static class Scanner {

        private final BufferedReader br;
        private String[] cache;
        private int cacheIndex;

        Scanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
            cache = new String[0];
            cacheIndex = 0;
        }

        int nextInt() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Integer.parseInt(cache[cacheIndex++]);
        }

        long nextLong() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return Long.parseLong(cache[cacheIndex++]);
        }

        String next() throws IOException {
            if (cacheIndex >= cache.length) {
                cache = br.readLine().split(" ");
                cacheIndex = 0;
            }
            return cache[cacheIndex++];
        }

        void close() throws IOException {
            br.close();
        }

    }


    static class Solution {


        public static void main(InputStream is, OutputStream os)
                throws NumberFormatException, IOException {
            PrintWriter pw = new PrintWriter(os);
            Scanner sc = new Scanner(is);

            long l = sc.nextLong();
            long r = sc.nextLong();

            long interval = r-l;

            if(interval == 0 || interval == 1 || (interval == 2 && l % 2 ==1 )){
                pw.println(-1);
            } else {
                if(l % 2 == 1){
                    l++;
                }
                pw.print(l);
                pw.print(" ");
                pw.print(l+1);
                pw.print(" ");
                pw.print(l+2);
            }



            pw.flush();
            sc.close();
        }
    }

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class A483 implements Runnable {

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	public static void main(String[] args) {
		new Thread(null, new A483(), "", 256 * (1L << 20)).start();
	}

	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			if (System.getProperty("ONLINE_JUDGE") != null) {
				in = new BufferedReader(new InputStreamReader(System.in));
				out = new PrintWriter(System.out);
			} else {
				in = new BufferedReader(new FileReader("input.txt"));
				out = new PrintWriter(System.out);
			}
			Locale.setDefault(Locale.US);
			solve();
			in.close();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Throwable t) {
			t.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	String readString() throws IOException {
		while (!tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	int readInt() throws IOException {
		return Integer.parseInt(readString());
	}

	long readLong() throws IOException {
		return Long.parseLong(readString());
	}

	double readDouble() throws IOException {
		return Double.parseDouble(readString());
	}

	// solution
	int choose(int total, int choose){
	    if(total < choose)
	        return 0;
	    if(choose == 0 || choose == total)
	        return 1;
	    return choose(total-1,choose-1)+choose(total-1,choose);
	}
	void solve() throws IOException {
		long l = readLong();
		long r = readLong();
		if(r-l>=3){
			long c = l%2==0?l:l+1;
			out.println(c+" "+(c+1)+" "+ (c+2));
		}else if(r-l==2&&r%2==0){
			out.println(l+" "+(l+1)+" "+(l+2));
		}else{
			out.println(-1);
		}
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;


public class A {

	public static void main(String[] args) {
		Scanner sc =new Scanner (System.in);
        long a=sc.nextLong(); long b=sc.nextLong();
        
        if(b-a <=1)
        	System.out.println("-1");
        else if(b-a==2 && a%2==1)
        	System.out.println("-1");
        else
        {
        	if(a%2==1)
        		System.out.println((a+1)+" "+(a+2)+" "+(a+3));
        	else
        		System.out.println((a)+" "+(a+1)+" "+(a+2));
        }
        sc.close();
	}

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        Scanner sc = new Scanner(System.in);
        long l= sc.nextLong();
        long r = sc.nextLong();
        if(l%2==0){
            if(r>=l+2){
                System.out.println(l + " " + (l+1) + " " + (l+2));
            }
            else{
                System.out.println(-1);
            }
        }
        else{
            if(r>=l+3){
                System.out.println((l+1) + " " + (l+2) + " " + (l+3));
            }
            else{
                System.out.println(-1);
            }
        }
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant

import java.math.BigInteger;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author Sagimbekov_MA
 */
public class A483 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        BigInteger l = sc.nextBigInteger();
        BigInteger r = sc.nextBigInteger();
        
        if (r.subtract(l).compareTo(new BigInteger("2")) == -1) {
            System.out.println("-1");
        } else if (r.subtract(l).compareTo(new BigInteger("2")) == 0 && l.mod(new BigInteger("2")) != BigInteger.ZERO) {
            System.out.println("-1");
        } else if (l.mod(new BigInteger("2")) != BigInteger.ZERO) {
            System.out.println(l.add(BigInteger.ONE) + " " + l.add(BigInteger.ONE).add(BigInteger.ONE) + " " + l.add(BigInteger.ONE).add(BigInteger.ONE).add(BigInteger.ONE));
        } else {
            System.out.println(l + " " + l.add(BigInteger.ONE) + " " + l.add(BigInteger.ONE).add(BigInteger.ONE));
        }
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.StringTokenizer;


public class problemA {
    public  static long GCD(long number1, long number2) {
        //base case
        if(number2 == 0){
            return number1;
        }
        return GCD(number2, number1%number2);
    }
  

public static void main(String[] args) throws NumberFormatException, IOException {
    BufferedReader br = new BufferedReader (new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        long b =  Long.parseLong(st.nextToken());
        long c =  Long.parseLong(st.nextToken());
        if(c-b<2 ||((c-b==2)&& GCD(c,b)==1) ){
            System.out.println("-1");
        }else{
                if(b%2==0 ){
                    System.out.println(b+" "+(b+1)+" "+(b+2));
            }else
                System.out.println((b+1)+" "+(b+2)+" "+(b+3));
        
    
    
}
        

        

}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.math.BigInteger;


public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

		try {
			String[] str = reader.readLine().split(" ");
			BigInteger b1 = new BigInteger(str[0]);
			BigInteger b2 = new BigInteger(str[1]);

			if(b2.subtract(b1).compareTo(new BigInteger("1"))<1){
				System.out.println(-1);
				return;
			}

			if(b2.subtract(b1).compareTo(new BigInteger("2"))==0){
				BigInteger b = b1.add(new BigInteger("1"));
				BigInteger c = b1.add(new BigInteger("2"));

				if(!b1.gcd(c).equals(new BigInteger("1"))){
					System.out.println(b1.toString()+" "+b.toString()+" "+c.toString());
				}else{
					System.out.println(-1);
				}
				return;
			}

			BigInteger b = b1.add(new BigInteger("1"));
			BigInteger c = b1.add(new BigInteger("2"));
			BigInteger d = b1.add(new BigInteger("3"));

			if(b1.remainder(new BigInteger("2")).equals(new BigInteger("1"))){
				System.out.println(b.toString()+" "+c.toString()+" "+d.toString());
			}else{
				System.out.println(b1.toString()+" "+b.toString()+" "+c.toString());
			}

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;

public class dwl {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		String[] lr = sc.nextLine().split(" ");
		long l = Long.valueOf(lr[0]);
		long r = Long.valueOf(lr[1]);

		if (r - l <= 1 || (l == 1 && (r - l) == 2)
				|| (l % 2 != 0 && (r - l) < 3))
			System.out.println(-1);
		else {
			if (l == 1)
				System.out.println(2 + " " + 3 + " " + 4);
			else {
				if (l % 2 == 0) {
					String res = "";
					res += l + " ";
					res += (l + 1) + " ";
					res += (l + 2) + " ";
					res = res.trim();
					System.out.println(res);
				} else {
					String res = "";
					res += (l + 1) + " ";
					res += (l + 2) + " ";
					res += (l + 3) + " ";
					res = res.trim();
					System.out.println(res);

				}
			}

		}

	}

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.StringTokenizer;

public class A {

    public static void main(String[] args) {
        InputScanner scanner = new InputScanner();
        try {
            long l = scanner.nextLong();
            long r = scanner.nextLong();
            if ((r - l) < 2) {
                System.out.println("-1");
                return;
            }

            if (l % 2 == 0) {
                long a = l;
                long b = l + 1;
                long c = l + 2;
                System.out.println(a + " " + b + " " + c);
            } else if (r%2==0){
                long a = r;
                long b = r-1;
                long c = r-2;
                System.out.println(c + " " + b + " " + a);
            } else {
                l++;
                if ((r - l) < 2) {
                    System.out.println("-1");
                    return;
                }
                long a = l;
                long b = l + 1;
                long c = l + 2;
                System.out.println(a + " " + b + " " + c);
            }
        } catch (IOException e) {

        }


    }

    static class InputScanner {

        BufferedReader br;
        StringTokenizer st;

        public InputScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() throws IOException {
            if (st == null || !st.hasMoreTokens()) {
                String line = br.readLine();
                st = new StringTokenizer(line);
            }
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            String next = next();
            next.length();
            return Integer.parseInt(next);
        }

        public long nextLong() throws IOException {
            String next = next();
            next.length();
            return Long.parseLong(next);
        }
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant

import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long l = sc.nextLong(), r = sc.nextLong();
		if (l % 2 == 0 && r - l >= 2) {
			System.out.println(l + " " + (l + 1) + " " + (l + 2));
		} else if (l % 2 == 1 && r - l >= 3) {
			System.out.println(l + 1 + " " + (l + 2) + " " + (l + 3));
		} else {
			System.out.println(-1);
		}
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;


public final class b1 {

	public static void main(String[] args) {
		Scanner datain = new Scanner(System.in);
		long l=datain.nextLong();
		long r=datain.nextLong();
		if(r-l<2){System.out.print(-1);}else{
			if(((r-l)==2)&&(l%2==1)){System.out.print(-1);}else{
				if((l%2)==0){System.out.print(""+l+" "+(l+1)+" "+(l+2));}else{
					System.out.print(""+(l+1)+" "+(l+2)+" "+(l+3));
				}
			}
		}
	}

}