codeparrot/codecomplex huggingface dataset:
// Problem: 122_A. Lucky Division
// Time complexity: constant

import java.util.Scanner;

public class three {
    static boolean check;

    public static void main(String[] args) {
        check = true;
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = n + "";
        recurse(n, s.length(), "4");
        if (!check)
            System.out.println("YES");
        else {
            recurse(n, s.length(), "7");
            if (!check)
                System.out.println("YES");
            else
                System.out.println("NO");
        }
    }

    private static void recurse(int n, int length, String string) {
        int k = Integer.parseInt(string);
        if (n % k == 0) {
            check = false;
        } else if (string.length() <= length && check) {
            recurse(n, length, string + "4");
            recurse(n, length, string + "7");
        }

    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.*;
import java.io.*;

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

	void run() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		pw = new PrintWriter(System.out);

		int n = nextInt();
		pw.println(3 * (n / 2));

		pw.close();
	}

	BufferedReader br;
	StringTokenizer st;
	PrintWriter pw;

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

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

	double nextDouble() throws IOException {
		return Double.parseDouble(next());
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {
	public static void main(String args[]) throws Exception
	{
		BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
		int num=Integer.parseInt(in.readLine());
		System.out.println((num/2)*(3));
	}		

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.PrintWriter;
import java.util.Scanner;



public class Solution {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);
        int n=in.nextInt();
    
        out.print(n/2+n);
       
        out.close();
        in.close();
    }

}
// Problem: 84_A. Toy Army
// Time complexity: constant
public class A {
	public static void main(String[] args) {
		System.out.println(new java.util.Scanner(System.in).nextInt() / 2 * 3);
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
//package Codeforces72;

import java.util.Scanner;

public class A {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();		
		System.out.println((int)(n+n/2));
	}

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.*;
import java.io.*;
public class C72A{
    static BufferedReader br;
    public static void main(String args[])throws Exception{
        br=new BufferedReader(new InputStreamReader(System.in));
        long n=toLong();
        long res=n+n/2;
        System.out.println(res);


    }


    /****************************************************************/
    public static int[] toIntArray()throws Exception{
       String str[]=br.readLine().split(" ");
       int k[]=new int[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Integer.parseInt(str[i]);
       }
       return k;
    }
    public static int toInt()throws Exception{
       return Integer.parseInt(br.readLine());
    }
    public static long[] toLongArray()throws Exception{
       String str[]=br.readLine().split(" ");
       long k[]=new long[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Long.parseLong(str[i]);
       }
       return k;
    }
    public static long toLong()throws Exception{
       return Long.parseLong(br.readLine());
    }
    public static double[] toDoubleArray()throws Exception{
       String str[]=br.readLine().split(" ");
       double k[]=new double[str.length];
       for(int i=0;i<str.length;i++){
            k[i]=Double.parseDouble(str[i]);
       }
       return k;
    }
    public static double toDouble()throws Exception{
       return Double.parseDouble(br.readLine());
    }
    public static String toStr()throws Exception{
       return br.readLine();
    }
    public static String[] toStrArray()throws Exception{
       String str[]=br.readLine().split(" ");
       return str;
    }
    /****************************************************************/

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.BigInteger;

public class Main implements Runnable {
  private final String problemname = "";
  private final String FILE_IN  = problemname + ".in";
  private final String FILE_OUT = problemname + ".out";

  public void run() {
//    in = new BufferedReader(new FileReader(FILE_IN));
//    out = new PrintWriter(FILE_OUT);
    in = new BufferedReader(new InputStreamReader(System.in));
    out = new PrintWriter(System.out);
    _st = new StringTokenizer("");

    // TODO: type your code here
    int n = nextInt();

    int best = n + n / 2;
    /*
    for (int i = 0; i <= n; i++) {
      for (int j = 0; j <= n - i; j++) {
        best = Math.max(best, i + j + Math.min(n - i, n - j));
      }
    }*/

    out.println(best);

    try {
      in.close();
      out.close();
    }
    catch (Exception e) {
      System.err.println("Epic fail");
    }
  }

  BufferedReader in;
  PrintWriter out;
  StringTokenizer _st;

  public static void main(String[] args) {
    new Thread(new Main()).start();
  }

  private void seek() {
    while (!_st.hasMoreTokens()) {
      String s;
      try {
        s = in.readLine();
        _st = new StringTokenizer(s);
      } catch (Exception e) {
        return;
      }
    }
  }

  private String next() {
    seek();
    return _st.nextToken();
  }

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

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

  private double nextDouble() {
    return Double.parseDouble(next());
  }

  private BigInteger nextBigInteger() {
    return new BigInteger(next());
  }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;
import java.text.*;


public class Main
{



    public static void main(String[] args)
 {

Scanner sc = new Scanner(System.in);
int T =sc.nextInt();

int t =T/2;
System.out.println(t*3);


}

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

public class ToyArmy {
    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        System.out.println(n + n / 2);
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
 
public class Main {
 
	private BufferedReader input;
	private PrintWriter output;
	private StringTokenizer stoken;
 
	String fin = "input";
	String fout = "output";
 
 
	private void solve() {

		long a = nextInt();
		
		long res = (a / 2) * 3;

		output.print(res);
		
	}
 
 
 
	Main() throws IOException {
		//input = new BufferedReader(new FileReader(fin + ".txt"));
		//output = new PrintWriter(new FileWriter(fout + ".txt"));
		input = new BufferedReader(new InputStreamReader(System.in));
		output = new PrintWriter(System.out);
 
 
		solve();
 
		input.close();
		output.flush();
		output.close();
	}
 
 
	int nextInt() {
		return Integer.parseInt(nextToken());
	}
 
	long nextLong() {
		return Long.parseLong(nextToken());
	}
 
	double nextFloat() {
		return Float.parseFloat(nextToken());
	}
 
	double nextDouble() {
		return Double.parseDouble(nextToken());
	}
 
	String nextToken() {
		while ((stoken == null) || (!stoken.hasMoreTokens())) {
			try {
				String line = input.readLine();
				stoken = new StringTokenizer(line);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return stoken.nextToken();
	}
 
 
 
	public static void main(String[] args) throws IOException {
		new Main();
	}
 
}


class Tarif {
	public int abPlata;
	public int tMin;
	public int price;
	public long res;
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class A {
	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
		String s=r.readLine();
		
		int n=Integer.parseInt(s);
		System.out.println(n*3/2);
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.*;

public class A72 {
	public static void main (String[] args){
		Scanner in = new Scanner(System.in);
		
		int n = in.nextInt();
		System.out.println(n * 3 / 2);
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

public class ToyArmy {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long n = sc.nextLong();
		System.out.println(n / 2 + n);
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.*;
import java.io.*;

public class A
{
    public static void main(String[] args)
    {
        Kattio io = new Kattio(System.in);

        int n = io.getInt();
        int ans = 0;
        int V = n;
        int A = n;

        A -= n/2;
        ans += n/2;

        V -= A;
        ans += A;

        A -= n/2;
        ans += n/2;

        io.println(ans);
        io.flush();
    }
}


class Kattio extends PrintWriter {
    public Kattio(InputStream i) {
	super(new BufferedOutputStream(System.out));
	r = new BufferedReader(new InputStreamReader(i));
    }
    public Kattio(InputStream i, OutputStream o) {
	super(new BufferedOutputStream(o));
	r = new BufferedReader(new InputStreamReader(i));
    }

    public boolean hasMoreTokens() {
	return peekToken() != null;
    }

    public int getInt() {
	return Integer.parseInt(nextToken());
    }

    public double getDouble() { 
	return Double.parseDouble(nextToken());
    }

    public long getLong() {
	return Long.parseLong(nextToken());
    }

    public String getWord() {
	return nextToken();
    }



    private BufferedReader r;
    private String line;
    private StringTokenizer st;
    private String token;

    private String peekToken() {
	if (token == null) 
	    try {
		while (st == null || !st.hasMoreTokens()) {
		    line = r.readLine();
		    if (line == null) return null;
		    st = new StringTokenizer(line);
		}
		token = st.nextToken();
	    } catch (IOException e) { }
	return token;
    }

    private String nextToken() {
	String ans = peekToken();
	token = null;
	return ans;
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

public class A {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int in = sc.nextInt();
		System.out.println(in/2 + in);
		System.exit(0);
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.StringTokenizer;

public class CF {
	public static void main(String[] args) throws IOException {
		Scanner sc=new Scanner(System.in);
		PrintWriter pw = new PrintWriter(System.out);
         int n=sc.nextInt();
         pw.print(n+n/2);
	pw.close();
	sc.close();
}
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;


public class A {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    long n = sc.nextLong();
    System.out.println(3 * (n / 2));
  }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.math.BigInteger;
import java.util.*;

/**
 * Created by IntelliJ IDEA.
 * User: piyushd
 * Date: 4/13/11
 * Time: 8:07 PM
 * To change this template use File | Settings | File Templates.
 */
public class TaskA1 {

    void run(){
        int n = nextInt();

        int ans = 2 * n - (n / 2);
        System.out.println(ans);
    }

    int nextInt(){
        try{
            int c = System.in.read();
            if(c == -1) return c;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return c;
            }
            if(c == '-') return -nextInt();
            int res = 0;
            do{
                res *= 10;
                res += c - '0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    long nextLong(){
        try{
            int c = System.in.read();
            if(c == -1) return -1;
            while(c != '-' && (c < '0' || '9' < c)){
                c = System.in.read();
                if(c == -1) return -1;
            }
            if(c == '-') return -nextLong();
            long res = 0;
            do{
                res *= 10;
                res += c-'0';
                c = System.in.read();
            }while('0' <= c && c <= '9');
            return res;
        }catch(Exception e){
            return -1;
        }
    }

    double nextDouble(){
        return Double.parseDouble(next());
    }

    String next(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(Character.isWhitespace(c))
                c = System.in.read();
            do{
                res.append((char)c);
            }while(!Character.isWhitespace(c=System.in.read()));
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

    String nextLine(){
        try{
            StringBuilder res = new StringBuilder("");
            int c = System.in.read();
            while(c == '\r' || c == '\n')
                c = System.in.read();
            do{
                res.append((char)c);
                c = System.in.read();
            }while(c != '\r' && c != '\n');
            return res.toString();
        }catch(Exception e){
            return null;
        }
    }

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



}
// Problem: 84_A. Toy Army
// Time complexity: constant

import java.io.PrintStream;
import java.util.Scanner;

public class Cfbra {
    public static void main(String[] args) {
       Scanner in = new Scanner(System.in);
       PrintStream out = System.out;
       out.println(in.nextInt() / 2 * 3);
    }

}
// Problem: 84_A. Toy Army
// 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();
		System.out.println(3 * n / 2);
	}

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Govnokod {

	public static void main(String args[]) {
		try {
			InputStreamReader isr = new InputStreamReader(System.in);
			BufferedReader br = new BufferedReader(isr);

			while (true) {
				String str = br.readLine();
				int i = Integer.parseInt(str);

				System.out.println(i*2-i/2);

				return;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.*;

public class N72A
{
    StreamTokenizer in;
    PrintWriter out;

    int nextInt() throws IOException
    {
        in.nextToken();
        return (int) in.nval;
    }

    double nextDouble() throws IOException
    {
        in.nextToken();
        return in.nval;
    }

    public void init() throws Exception
    {
        boolean oj = System.getProperty("ONLINE_JUDGE") != null;
        Reader reader = oj ? new InputStreamReader(System.in) : new FileReader(new File("input.txt"));
        Writer writer = oj ? new OutputStreamWriter(System.out) : new FileWriter(new File("output.txt"));
        in = new StreamTokenizer(reader);
        out = new PrintWriter(writer);
    }

    public void solve() throws Exception
    {
        int n = nextInt();
        out.print(2*n - (n/2));
    }

    public void print() throws Exception
    {
        out.flush();
    }

    public void run() throws Exception
    {
        init();
        solve();
        print();
    }

    public static void main(String[] args) throws Exception
    {
        new N72A().run();
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

public class MainA {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n  = sc.nextInt();
        
        int count = 0;
        
        count = n/2;
        
        count = count + (n - n/2);
        
        n = n - n/2;
            
        count = count + n;  

        
        System.out.println(count);
        
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

public class Task1 {

    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        System.out.println(n*3/2);
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class TemplateBuf implements Runnable{
    
    private void solve() throws Exception {
        long n = nextUnsignedLong();
        
        out.println(n+n/2);
    }

    /////////////////////////////////////////////////
    
    BufferedReader in;
    PrintWriter out;
    
    @Override
    public void run() {
        try{
            in = new BufferedReader(new InputStreamReader(System.in), INPUT_BUF_SIZE);
            out = new PrintWriter(new OutputStreamWriter(System.out));
            solve();
            out.flush();
        }catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
    
    final int INPUT_BUF_SIZE = 1024 * 8;
    final int BUF_SIZE = INPUT_BUF_SIZE;
    char[] buf = new char[BUF_SIZE];
    int ch=-1;
    int charRead=-1;
    int charPos=-1;
    
    public char nextChar() throws IOException{
        if (charPos<0 || charPos>=charRead){
            charRead = in.read(buf);
            charPos=0;
        }
        return buf[charPos++];
    }
    
    public long nextUnsignedLong() throws IOException{      
        while ((ch=nextChar())<'0' || ch>'9');
        long num = ch-'0';
        while ((ch=nextChar())>='0' && ch<='9'){
            num*=10;
            num+=ch-'0';
        }
        return num;
    }
    
    public int nextUnsignedInt() throws IOException{
        return (int)nextUnsignedLong();
    }
    
    public double nextDouble() throws IOException{
        while (((ch=nextChar())<'0' || ch>'9') && ch!='.' && ch!='-');
        char[] tmp = new char[255];
        int itmp = 0;
        tmp[itmp++]=(char)ch;
        while (((ch=nextChar())>='0' && ch<='9') || ch=='.' || ch=='-'){
            tmp[itmp++]=(char)ch;
        }
        return Double.parseDouble(new String(tmp,0,itmp));
    }
    
    public static void main(String[] args) {
        new TemplateBuf().run();
    }
    
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.util.Scanner;

/**
 * Created by IntelliJ IDEA.
 * User: Administrator
 * Date: 13.05.11
 * Time: 23:21
 * To change this template use File | Settings | File Templates.
 */
public class ToyArmies {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextLong();
        System.out.print(String.format("%d",(long)(n*1.5)));
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant
import java.io.*;
import java.util.*;
import java.math.*;

public class A {
    private void solve() throws IOException {
        int n = nextInt();
        int r = n;
        n *= 2;
        n -= (0.5*r);
        System.out.println(n);
    }

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

    BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter writer;

    public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            writer = new PrintWriter(System.out);
            solve();
            reader.close();
            writer.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int[] readIntArray(int size) throws IOException {
        int[] res = new int[size];
        for (int i = 0; i < size; i++) {
            res[i] = nextInt();
        }
        return res;
    }

    long[] readLongArray(int size) throws IOException {
        long[] res = new long[size];
        for (int i = 0; i < size; i++) {
            res[i] = nextLong();
        }
        return res;
    }

    double[] readDoubleArray(int size) throws IOException {
        double[] res = new double[size];
        for (int i = 0; i < size; i++) {
            res[i] = nextDouble();
        }
        return res;
    }

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

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

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

    BigInteger nextBigInteger() throws IOException {
        return new BigInteger(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }
}
// Problem: 84_A. Toy Army
// Time complexity: constant


import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class A {
	
	private void processInput() throws IOException {
		Scanner in = new Scanner(System.in);
		
		int n = in.nextInt();
		long res = go(n);

		System.out.printf(Locale.ENGLISH, "%d\n", res);			

	

		
		in.close();
	}

	private long go(long n) {
		
		long res = 3*n / 2;
		

		return res;
	}
	
	public static void main(String[] args) throws Exception {
		A a = new A();
		a.processInput();
	}
}
// Problem: 84_A. Toy Army
// Time complexity: constant

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

public class BetaRound72_Div2_A implements Runnable {

	final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok = new StringTokenizer("");

	void init() throws IOException {
		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
	}

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

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

	@Override
	public void run() {
		try {
			long t1 = System.currentTimeMillis();
			init();
			Locale.setDefault(Locale.US);
			solve();
			out.close();
			long t2 = System.currentTimeMillis();
			System.err.println("Time = " + (t2 - t1));
		} catch (Exception e) {
			e.printStackTrace(System.err);
			System.exit(-1);
		}
	}

	public static void main(String[] args) {
		new Thread(new BetaRound72_Div2_A()).start();
	}
	
	void solve() throws IOException {
		int n = readInt();
		int ans = n * 3 / 2;
		out.print(ans);
	}
	
}