codeparrot/codecomplex huggingface dataset:
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.*;
import java.math.*;

public class Counterexample {
    public static void main(String[] args) {
        System.out.println(new Counterexample().solve());
    }

    String solve() {
        Scanner sc = new Scanner(System.in);

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

        if ((r - l) > 1) {
            long a = l;
            long b = l + 1;
            long c = l + 2;

            while (a < (r - 1)) {
                while (b < r) {
                    while (c <= r) {
                        if (gcd(a,b) == 1
                                && gcd(b,c) == 1
                                && gcd(a,c) > 1) {
                            return Long.toString(a)
                                + " "
                                + Long.toString(b)
                                + " "
                                + Long.toString(c);
                                }
                        c += 1;
                    }
                    c = b + 1;
                    b += 1;
                }
                b = a + 1;
                a += 1;
            }
        }
        return "-1";
    }

    long gcd(long a, long b) {
        while (b != 0) {
            long t = b;
            b = a % b;
            a = t;
        }
        return a;
    }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class A {
  FastScanner in;
  PrintWriter out;

  public void run() {
    try {
      in = new FastScanner(new InputStreamReader(System.in));
      out = new PrintWriter(System.out);
      solve();
      out.close();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  public void solve() throws IOException {
    long l = new Long(in.next());
    long r = new Long(in.next());
    if (r - l < 2 || (r - l == 2 && l % 2 != 0)) {
      out.println("-1");
    } else {
      if (l % 2 != 0) {
        l++;
      }
      out.println(l);
      out.println(l+1);
      out.println(l+2);
    }
  }

  class FastScanner {
    BufferedReader br;
    StringTokenizer st;

    FastScanner(InputStreamReader in) {
      br = new BufferedReader(in);
    }

    String nextLine() {
      String str = null;
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }

      return str;
    }

    String next() {
      while (st == null || !st.hasMoreTokens()) {
        try {
          st = new StringTokenizer(br.readLine());
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
      return st.nextToken();
    }

    int nextInt() {
      return Integer.parseInt(next());
    }
  }

  public static void main(String[] arg) {
    A o = new A();
    o.run();
  }

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

	public static void main(String[] args) {		
		Scanner sc = new Scanner(System.in);
		
		long l = sc.nextLong();
		long h = sc.nextLong();
		
		sc.close();
		
		if(h-l<2) {
			System.out.println(-1);
			return ;
		}
		
		if(h-l==2 && l%2==1) {
			System.out.println(-1);
			return ;
		}
		
		if(l%2==1) {
			++l;
		}
		
		System.out.printf("%d %d %d\n",l,l+1L,l+2L);
	}

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

public class Main {
  // main
  public static void main(String [] args) throws IOException {
    // makes the reader and writer
    BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
    PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
    
    // read in 
    StringTokenizer st = new StringTokenizer(f.readLine());
    BigInteger l = new BigInteger(st.nextToken());
    BigInteger r = new BigInteger(st.nextToken());
    
    // write
    if (r.subtract(l).intValue()<2 || (r.subtract(l).intValue()==2 && r.mod(new BigInteger("2")).intValue()==1)) out.println(-1);
    else out.println(l.add(l.mod(new BigInteger("2"))).toString()+" "+l.add(l.mod(new BigInteger("2"))).add(new BigInteger("1")).toString()+" "+l.add(l.mod(new BigInteger("2"))).add(new BigInteger("2")).toString());
    
    // cleanup
    out.close();
    System.exit(0);
  }
}
// Problem: 483_A. Counterexample 
// Time complexity: constant
import java.util.Scanner;

public class A {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		long l = s.nextLong();
		long r = s.nextLong();
		s.close();
		
		if (r-l<2 || (r-l==2 && l%2==1)) {
			System.out.print("-1");
			return;
		}
		
		long beg = l%2==0 ? l : l+1;
		if (beg+2>r) System.out.print("-1");
		else System.out.print(beg+" "+(beg+1)+" "+(beg+2));
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;

public class A {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        if (n % 2 == 0) {
            System.out.printf("%d %d", 4, n - 4);
        } else {
            System.out.printf("%d %d", 9, n - 9);
        }
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.*;

public class Main {

    public static void main(String[] args) throws FileNotFoundException {
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        if (n%2==0) {
            System.out.println(4+" "+(n-4));
        } else {
            System.out.println(9+" "+(n-9));
        }

        in.close();
        out.close();
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;

public class Solution {

  public static void main(String[] args) throws Exception {
    Scanner in = new Scanner(System.in);
    int n = in.nextInt();
    if (n % 2 == 0)
      System.out.println("4 " + (n - 4));
    else
      System.out.println("9 " + (n - 9));
  }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.*;

public class LearnMath {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int N = scan.nextInt();
		scan.close();
		
		if ((N%2) == 0) {
			System.out.println(4 + " " + (N-4));
		}
		else {
			if (N > 18) {
				System.out.println(9 + " " + (N-9));
			}
			else {
				System.out.println((N-9) + " " + 9);
			}
		}

	}

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;


public class Composite {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		
		int n = in.nextInt();
		if (n == 12)
			System.out.println("4 8");
		
		else if (n % 2 == 1)
			System.out.println((n - 9) + " 9");
		
		else
			System.out.println((n - 6) + " 6");
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.StringTokenizer;
import static java.lang.Integer.*;

public class A {

    public static void main(String[] args) throws IOException {
        //BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
        Scanner sc=new Scanner (System.in);
    //  StringTokenizer st=new StringTokenizer(buf.readLine());
        int n=sc.nextInt();
        System.out.println(n%2==0?4+" "+(n-4):9+" "+(n-9));

    }

}
// Problem: 472_A. Design Tutorial: Learn from Math
// 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) {
        int n = in.nextInt();
        if (n % 2 == 0) {
            out.println(4 + " " + (n - 4));
        } else {
            out.println(9 + " " + (n - 9));
        }
    }
}

class InputReader {
    private final BufferedReader reader;
    private StringTokenizer tokenizer;

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

    public String nextLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(nextLine());
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.*;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
    public class Main
    {
        public static void main(String[] args)
        {
        Scanner sc =new Scanner(System.in);    
        long a=sc.nextLong();
        if(a%4==0){System.out.println(a/2 + " " + a/2);}
        if(a%4==1){System.out.println(9 + " " + (a-9));}
        if(a%4==2){System.out.println(6 + " " + (a-6));}
        if(a%4==3 && a>15){System.out.println(15 + " " + (a-15));}
        if(a==15){System.out.println("6 9");}
        
        }
    }
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;

public class Code1 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = Integer.valueOf(sc.nextLine());
        if (n % 2 == 0)
            System.out.println(4 + " " + (n - 4));
        else {
            System.out.println(9 + " " + (n - 9));
        }

    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class A {

	public static void main(String[] args) throws IOException {
		try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
			String input;

			while ((input = reader.readLine()) != null && input.length() > 0) {
				int n = Integer.parseInt(input);
				int start = 4;
				int end = n - start;

				while (start <= end) {
					if ((start % 2 == 0 || start % 3 == 0) && (end % 2 == 0 || end % 3 == 0)) {
						System.out.println(start + " " + end);
						break;
					}
					++start;
					--end;
				}
			}
		}
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;


public class A {

    public static void main(String[] args) {
         
        Scanner x=new Scanner(System.in);
        
        int n=x.nextInt();
                
                if(n%2==0){
                    
                    System.out.println((n-4)+" "+"4");
                }
                else{
                    
                    System.out.println((n-9)+" "+"9");
                    
                }
        
        
        
        
    }

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
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;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, Scanner in, PrintWriter out) {
        int N = in.nextInt();
        if (N % 2 == 0){
            out.println("4 " + (N - 4));
        }
        else {
            out.println("9 " + (N - 9));
        }
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// 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.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Solution {
	private BufferedReader cin;
	private PrintWriter cout;
	private StringTokenizer strtok;

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		Solution sol = new Solution();
		final boolean CONTEST = true;
		if (CONTEST) {
			sol.cin = new BufferedReader(new InputStreamReader(System.in));
			sol.cout = new PrintWriter(System.out);

		} else {
			sol.cin = new BufferedReader(new FileReader("input.txt"));
			sol.cout = new PrintWriter("output.txt");
		}
		sol.solve();
		sol.cin.close();
		sol.cout.close();
	}

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

	private String nextToken() throws IOException {
		while (strtok == null || !strtok.hasMoreTokens()) {
			strtok = new StringTokenizer(cin.readLine());
		}
		return strtok.nextToken();
	}

	private void solve() throws IOException {
		int n = nextInt();
		if (n % 2 == 0) {
			cout.println(n - 4 + " " + 4);
		} else {
			cout.println(n - 9 + " " + 9);
		}
	}

}
// Problem: 472_A. Design Tutorial: Learn from Math
// 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);
        int n = sc.nextInt();
        if(n%2==0){
            System.out.println(4 + " " + (n-4));
        }
        else{
            int a = Math.min(9,n-9);
            int b = Math.max(9,n-9);
            System.out.println(a + " " + b);
        }
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;

public class ProblemA {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(new InputStreamReader(System.in));
        int n = sc.nextInt();
        if (n % 2 == 0) {
            System.out.println((n - 4) + " " + 4);
        } else {
            System.out.println((n - 9) + " " + 9);
        }
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant

import java.util.Scanner;


public class composite {

  
    public static void main(String[] args) {
        
        Scanner s=new Scanner(System.in);
        int a=s.nextInt();
      
          if(a%2==0)
          {
              a=a-4;
              System.out.println(4+" "+a);
          }
          else
          {
              a=a-9;
              System.out.println(9+" "+a);
          }
      
    
}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// 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.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main
{

	private static BufferedReader in;
	private static BufferedWriter out;

	public static void main(String[] args) throws NumberFormatException, IOException
	{
		// streams
		boolean file = false;
		if (file)
			in = new BufferedReader(new FileReader("input.txt"));
		else
			in = new BufferedReader(new InputStreamReader(System.in));
		// out = new BufferedWriter(new OutputStreamWriter(System.out));
		out = new BufferedWriter(new FileWriter("output.txt"));
		StringTokenizer tok;

		int n = Integer.parseInt(in.readLine());
		if (n % 2 == 0)
			System.out.println(4 + " " + (n-4));
		else
			System.out.println(9 + " " + (n-9));
	}

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.*;
import java.util.*;

public class Main {
    private static PrintWriter out;
    private static FastReader in;

    private static class FastReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastReader(InputStream inputStream) {
            reader = new BufferedReader(
                    new InputStreamReader(inputStream), 1 << 16);
            tokenizer = null;
        }

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

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }

    public static void main(String[] args) throws FileNotFoundException, InterruptedException {
        in = new FastReader(System.in);
        out = new PrintWriter(System.out);

        int n = in.nextInt();
        int a = ((n & 1) == 0) ? a = 6 : 9;
        int b = n - a;
        out.println(a + " " + b);

        out.flush();
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.*;
import java.util.Scanner;


public class T
{
    public static void main(String[] args) throws IOException
    {
        T t = new T();
        t.run();
        t.close();
    }

    private void close()
    {
        sc.close();
        pw.close();
    }

    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    Scanner sc = new Scanner(reader);
    PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

    void yesno(boolean b)
    {
        pw.println(b ? "YES" : "NO");
    }


    void run() throws IOException
    {
        int n = sc.nextInt();

        if (n % 2 == 0)
        {
            pw.print(4 + " " + (n - 4));
        }
        else
        {
            pw.print(9 + " " + (n - 9));
        }

    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.*;
public class a {
public static void main(String[] args)
{
    Scanner input = new Scanner(System.in);
    int n = input.nextInt();
    if(n%2 == 0) System.out.println(4+" "+(n-4));
    else System.out.println(9+" " +(n-9));
}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.*;
public class Test {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		if (n % 2 == 0) {
			System.out.println(4 + " " + (n - 4));
		} else {
			System.out.println(9 + " " + (n - 9));
		}
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;

public class code0 {

public static void main(String[] args){
	Scanner scr= new Scanner(System.in);
int c=0,e=0,d=0;
int a=scr.nextInt();
d=a/2;
if(a>=11 && a%2==1){
c=9;
e=a-9;
}
else{
c=a-4;e=4;
}

System.out.print(c+" "+e);
}

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
/*
 * 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.
 */

import java.util.Scanner;

/**
 *
 * @author RezaM
 */
public class A {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        int n = scan.nextInt();

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

    }

}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.*;
	
public class A {
	public static void main(String[] args)
	{
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		s.close();
		
		if (n % 2 == 0)
			System.out.print("4 " + (n-4));
		else 
			System.out.print("9 " + (n-9));
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.*;
import java.util.*;

public class a
{
	public static void main(String[] args)
	{
		
		Scanner sc=new Scanner(System.in);
		
		int N=sc.nextInt();
		
		solve(N);
		
		
	}
	
	static void solve(int a)
	{
		if((a-8)%3==0)
		{
			System.out.println(8+" "+(a-8));
			return ;
		}
		if((a-4)%3==0)
		{
			System.out.println(4+" "+(a-4));
			return ;
		}
		if((a-6)%3==0)
		{
			System.out.println(6+" "+(a-6));
			return ;
		}
	}
		
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class ProblemA {

	public static void main(String [] args) throws NumberFormatException, IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		int num1,num2;
		if(n % 2 == 0){
			num1 = n / 2;
			if(num1 % 2 == 0){
				num2 = num1;
			}
			else{
				num1--;
				num2 = num1 + 2;
			}
		}
		else{
			num1 = 9;
			num2 = n - num1;
		}
		
		System.out.println(num1+" "+num2);
	}
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;

/**
 * Created by misanand on 9/20/14.
 */
public class Recovery {
    public static void main(String [] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        if( N%2 == 0) {
            System.out.println( (4)+" "+(N-4));
        }
        else System.out.println( (9)+" "+(N-9));
        scan .close();
    }
}
// Problem: 472_A. Design Tutorial: Learn from Math
// Time complexity: constant
import java.util.Scanner;


public class main1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		
		int n = sc.nextInt();
		
		int a = n / 2;
		int b = n - a;
		
		if (n % 2 == 0) {
			if (a % 2 == 1) {
				a++;
				b--;
			}
			
			System.out.println(a + " " + b);
		} else {
			if (a % 2 == 1) {
				int x = a;
				a = b;
				b= x;
			}
			
			if (b % 3 == 0) {
				
			} else if (b % 3 == 1) {
				a-=2;
				b+=2;
			} else {
				a+=2;
				b-=2;
			}
			
			System.out.println(a + " " + b);
		}
	}
}