codeparrot/codecomplex huggingface dataset:
// 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 C {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer tokenizer=  new StringTokenizer(br.readLine());
		BigInteger left = new BigInteger(tokenizer.nextToken());
		BigInteger right= new BigInteger(tokenizer.nextToken());
		BigInteger val= (right.subtract(left)).add(new BigInteger(""+1));
		if(val.intValue()<3){
			System.out.println(-1);
			return;
			
		}


		BigInteger a, b, c;
		BigInteger i=left;
		while(i.intValue()<=right.intValue()){
			BigInteger temp1=i;  //a
			BigInteger temp2= i.add(new BigInteger(""+1));//b
			BigInteger j=temp2.add(new BigInteger(""+1));
			while(j.intValue()<=right.intValue()){
				BigInteger b1= temp2;
				BigInteger b2 =j;
				BigInteger b3 = temp1;
				BigInteger gcd= b1.gcd(b2);
				if(gcd.intValue()==1){
					BigInteger gcd2 =b2.gcd(b3);
					if(gcd2.intValue() !=1){
						a=b3;
						b= b1;
						c= b2;
						System.out.print(a+" "+b+" "+c+" ");
						System.out.println();
						return ;
					}

				}

				j=j.add(new BigInteger(""+1));
			}
			i=i.add(new BigInteger(""+1));

		}
		System.out.println(-1);
	}

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

public class Solution {

    public static void main(String[] args) {
        /* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
        Scanner t=new Scanner(System.in);
        long l=t.nextLong();
        long r=t.nextLong();
        if(r-l<2) System.out.println(-1);
        else if(r-l<3 && l%2!=0){
            if(l%3!=0) System.out.println(-1);
            else if ((l+3)%2==0) System.out.println(-1);
                else System.out.println(l+" "+(l+1)+" "+(l+3));
        } else{
            while (l%2!=0) l++;
            System.out.println(l+" "+(l+1)+" "+(l+2));
        }
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Locale;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.StringTokenizer;

public class A {
	static String file = "";
	static BufferedReader br;
	static PrintWriter pw;
	static StringTokenizer st;

	public static void main(String[] args) throws NumberFormatException,
			IOException {
		Locale.setDefault(Locale.US);

		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
				System.out)));
		long a = nextLong();
		long b = nextLong();
		if (a % 2 == 1 && b - a == 2 || b - a == 1 || a == b) {
			pw.print(-1);
		} else {
			if (a % 2 == 1)
				a++;
			pw.print(a + " " + (a + 1) + " " + (a + 2));
		}
		pw.close();
	}

	private static double yuza(double x1, double y1, double x2, double y2,
			double x3, double y3) {
		return (x1 * (y3 - y2) + x2 * (y1 - y3) + x3 * (y2 - y1));
	}

	private static void ffile() throws IOException {
		br = new BufferedReader(new FileReader(file + "in"));
		pw = new PrintWriter(new BufferedWriter(new FileWriter(file + "out")));
	}

	private static int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	private static long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	private static double nextDouble() throws NumberFormatException,
			IOException {
		return Double.parseDouble(next());
	}

	private static String next() throws IOException {
		while (st == null || !st.hasMoreTokens())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    public void solve(int testNumber, InputReader in, PrintWriter out) {
        long l = in.nextLong();
        long r = in.nextLong();
        int max = (int) (r - l);
        if (max >= 2) {
            if ((l & 1) == 0) {
                out.println(l + " " + (l + 1) + " " + (l + 2));
                return;
            } else {
                if (max >= 3) {
                    out.println((l + 1) + " " + (l + 2) + " " + (l + 3));
                    return;
                }
            }
        }
        out.println(-1);
    }
}

class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.concurrent.LinkedBlockingDeque;

import javax.swing.border.Border;

public class a {

	public static long mod = (long) Math.pow(10, 9) + 7;

	private static class node implements Comparable<node> {
		int x;
		int y;

		node(int x, int c) {
			this.x = x;
			this.y = c;

		}

		@Override
		public int compareTo(node o) {
			if (o.x < x)
				return 1;
			else if (o.x > x)
				return -1;
			else if (o.y < y)
				return 1;
			else if (o.y > y)
				return -1;
			else
				return 0;
		}

	}

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

		else
			return gcd(b, a % b);
	}

	public static void main(String[] args) throws IOException {
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
		StringBuilder qq = new StringBuilder();
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

		// int n = Integer.parseInt(in.readLine());
		String y[] = in.readLine().split(" ");
		long n = Long.parseLong(y[0]);
		long m = Long.parseLong(y[1]);

		if (m - n < 2) {
			System.out.println(-1);
		} else if (m - n == 2) {

			if (gcd(n, m) != 1)

				System.out.println(n + " " + (n + 1) + " " + (n + 2));

			else
				System.out.println(-1);
		} else {
			if (n % 2 == 0)
				System.out.println(n + " " + (n + 1) + " " + (n + 2));
			else
				System.out.println((n + 1) + " " + (n + 2) + " " + (n + 3));
		}

		out.close();

	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.*;
import java.util.*;
public class Main
{
	
	public static void main(String args[]) throws IOException
	{
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
String x[]=br.readLine().split(" ");
		long l=Long.parseLong(x[0]);
		long r=Long.parseLong(x[1]);
		if(l%2!=0)
		{
			l++;
		}
		if(l+2>r)
		{
			System.out.println("-1");
		}
		else
		{
			System.out.println(l+" "+(l+1)+" "+(l+2));
		}
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
import java.math.*;
import java.io.PrintStream;
import static java.lang.Math.*;

public class Task275A {

    public static Scanner in = new Scanner(System.in);
    public static PrintStream out = System.out;

    public static void main(String[] args) {
        long l = in.nextLong();
        long r = in.nextLong();

        if (l % 2 == 1) {
            l++;
        }

        if (r - l < 2) {
            out.print(-1);
        }
        else {
            out.print(l + " " + (l + 1) + " " + (l + 2));
        }
    }

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

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc= new Scanner(System.in);
		long l=sc.nextLong(),r=sc.nextLong();
		if (l%2==0&&r-l>=2) System.out.print(l+" "+(l+1)+" "+(l+2));
		else if (l%2==1&&r-l>=3) System.out.print((l+1)+" "+(l+2)+" "+(l+3));
		else System.out.print("-1");
	}

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

public class Main {

    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        long r,l;
          r = sc.nextLong();
          l = sc.nextLong();


            if ((r+2)>l) { System.out.print("-1"); return;}
            if ((r % 2) == 0)   {
              System.out.print(r);
                System.out.print(" ");
                System.out.print(r+1);
                System.out.print(" ");
                System.out.print(r+2);return; }
               if((r+3)<=l )
                {  System.out.print(r+1);
                System.out.print(" ");
                  System.out.print(r+2);
                System.out.print(" ");
                  System.out.print(r+3);return; }
             System.out.print("-1");


    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import static java.lang.Math.*;
import static java.util.Arrays.*;

public class Main {

	public static void main(String[] args) throws IOException {
		new Main().run();
	}

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

	private void run() throws IOException {
		if (new File("input.txt").exists())
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		if (new File("output.txt").exists())
			out = new PrintWriter("output.txt");
		else
			out = new PrintWriter(System.out);

		solve();

		in.close();
		out.close();
	}

	void solve() throws IOException {
		long l = nextLong();
		long r = nextLong();
		l += l % 2;
		if (l + 2 > r)
			out.println("-1");
		else {
			out.println(l + " " + (l + 1) + " " + (l + 2));
		}
	}

	String nextLine() throws IOException {
		st = new StringTokenizer("");
		return in.readLine();
	}

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

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}

	boolean EOF() throws IOException {
		while (!st.hasMoreTokens()) {
			String str = in.readLine();
			if (str == null)
				return true;
			st = new StringTokenizer(str);
		}
		return false;
	}

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

public class practice {
	public static void main(String[] args) throws Exception {
		//Scanner in = new Scanner(new File("practice.in"));
		Scanner in = new Scanner(System.in);

		String str = in.nextLine();
		long n = Long.parseLong(str.substring(0, str.indexOf(" ")));
		long m = Long.parseLong(str.substring(str.indexOf(" ") + 1));
		if(m - n < 2) {
			System.out.println("-1");
		} else {
			if(m - n == 2 && m % 2 == 1) {
				System.out.println("-1");
			} else {
				System.out.println((n + n % 2) + " " + (n + 1 + n % 2) + " " + (n + 2 + n % 2));
			}
		}
	}
}
// 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();
		in.close();
		if (r - l < 2) {
			System.out.println(-1);
			return;
		}
		if ((r - l > 2)||(l%2 ==0 )) {
			long s = l + l%2;
			System.out.println(s+" "+(s+1)+" "+(s+2));
		} else {
			if (l%2 == 1) {
				System.out.println(-1);
			} else{
				long s = l;
				System.out.println(s+" "+(s+1)+" "+(s+2));
			}
		}
		
	}
	static long gcd(long a, long b) {
		if(a==0) {
			return b;
		}
		if (b==0) {
			return a;
		}
		if (a > b) {
			return gcd (a%b, b);
		}
		return gcd (b%a, a);
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String [] line = br.readLine().split(" ");
		long l = Long.parseLong(line[0]);
		long r = Long.parseLong(line[1]);
		if(r-l < 2 || ((r-l == 2) && (l % 2 == 1)))
			System.out.println("-1");
		else
		{
			Long start = l + (l%2); 
			System.out.println(start + " " + (start + 1) + " " + (start + 2));
		}
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
import java.math.*;
public class fuck {
	public static int[] a;

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

public class Counterexample483A
{
    public static void main(String[] args) 
    {
        // Set up scanner
        Scanner sc = new Scanner(System.in); 
        // System.out.println("Enter l");
        long l = sc.nextLong();
        // System.out.println("Enter r");
        long r = sc.nextLong();
        
        if (l==r || l+1 == r)
        {
            System.out.println(-1);
            return;
        }
        if (l+2 == r && l%2 == 1)
        {
            System.out.println(-1);
            return;
        }
        if (l%2 == 0)
        {
            System.out.println(l + " " + (l+1) + " " + (l+2));
            return;
        }
        System.out.println((l+1) + " " + (l+2) + " " + (l+3));
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		BigInteger l = new BigInteger(scanner.next());
		BigInteger r = new BigInteger(scanner.next());
		if(r.subtract(l).intValue() < 2) {
			System.out.println(-1);
			return;
		}
		BigInteger a = l.abs(),b,c;
		
		BigInteger toothless = r.subtract(BigInteger.valueOf(1));
		while(a.compareTo(toothless) == -1) {
			b = l.add(BigInteger.valueOf(1));
			while(b.compareTo(r) == -1) {
				c = l.add(BigInteger.valueOf(2));
				while(c.compareTo(r) == -1 || c.compareTo(r) == 0) {
					if(gcd(a,b) == 1 && gcd(b,c) == 1 && gcd(a,c) != 1) {
						System.out.println(a + " " + b + " " + c);
						return;
					}
					
					c = c.add(BigInteger.valueOf(1));
				}
				b = b.add(BigInteger.valueOf(1));
			}
			a = a.add(BigInteger.valueOf(1));
		}
		System.out.println(-1);
	}
	private static int gcd(BigInteger a, BigInteger b) {
		return a.gcd(b).intValue();
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
import java.io.*;
import java.math.*;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		BigInteger l = sc.nextBigInteger();
		BigInteger r = sc.nextBigInteger();
		BigInteger a = l.add(BigInteger.ZERO);
		while (a.compareTo(r) < 0) {
			BigInteger b = a.add(BigInteger.ONE);
			while (b.compareTo(r) < 0) {
				try {
					a.modInverse(b);
				} catch (ArithmeticException e) {
					b = b.add(BigInteger.ONE);
					continue;
				}
				BigInteger c = b.add(BigInteger.ONE);
				while (c.compareTo(r) <= 0) {
					try {
						b.modInverse(c);
						try {
							a.modInverse(c);
						} catch (ArithmeticException e) {
							System.out.printf("%s %s %s\n", a.toString(), b.toString(), c.toString());
							return;
						}
					} catch (ArithmeticException e) {
						
					}
					c = c.add(BigInteger.ONE);
				}
				b = b.add(BigInteger.ONE);
			}
			a = a.add(BigInteger.ONE);
		}
		System.out.println("-1");
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
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(l % 2 == 0)
                System.out.println(l + " " + (l+1) + " " + (l+2));
            else {
                if(r - l < 3) System.out.println(-1);
                else
                    System.out.println((l+1) + " " + (l+2) + " " + (l+3));
            }
        }
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
import java.io.*;

public class Main {

	public static void main(String[] args) {		
		new TaskA().solve();
	}

}

class TaskA extends Base {	
	public static void solve () {
		long l = in.nextLong();
		long r = in.nextLong();		
		
		if (r - l < 2) {
			System.out.println(-1);
			return;
		}
		
		if (l % 2 == 0) {
			System.out.println(l + " " + (l + 1) + " " + (l + 2));
			return;
		}
		
		if (r - l > 2) {
			System.out.println((l + 1) + " " + (l + 2) + " " + (l + 3));
			return;
		}
		
		System.out.println(-1);		
	}
}

class Base {
	public static InputReader in = new InputReader(System.in);
}

class InputReader {
	BufferedReader reader;
	StringTokenizer tokenizer;
	
	public InputReader (InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}
	
	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {			
				e.printStackTrace();
			}
		}
		return tokenizer.nextToken();
	}
	
	public int nextInt() {
		return Integer.parseInt(next());
	}
	
	public long nextLong() {
		return Long.parseLong(next());
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;


public class CF275Ad2 {
	
	public static void main(String[] args) throws Exception {
		
		Scanner scan = new Scanner(System.in);
		
		long l = scan.nextLong();
		long r = scan.nextLong();
		
		long diff = r-l;
		boolean exists = false;
		if(diff >= 3){
			if(l%2 == 1){
				l++;
			}
			exists = true;
		} else if(diff == 2 && l%2 == 0){
			exists = true;
		} else if(diff == 2 && gcd(l, r) > 1){
			exists = true;
		}
		
		if(!exists){
			System.out.println("-1");
		} else {
			System.out.println(l + " " + (l+1) + " " + (l+2));
		}
	}
	
	private static long gcd(long a, long b){
		if(b == 0){
			return 1;
		} 
		return gcd(b, a % b);
	}

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


public class A275 {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        
        long a=sc.nextLong();
        long b=sc.nextLong();
        
        if(b-a<2){
            System.out.println(-1);
        }else if(b-a==2 && a%2==1){
            System.out.println(-1);
        }else if(b-a==2 && a%2==0){
            System.out.println(a+" "+(a+1)+" "+(a+2));
        }else{
            if(a%2==0){
                System.out.println(a+" "+(a+1)+" "+(a+2));
            }else{
                System.out.println((a+1)+" "+(a+2)+" "+(a+3));
            }
        }
    }
}
// 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();
		long a = 0;
		long b = 0;
		long c = 0;
		if (r - l < 2)
			System.out.println(-1);
		else if (r - l < 3 && l % 2 == 1)
			System.out.println(-1);
		else {
			if (l % 2 == 0) {
				a = l;
				b = l + 1;
				c = l + 2;
			} else {
				if (l == 1) {
					a = 2;
					b = 3;
					c = 4;
				} else {
					a = l + 1;
					b = l + 2;
					c = l + 3;
				}
			}
			System.out.println(a + " " + b + " " + c);
		}
		
	}
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;


public class K603 {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        
        long a=sc.nextLong();
        long b=sc.nextLong();
        
        if(b-a<2){
            System.out.println(-1);
        }else if(b-a==2 && a%2==1){
            System.out.println(-1);
        }else if(b-a==2 && a%2==0){
            System.out.println(a+" "+(a+1)+" "+(a+2));
        }else{
            if(a%2==0){
                System.out.println(a+" "+(a+1)+" "+(a+2));
            }else{
                System.out.println((a+1)+" "+(a+2)+" "+(a+3));
            }
        }
    }
}
// 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%2==0){
					z.write(l+" "+(l+1)+" "+(l+2)+"\n");
				}
				else{
					z.write((l+1)+" "+(l+2)+" "+(l+3)+"\n");
				}
			}
			
			
			
			
		
		z.flush();

	}

}