codeparrot/codecomplex huggingface dataset:
// Problem: 1209_A. Paint the Numbers
// Time complexity: quadratic
import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }
  
    void solve() throws IOException {
        int n=ni();
        int[]A=new int[n];
        for (int x=0;x<n;x++) A[x]=ni();
        Arrays.sort(A);
        ArrayList<Integer>B=new ArrayList();
        B.add(A[0]);
        int ans=1;
        
        Outer:
        for (int x=1;x<n;x++) {
            for (int y=0;y<B.size();y++) {
                if (A[x]%B.get(y)==0) continue Outer;
            }
            ans++;
            B.add(A[x]);
        }
        System.out.println(ans);   
        
    }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}
// Problem: 1209_A. Paint the Numbers
// Time complexity: quadratic
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
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;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = in.nextInt();
            }
            Arrays.sort(a);
            boolean[] dead = new boolean[n];
            int ans = 0;
            for (int i = 0; i < n; i++) {
                if (dead[i]) {
                    continue;
                }
                ++ans;
                for (int j = i; j < n; j++) {
                    if (a[j] % a[i] == 0) {
                        dead[j] = true;
                    }
                }
            }
            out.println(ans);
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

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

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

    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.*;
import java.util.*;

public class Lcm
{
public static void main(String args[])throws Exception
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(System.out);
long n=Long.parseLong(br.readLine());
if(n<=2)
pw.println(n);
else
{

 if(n%6==0)
{
 pw.println(((n-1)*(n-2)*(n-3)));
}
 else if(n%2==0)
{
  pw.println((n*(n-1)*(n-3)));
}
else
{
  pw.println((n*(n-1)*(n-2)));
}
}
pw.flush();
}
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;

public class Task235A {

	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 n = sc.nextInt();

			if (n < 3) {
				pw.println(n);
			} else {
				if (n % 2 != 0) {
					pw.println(n * (n - 1) * (n - 2));
				} else {
					if (n % 3 != 0) {
						pw.println(n * (n - 1) * (n - 3));
					} else {
						long cand1 = n * (n - 1) * (n - 2) / 2;
						long cand2 = (n - 1) * (n - 2) * (n - 3);
						pw.println(Math.max(cand1, cand2));
					}
				}
			}

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

}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;

public class Main
{
    public static long gcd(long a, long b)
    {
        return b==0? a:gcd(b, a%b);
    }
    public static long lcm(long a, long b, long c)
    {
        long d=a/gcd(a, b)*b;
        return c/gcd(c, d)*d;
    }
    public static long max(long a, long b)
    {
        return a>b? a:b;
    }
    public static void main(String[] args)
    {
        InputReader in = new InputReader();
        PrintWriter out = new PrintWriter(System.out);
        long n=in.nextLong();
        if(n<=2)
            out.println(n);
        else
            out.println(max(lcm(n, n-1, n-2), max(lcm(n, n-1, n-3), lcm(n-1, n-2, n-3))));
        out.close();
    }
}

class InputReader
{
    BufferedReader buf;
    StringTokenizer tok;
    InputReader()
    {
        buf = new BufferedReader(new InputStreamReader(System.in));
    }
    boolean hasNext()
    {
        while(tok == null || !tok.hasMoreElements()) 
        {
            try
            {
                tok = new StringTokenizer(buf.readLine());
            } 
            catch(Exception e) 
            {
                return false;
            }
        }
        return true;
    }
    String next()
    {
        if(hasNext()) 
            return tok.nextToken();
        return null;
    }
    int nextInt()
    {
        return Integer.parseInt(next());
    }
    long nextLong()
    {
        return Long.parseLong(next());
    }
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
    BigInteger nextBigInteger()
    {
        return new BigInteger(next());
    }
    BigDecimal nextBigDecimal()
    {
        return new BigDecimal(next());
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.*;

/*Author LAVLESH*/
public class solution
{  
	static long gcd(long a,long b){
		if(b==0) return a;
		else 
			return gcd(b,a%b);
		
	}
	public static void main(String[]args){
		Scanner in=new Scanner(System.in);
		long n=in.nextLong();
		long m1=0,m2=0;
		if(n<3)m1=n;
		else {
			if((n&1)==1){
				long lcm=n*(n-1)/gcd(n,n-1);
				m1=lcm*(n-2)/gcd(lcm,n-2);
			}
			else{
				long lcm=(n-1)*(n-2)/gcd(n-1,n-2);
				m1=lcm*(n-3)/gcd(lcm,n-3);
				
				 lcm=n*(n-1)/gcd(n,n-1);
				m2=lcm*(n-3)/gcd(lcm,n-3);
				m1 = Math.max(m1,m2);
			}
		}
		System.out.println(m1);
		
}}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;


public class Main {

    public static long GCF(long a, long b) {
        if(b == 0) return a;
        else return GCF(b, a%b);
    }
    
    public static long LCM(long a, long b){
        return a*b / GCF(a, b);
    }
    
    
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        if(n < 3) System.out.println(n);
        else{
            long t1 = LCM(n, n-1);
            long t2 = LCM(n-2, n-3);
        
            long l1 = LCM(t1, n-2);
            long l2 = LCM(t1, n-3);
            long l3 = LCM(n, t2);
            long l4 = LCM(n-1, t2);
        
        System.out.println(Math.max(l1, Math.max(l2, Math.max(l3, l4))));

        }
        
    }

}
// Problem: 235_A. LCM Challenge
// 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.
 */

//package NumberTheory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 *
 * @author Sourav Kumar Paul
 */
public class A235 {
    public static void main(String[] args) throws IOException{
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        long n = Long.parseLong(reader.readLine());
        //int gcd = gcd(924,923);
        //System.out.println(gcd);
       // System.out.println(gcd(923,461));
        if(n<=2)
            System.out.println(n);
        else if(n==3)
            System.out.println("6");
        
        else if(n % 2== 0)
       {
           if(n % 3 == 0)
           {
               System.out.println((n-3)*(n-1)*(n-2));
           }
           else
               
           System.out.println(n * (n-1) * (n-3) );
       }
        else
            System.out.println(n*(n-1)*(n-2));
    }
     private static int gcd(int i, int j) {
        int a = Math.min(i,j);
        int b = Math.max(i,j);
       while(a != 0)
       {
           int temp = b % a;
           b = a;
           a = temp;
       }
       return b;
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.math.BigInteger;
import java.util.Scanner;

public class A235 {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        long n = scan.nextInt();
        BigInteger res = null;
        if (n >= 3) {
            if (n % 2 != 0) {
                res = BigInteger.valueOf(n * (n - 1) * (n - 2));
            } else if (n % 3 == 0) {
                res = BigInteger.valueOf((n - 1) * (n - 2) * (n - 3));
            } else {
                res = BigInteger.valueOf(n * (n - 1) * (n - 3));
            }
        } else {
            res = BigInteger.valueOf(n);
        }
        System.out.println(res);
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;

public class LCM {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        long n = scan.nextLong();

        if (n <= 2)
            System.out.println(n);
        else if (n % 2 == 1)
            System.out.println(n * (n - 1) * (n - 2));
        else if (n % 3 == 0)
            System.out.println((n - 1) * (n - 2) * (n - 3));
        else
            System.out.println(n * (n - 1) * (n - 3));
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;

public class A235 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        long n = sc.nextInt();
        if (n == 1) {
            System.out.println(1);
            return;
        } else if (n == 2) {
            System.out.println(2);
            return;
        } else if (n == 3) {
            System.out.println(6);
            return;
        }

        if (n % 2 == 0) {
            if(n % 3 == 0) 
                System.out.println((n - 1) * (n - 2) * (n - 3));
            else
                System.out.println((n - 1) * n * (n - 3));
        } else {
            System.out.println(n * (n - 1) * (n - 2));
        }
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.*;
public class Main
{
    public static void main(String[]args)
    {
        Scanner input=new Scanner (System.in);
        while(input.hasNext())
        {
            long n=input.nextLong();
            if(n==1||n==2)
                System.out.println(n);
            else if(n%2==1)
                System.out.println(n*(n-1)*(n-2));
            else
                if(n%3!=0)
                    System.out.println(Math.max(n*(n-1)*(n-3),n*(n-1)*(n-2)/2));
                else
                    System.out.println(Math.max(  Math.max(n*(n-1)*(n-3)/3,n*(n-1)*(n-2)/2) , Math.max((n-2)*(n-1)*(n-3),n*(n-2)*(n-3)/6) ));
        }
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        long num=in.nextLong();
        long lcm=1;
        if(num==2){
            System.out.println(2);
            System.exit(0);
        }//End if
        else if(num%2==0&&num%3!=0)
            lcm=(num)*(num-1)*(num-3);
        else if(num%2==0&&num%3==0)
            lcm=(num-1)*(num-2)*(num-3);
        else if(num%2!=0&&num>2)
            lcm=num*(num-1)*(num-2);
        System.out.println(lcm);
    }//End main()
}//End class
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;


public class Main{
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        long num = input.nextLong();
        if(num==0){
            System.out.println(num);
        }else if(num==1||num==2){
            System.out.println(num);}
        else if(num%2==0&&num>2&&num%3!=0){
            System.out.println(num*(num-1)*(num-3));
        }
        else if(num%2==0&&num%3==0){
            System.out.println((num-1)*(num-2)*(num-3));
        }
        else{
        System.out.println(num*(num-1)*(num-2));}
    }
   
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * Created by jizhe on 2016/1/29.
 */
public class LCMChallenge {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));

        long N = in.nextLong();
        if( N == 1 || N == 2 )
        {
            System.out.printf("%d\n", N);
            return;
        }

        if( (N&1) == 1 )
        {
            long lcm = N*(N-1)*(N-2);
            System.out.printf("%d\n", lcm);
        }
        else
        {
            if( N == 4 )
            {
                System.out.printf("12\n");
            }
            else
            {
                long lcm;
                if( N%3 == 0 )
                {
                    lcm = (N-1)*(N-2)*(N-3);
                }
                else
                {
                    lcm = N*(N-1)*(N-3);
                }

                System.out.printf("%d\n", lcm);
            }
        }
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.*;
public class maximus {
	static long GCD(long a,long b){
	if(b==0)return a;
	return GCD(b,a%b);	
	}
public static void main(String [] args){
  Scanner in=new Scanner(System.in);
  long n=in.nextInt();
  if(n<=2){
  System.out.print(n);
  return;	
  }
  if(n%2==1){
  System.out.print((n*(n-1)*(n-2)));
  return;
  }
  if(n%2==0 && n<=6){
  System.out.print(n*(n-1)*(n-2)/2);
  return;	
  }
  long temp=(n*(n-1)*(n-3))/GCD(n,n-3);
  System.out.print(Math.max((n-1)*(n-2)*(n-3),temp));
  }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.*;
import java.util.*;

public class Main {
    Scanner cin = new Scanner(new BufferedInputStream(System.in));
    long n;
    long maxlcm;
    
    void run(){
    	n = cin.nextInt();
    	if(n == 1 || n ==2)
    		maxlcm = n;
    	else if(n >= 3){
            	if(n % 2 != 0){
    	           	maxlcm = n * (n-1) * (n - 2);
    	        }
            	else if(n%3 != 0)
            		maxlcm = n * (n - 1) * (n - 3);
            	else maxlcm = (n - 1) * (n - 2) * (n - 3);
    	}  
    	System.out.println(maxlcm);
    }

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

	}
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;
public class LCM {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long n=sc.nextLong();
		if(n < 3) {
			System.out.println(n);
		}
		else if(n % 2 != 0) {
			System.out.println(n * (n-1) * (n-2));
		}
		else if(n % 3 == 0) {
			System.out.println((n-1) * (n-2) * (n-3));
		}
		else {
			System.out.println(n * (n-1) * (n-3));
		}
	}
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;


public class Main {

    public static void main(String[] args) {
Scanner input = new Scanner(System.in);
long x = input.nextLong();

if(x==1||x==2){System.out.println(x);
    
}
else if(x%2==0&&x>2&&x%3!=0){
    System.out.println((x)*(x-1)*(x-3));
    
}else if(x%2==0&&x%3==0){
    System.out.println((x-1)*(x-2)*(x-3));
}

else {System.out.println(x*(x-1)*(x-2));}
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.io.*;
import java.util.*;

public class LCMChallenge {
    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        long n = Long.parseLong(f.readLine());
        if (n == 1 || n == 2)
            System.out.println(n);
        else if (n % 2 == 1)
            System.out.println(n*(n-1)*(n-2));
        else
        {
            long prod = n*(n-1);
            long x = n-2;
            while (x > 0 && gcd(n,x) > 1 || gcd(n-1,x) > 1)
                x--;
            prod *= x;
            if ((n-1)*(n-2)*(n-3) > prod)
                prod = (n-1)*(n-2)*(n-3);
            System.out.println(prod);
        }
    }
    
    public static long gcd(long a, long b)
    {
        if (b == 0)
            return a;
        return gcd(b, a%b);
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;
public class test5{
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
            long x=in.nextLong();
            if(x>=3){
                if(x%2!=0)
                    System.out.println(x*(x-1)*(x-2));
                else if(x%3==0)
                    System.out.println((x-3)*(x-1)*(x-2));
                else 
                    System.out.println(x*(x-1)*(x-3));
            }
            else System.out.println(x);
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.*;
import java.lang.*;
import java.io.*;

public class LCM {
	public static long gcd(long a,long b) {
		while(true) {
	    	a=a%b;
		  	if (a==0) return b;
		    b=b%a;
		    if (b==0) return a;
		}
    }
	public static void main (String[] args) throws java.lang.Exception {
		Scanner in=new Scanner(System.in);
		long n=in.nextInt();
		if (n>2) {
			if (gcd(n,n-2)>1) {
				if (gcd(n,n-3)>1) {
					System.out.println((n-1)*(n-2)*(n-3));
				}
				else System.out.println(n*(n-1)*(n-3));
			}
			else System.out.println(n*(n-1)*(n-2));
		}
		else System.out.println(n);
	}
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant

import java.io.*;
import java.util.*;
import java.math.*;
import static java.lang.Math.*;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;
import static java.lang.String.*;

public class Main {

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

        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
                                            //(new FileReader("input.in"));
        StringBuilder out = new StringBuilder();
        StringTokenizer tk;
        //PrintWriter pw = new PrintWriter("output.out", "UTF-8");
  
        long n = parseLong(in.readLine());
        
        if(n <= 2) System.out.println(n);
        else if(n%2 == 1)System.out.println(n*(n-1)*(n-2));
        else {
            long ans = (n-1)*(n-2)*(n-3);
            
            if(gcd(n*(n-1),n-3)==1) ans = max(ans, n*(n-1)*(n-3));
            
            System.out.println(ans);
        }
    }
    
    static long gcd(long a,long b) {
        return b==0 ? a : gcd(b, a%b);
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.*;
import java.io.*;
import java.math.*;

public class Main {
    public static Scanner scan = new Scanner(System.in);
    public static boolean bg = true;

    public static void main(String[] args) throws Exception {
        long n1 = Integer.parseInt(scan.next());
        if (n1==1){
            System.out.println(1);
            System.exit(0);
        }
        if (n1==2){
            System.out.println(2);
            System.exit(0);
        }
        if (n1==3){
            System.out.println(6);
            System.exit(0);
        }
        if (n1%2==0){
            if (n1%3==0){
                n1-=1;
                n1 = n1*(n1-1)*(n1-2);
                System.out.println(n1);
            }
            else {
                n1 = n1*(n1-1)*(n1-3);
                System.out.println(n1);
            }
        }
        else {
            n1 = n1*(n1-1)*(n1-2);
            System.out.println(n1);
        }
    }
}
// Problem: 235_A. LCM Challenge
// Time complexity: constant
import java.util.Scanner;

public class Prob235A {
	public static void main(String[] Args) {
		Scanner scan = new Scanner(System.in);
		int x = scan.nextInt();
		if (x < 3) {
			if (x == 1)
				System.out.println(1);
			else
				System.out.println(2);
		} else {
			long answer = x;
			if (x % 2 == 1) {
				answer *= x - 1;
				answer *= x - 2;
			} else if (x % 3 != 0) {
				answer *= x - 1;
				answer *= x - 3;
			} else {
				answer = x - 1;
				answer *= x - 2;
				answer *= x - 3;
			}
			System.out.println(answer);
		}
	}
}