You are given a rectangular board of M × N squares. Also you are given an unlimited number of standard domino pieces of 2 × 1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:1. Each domino completely covers two squares.2. No two dominoes overlap.3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board.Find the maximum number of dominoes, which can be placed under these restrictions.

In a single line you are given two integers M and N — board sizes in squares (1 ≤ M ≤ N ≤ 16).

Output one number — the maximal number of dominoes, which can be placed.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class DominoPiling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// Problem https://codeforces.com/problemset/problem/50/A
		// For more solutions check https://github.com/jontiboss
		Reader reader = new Reader();
		int area = reader.nextInt()*reader.nextInt();
		System.out.println(area>>1);
	}
	static class Reader
	{
		BufferedReader br;
		StringTokenizer st;

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

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

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

	}
}

import java.util.*;
public class CF50A7 {
  public static void main(  String args[]){
    long m, n;
    Scanner sc=new Scanner(System.in);
    m=sc.nextInt();
    n=sc.nextInt();
    long total=(m * n) / 2;
    if (false) {
      System.out.println(total - 1);
    }
 else {
      System.out.println(total);
    }
    sc.close();
  }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;

public class DominoP{
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);

		SolveDominoP solver = new SolveDominoP();
		int testCount = 1;
		for (int i = 1; i <= testCount; i++)
		solver.solve(i, in, out);
		out.close();
	}
}
/*class Pair implements Comparable<Pair>{
private  int L=0;
private  int R=0;
public Pair(int l,int r){
	this.L=l;
	this.R=r;
}
public Pair(){}
public void setL(int l){
	this.L=l;
}
public void setR(int r){
	this.R=r;
}
public int getL(){
	return L;
}
public int getR(){
	return R;
}
public int compareTo(Pair o) {
		return R < o.R ? -1 : R > o.R ? 1 : 0;
	}
}*/

class SolveDominoP {

	public void solve(int testNumber, InputReader in, PrintWriter out) {
		int m=in.readInt();
		int n=in.readInt();
		int arr[][]=new int[m+2][n+2];
		arr[1][1]=0;
		for(int i=1;i<=n;i++)
		{
			if(i%2==0)
			arr[1][i]=arr[1][i-1]+1;
			else
			arr[1][i]=arr[1][i-1];

		}
		for(int i=1;i<=m;i++)
		{
			if(i%2==0)
			arr[i][1]=arr[i-1][1]+1;
			else
			arr[i][1]=arr[i-1][1];

		}

		for(int i=2;i<=m;i++)
		{
			for(int j=2;j<=n;j++)
			{
				arr[i][j]=Math.max(arr[i][j-1],arr[i-1][j])+1;

			}

		}

		out.println(m*n/2);
	}
	public static long gcd(long a,long b){
		if(b==0)
		return a;
		else
		return gcd(b,a%b);

	}
	public static int fastpower(int a,int b){
		long res=1;
		long x=(long)a;
		while(b>0){
			if(b%2!=0){
				res=res*a;

			}
			a=a*a;
			b=b/2;

		}
		return (int)(res%4);

	}

}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	private int read() {
		if (numChars == -1)
		throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
			return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
		c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
			throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c))
		c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
		return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public String next() {
		return readString();
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

import java.io.*;
import java.util.StringTokenizer;

public class A50 {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int ans = (n*m)/2;
        System.out.println(ans);
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

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

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

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

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

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

        public boolean ready() throws IOException {
            return br.ready();
        }
    }
}

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 *
 * @author sukhdeep
 */
public class Hel {

     static class IntStreamReader
    {

        private BufferedInputStream inp = null;
        private int offset = 0;
        private int size = 25600;
        private byte[] buff = new byte[size];

        public IntStreamReader(InputStream in) throws IOException
        {
            inp = new BufferedInputStream(in);
            inp.read(buff, 0, size);
        }

        public int getNextInt() throws IOException
        {
            int parsedInt = 0;
            int i = offset;

            while (i < buff.length && (buff[i] < '0' || buff[i] > '9'))
            {
                i++;
            }

            while (i < buff.length && buff[i] >= '0' && buff[i] <= '9')
            {
                parsedInt *= 10;
                parsedInt += buff[i] - '0';
                i++;
            }

            if (i == buff.length)
            {

                int j = 0;
                for (; offset < buff.length; j++, offset++)
                {
                    buff[j] = buff[offset];
                }

                inp.read(buff, j, size - j);

                offset = 0;
                parsedInt = getNextInt();
            }
            else
            {
                offset = i;
            }
            return parsedInt;
        }
    }

    public static void main(String[] args) throws IOException {
       IntStreamReader r=new IntStreamReader(System.in);
       int n=r.getNextInt();
int m=r.getNextInt();

if(n>1)
{
    if(n%2==0)
    System.out.println(m*(n/2));
    else
        System.out.println((m*(n/2))+m/2);
}
else
    System.out.println(m/2);

}
}

import java.util.Scanner;

public class Main{
	public static void main(String args[]){
		Scanner in = new Scanner(System.in);

		int n = in.nextInt();
		int m = in.nextInt();

		System.out.println((int)Math.floor(n * m / 2));
	}
}

import java.util.Scanner;

public class a50 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num1 = in.nextInt();
        int num2 = in.nextInt();
        int x = (num1 * num2) / 2;
        System.out.println(x);

    }
}

import java.util.*;

 public class Solve50{
 	public static void main(String[] args) {

 	Scanner sc=new Scanner(System.in);
 	int m=sc.nextInt();
 	int n=sc.nextInt();
 	int max=0;
 	if (m>=1&&n>=1) {

 	 max=(m*n)/2;
 }
 System.out.println(max);
 }

 }

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

public class diminopiling {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String []s=br.readLine().trim().split("\\s+");
        int d=Integer.parseInt(s[0])* Integer.parseInt(s[1]);
        d=d/2;
        System.out.println(d);

    }

}

import java.util.*;
public class dominoes
{
	public static void main(String[] args)
	{
		Scanner scanner = new Scanner(System.in);
		int rows = scanner.nextInt();
		int cols = scanner.nextInt();
		int total = 0;
		if(cols % 2 == 0)
		{
			total += (rows * (cols / 2));
			System.out.println(total);
		}

		else
		{
			total += (rows * (cols / 2)); //cols = 1;
			total += (rows / 2);
			System.out.println(total);
		}
	}
}

import java.util.Scanner;

public class FiftyAMain {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scanner = new Scanner(System.in);
        int M;
        int N;
        M = scanner.nextInt();
        N = scanner.nextInt();

        System.out.print((M * N) / 2);
    }

}

import java.util.Scanner;

public class DominoPiling {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int count = 0;
        if (m < 2 && n < 2)
            System.out.println(count);
        else {
            if (m >= 2 && n >= 1) {
                count += (n * (m / 2));
                m %= 2;
            }
            if (n >= 2 && m == 1) {
                count += (n / 2);
            }

            System.out.println(count);
        }
    }

}

import java.util.Scanner;
public class Domino {

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

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		try (Scanner reader = new Scanner(System.in)) {

			int width = reader.nextInt();
			int length = reader.nextInt();
			int count = 0;
			if(width == 1 || length == 1  )
			{
				count = width * length / 2;
			}
			else if(width % 2 == 0)
			{
				count = width / 2 * length;
			}
			else if (length % 2 == 0)
			{
				count = length / 2 * width;
			}
			else
			{
				count = (width / 2 * (length)) + (length / 2) ;
			}

			System.out.println(count);

		}

	}

}

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

public class DominoPiling {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String[] dimension = reader.readLine().split("\\s+");
        int M = Integer.parseInt(dimension[0]);
        int N = Integer.parseInt(dimension[1]);
        System.out.println(numDominoPilings(M, N));
    }

    private static int numDominoPilings(int m, int n) {
        return (n * (int)(m/2)) + (m%2 * n/2);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;

public class DominoP{
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);

		SolveDominoP solver = new SolveDominoP();
		int testCount = 1;
		for (int i = 1; i <= testCount; i++)
		solver.solve(i, in, out);
		out.close();
	}
}
/*class Pair implements Comparable<Pair>{
private  int L=0;
private  int R=0;
public Pair(int l,int r){
	this.L=l;
	this.R=r;
}
public Pair(){}
public void setL(int l){
	this.L=l;
}
public void setR(int r){
	this.R=r;
}
public int getL(){
	return L;
}
public int getR(){
	return R;
}
public int compareTo(Pair o) {
		return R < o.R ? -1 : R > o.R ? 1 : 0;
	}
}*/

class SolveDominoP {

	public void solve(int testNumber, InputReader in, PrintWriter out) {
		int m=in.readInt();
		int n=in.readInt();

		out.println(m*n/2);
	}
	public static long gcd(long a,long b){
		if(b==0)
		return a;
		else
		return gcd(b,a%b);

	}
	public static int fastpower(int a,int b){
		long res=1;
		long x=(long)a;
		while(b>0){
			if(b%2!=0){
				res=res*a;

			}
			a=a*a;
			b=b/2;

		}
		return (int)(res%4);

	}

}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	private int read() {
		if (numChars == -1)
		throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (numChars <= 0)
			return -1;
		}
		return buf[curChar++];
	}

	public int readInt() {
		int c = read();
		while (isSpaceChar(c))
		c = read();
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = read();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
			throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = read();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public String readString() {
		int c = read();
		while (isSpaceChar(c))
		c = read();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = read();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
		return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

	public static boolean isWhitespace(int c) {
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	public String next() {
		return readString();
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class DominoPiling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastReader fr = new FastReader();

		int m=fr.nextInt(),n=fr.nextInt();
		System.out.println((int)Math.floor((m*n)*1.0/2*1.0));

	}

	static class FastReader{
		BufferedReader bf;
		StringTokenizer st;

		FastReader(){
			bf=new BufferedReader(new InputStreamReader(System.in));
			//bf=new BufferedReader(new FileReader("pruebas.txt"));
		}

		String next() {
			while(st==null || !st.hasMoreElements()) {
				try {
					st=new StringTokenizer(bf.readLine());
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

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

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

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

		String nextLine() throws IOException {
			return bf.readLine();
		}

		boolean ready() throws IOException {
			return bf.ready() || (st!=null && st.hasMoreElements());
		}
	}

}

import java.util.Scanner;

public class DominoPilling {

    public static void main(String[] args) {
    Scanner sc= new Scanner( System.in);
    int a,b,c;
    a=sc.nextInt();
    b=sc.nextInt();

    if (((a%2)==0) || ((b%2) ==0)) {
        System.out.println(a*b/2);

    }
    else {  System.out.println((a*b-1)/2 );

    }
    }
                                                  }

import java.util.Scanner;

public class test {

	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);
		int M = scan.nextInt();
		int N = scan.nextInt();

		int ans =(M*N)/2;
		System.out.println(ans);

	}

}

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

/**
 *
 * @author Joe
 */
public class Problem50A {

    /**
     * @param args the command line arguments
     */
    static final Scanner scan = new Scanner(System.in);
    static final PrintStream sout = System.out;

    public static void main(String[] args) {
        int m = scan.nextInt();
        int n = scan.nextInt();
        int black = 0;
        int dominoes = 0;
        black = m/2 + m%2;
        if (m%2 == 1) {
            if (n%2 == 0) {
                black = n*black/2 + (n/2)*(black-1);
            } else {
                black = (n/2 + 1)*black + (n/2)*(black-1);
            }
        } else {
            black = n*black;
        }
        int white = m*n - black;
        if (black <= white) {
            dominoes = black;
        } else {
            dominoes = white;
        }
        sout.println(dominoes);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;

/**
 * Created by Bharani on 10/19/14.
 */

public class A50 {
    public static void main(String args[]) throws IOException {
        BufferedReader ip = new BufferedReader(new InputStreamReader(System.in));
        String s = ip.readLine();
        String[] sp = s.split(" ");
        int n = Integer.parseInt(sp[0]);
        int m = Integer.parseInt(sp[1]);
        int r1,r2,q1,q2;
        BigInteger b1,b2;

        q1 = n / 2;
        r1 = n % 2;

        q2 = m / 2;
        r2 = m % 2;

        b1 = BigInteger.valueOf(q1*m+(r1*m)/2);
        b2 = BigInteger.valueOf(q2*n+(r2*n)/2);

        if(b1.compareTo(b2) < 0)
            System.out.print(b1);
        else
            System.out.print(b2);
    }
}

import java.util.Scanner;

public class A50_Domino_Piling {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if(m==1 && n==1) System.out.print("0");
        else if ((m==1&&n==2) || (m==2&&n==1)) System.out.print("1");
        else {
            if ((m * n) % 2 == 0) {
                System.out.print(((m * n) / 2));
            } else System.out.print((((m * n) - 1) / 2));
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class DominoPiling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// Problem https://codeforces.com/problemset/problem/50/A
		// For more solutions check https://github.com/jontiboss
		Reader reader = new Reader();
		// Find the area which is x*y, a domino is always taking up 2 spaces.
		// A even area can always be divided by 2, and odd area will have a square left empty.
		// for bigger squares the one "empty" square thats left will have a smaller impact in the total area.
		// therefore we could just truncate the decimals to an integer, to get the maximum domino its just to divide by 2.

	    //multiply the two inputs to get the area, then bitwise divide by 2 to get the final result.
		int area = reader.nextInt()*reader.nextInt();
		area = area>>1;
		System.out.println(area);
	}
	static class Reader
	{
		BufferedReader br;
		StringTokenizer st;

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

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

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

	}
}

import java.util.Scanner;
public class Domino
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);
		int m = input.nextInt();
		int n = input.nextInt();
		String [] a = new String [m];
		int area =m*n;
		if (area>=1 && area<=256)
		{
			System.out.println(area/2);
		}
		else
		{
			main(a);
		}
	}
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
	    Scanner in = new Scanner(System.in);
	    int m = in.nextInt();
	    int n = in.nextInt();
	    System.out.println((m*n)/2);
	    in.close();
	}
}

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        int M  = scan.nextInt();
        int N  = scan.nextInt();

        System.out.println((M*N)/2);

    }
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
                int ans = (n * m) / 2;
                System.out.println(ans);
                return;
        }
}
//I'm coding on mobile forgive my incompetence 😭

import java.util.Scanner;

public class Main {

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

    }
}

import java.util.Scanner;

public class prob50A {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String inputs[]= sc.nextLine().split(" ");
    int length = Integer.parseInt(inputs[0]);
    int width = Integer.parseInt(inputs[1]);
    int result = 0;
    if (length > 1) {
      result = width;
      int leftLength = length - 2;
      while (leftLength > 0) {
        if(leftLength == 1){
          result = result + (width / 2);
        } else {
          result = result + width;
        }
        leftLength = leftLength - 2;
      }
    } else {
      result = width / 2;
    }
    System.out.println(result);
  }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class p4 {

    public static void main(String[] args) throws Exception {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String f[] = bf.readLine().split(" ");
        System.out.println((((Integer.parseInt(f[0])))*(Integer.parseInt(f[1])))/2);
    }
}

import java.util.Scanner;

public class Domino {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int m,n,a;
        m = sc.nextInt();
        n = sc.nextInt();
        a=(m*n)/2;
        System.out.println(a);
    }
}

import java.util.Scanner;
public class CodeForces {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt(),n = scanner.nextInt();
        if (n % 2 == 0 && m % 2 == 0)
            System.out.println((n / 2) *m );

        else if (m % 2 != 0 && n%2 == 0)
            System.out.println(m * (n / 2));
        else if (m % 2 == 0 && n % 2 != 0)
            System.out.println(n * (m  / 2));
        else if (m == 1)
            System.out.println(n/2);
       else
            System.out.println(n + ((m-2) /2)*n + n / 2);
    }
}

import java.util.*;

public class Solution {
    private static int solve(int m, int n) {
        return m*n/2;
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int M = in.nextInt(), N = in.nextInt();
        System.out.println(solve(M, N));
    }
}

import java.util.Scanner;

public class DominoPilling {

    public static void main(String[] args) {

        Scanner teclado = new Scanner(System.in);
        int m,n,r;

        m=teclado.nextInt();
        n=teclado.nextInt();

        r =m*n/2;

        System.out.println(r);
    }

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);
        int m = input.nextInt();
        int n = input.nextInt();
        int nm = n * m;
        int result = nm / 2;
        System.out.println(result);

    }
}

import java.util.Scanner;
import javax.swing.JOptionPane;

public class DominoPiling {

    public static void main(String[] args) {

      int value = 0;
      Scanner in = new Scanner(System.in);
      int m = in.nextInt();
        int n = in.nextInt();

      for(int i = 0;i<m-(m%2);i=i+2)
      {
        value+=n;
      }
      if((m%2)==1){
      value+=n/2;}
      System.out.println(""+value);

}
}

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class DominoPiling_50A {
		public static void main(String[] args) throws IOException {
			BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
			StringTokenizer st =new StringTokenizer(br.readLine());
			int m= Integer.parseInt(st.nextToken());
			int n= Integer.parseInt(st.nextToken());
//			PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

			System.out.println((m*n)/2);
		}
}

import java.util.*;

public class dominoshki {
	public static void main (String [] args) {
		Scanner in = new Scanner (System.in);

		int side1 = in.nextInt();
		int side2 = in.nextInt();
		int div = 0;

		if (side1 % 2 == 0) {
			div = side1 / 2 * side2;
		}

		else if (side2 % 2 == 0) {
			div = side2 / 2 * side1;
		}

		else {
			div = ((side1 - 1) / 2 * side2) + (side2/2);
		}

		System.out.println (div);
	}
}

import java.util.Scanner;
public class P50A {
    // Domino pilling
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt(), n = sc.nextInt(),x;
        if ( 16 >= n && n>= m && m>= 1 ) {
            int a = n*m;
            x = a%2;
            if ( x == 0 ){
                System.out.println(a/2);}

            else System.out.println(a/2);
        }
        sc.close();
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int boxWidth = sc.nextInt();
        int boxHeight = sc.nextInt();
        int dominoWidth = 2;
        int dominoHeight = 1;
        sc.close();
        int requiredDomino = 0;
        int requiredDominoByWidth = boxWidth / dominoWidth;
        int requiredDominoByHeight = boxHeight / dominoHeight;
        requiredDomino = requiredDominoByHeight*requiredDominoByWidth;
        if(boxWidth > (requiredDominoByWidth*dominoWidth)) {
            int vacancy = boxWidth - (requiredDominoByWidth*dominoWidth);
            requiredDomino += (vacancy * boxHeight) / dominoWidth;
        }
        if(boxWidth == 1) requiredDomino = boxHeight / dominoWidth;
        System.out.println(requiredDomino);
    }
}

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

public class DominoPiling
{
	public static void main(String args[])throws IOException
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String str[] = br.readLine().split(" ");
		int m = Integer.parseInt(str[0]);
		int n = Integer.parseInt(str[1]);

		int area = m*n;

		System.out.println(area/2);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class A50 {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String arr[] = input.readLine().split(" ");
        out.println((Integer.parseInt(arr[0])*(Integer.parseInt(arr[1])))/2 + "");
        input.close();
        out.close();
    }
}

import java.util.Scanner;

public class DominoPiling {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int m = in.nextInt();
		int n = in.nextInt();

		int result = 0;
		if(m > 1 && n >= 1 || n > 1 && m >= 1){
			if(m%2 == 0){
				result = m/2 * n;
			}else{
			    result = m/2 * n + n/2;
			}
		}else{
		result = 0;
		}
		System.out.print(result);
	}
}

import java.util.Scanner;

//50A
public class domino {

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int h=s.nextInt();
		int v=s.nextInt();
		int x;
		int y;
		if(h>v) {
			x=h;
			y=v;
		}
		else {
			y=h;
			x=v;
		}
		int count1=0;
        for(int i=y;i>=0;i=i-2) {
        	count1++;
        }

        count1=count1-1;
        int res=count1*x;
        int count2=0;
        int result=0;
        if((count1*2-y)==0)
        	System.out.println(res);
        else {
        	for(int j=x;j>=0;j=j-2) {
        		count2++;
        	}
        	result=res+count2-1;
            System.out.println(result);
        }

	}

}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int M = sc.nextInt();
        int N = sc.nextInt();
        int x = M*N;
        int j;

        if(x>1) {
            if (x % 2 == 0) {
                j = x / 2;
            }
            else{
                x-=1;
                j=x/2;
            }
            System.out.println(j);
        }
        else
            System.out.println("0");
    }
}

import java.util.*;

public class main
{
 static int M,N;
       static int size;
    public static void main(String[] args)
    {

        Scanner in = new Scanner(System.in) ;
             M=in.nextInt();
             N=in.nextInt();
             size = N*M;
             size=(size/2);
             System.out.println(size);
    }

}

import java.util.Scanner;

public class Dummy {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] input = sc.nextLine().split(" ");
        int m = Integer.parseInt(input[0]);
        int n = Integer.parseInt(input[1]);
        int total = 0;

        if (m % 2 == 1) {
            total += n/2;
            m--;
        }

        if (m != 0) {
            total += n * m/2;
        }

        System.out.println(total);
        sc.close();

    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int M = scanner.nextInt();
		int N = scanner.nextInt();

		if(M > N){
			return;
		}else {
			int n = N / 2;
			int m = M;
			if(N % 2 == 1)
			{
				System.out.println((n * m) + (m / 2));
			}else {
				System.out.println(n * m);
			}
		}
	}
}

/*
 * 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 Fabian
 */
public class JavaApplication57 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner leer = new Scanner (System.in);
        int m,n,cantMax=0;
        m=leer.nextInt();
        n=leer.nextInt();
        if (m%2==0 || n%2==0) {
            cantMax = (m*n)/2;
        }else{
            if (n%2!=0 && m%2!=0 && m>1){
                cantMax = ((m-1)*n)/2 + n/2;
            }else{
                cantMax= m*n/2;
            }
        }
        System.out.println(cantMax);
    }

}

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

public class diminopiling {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String []s=br.readLine().trim().split("\\s+");
        int d=Integer.parseInt(s[0])* Integer.parseInt(s[1]);
        d=d/2;
        System.out.println(d);

    }

}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		Scanner sin = new Scanner(System.in);
		int M = Integer.parseInt(sin.next());
		int N = Integer.parseInt(sin.next());

		if (M % 2 == 1 && N % 2 == 1){
			System.out.println((M * N - 1) / 2);
		} else {
			System.out.println((M * N / 2));
		}
	}
}

import java.util.Scanner;

public class domino {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int k ;

		if((m*n)%2==0) {
			k=(m*n)/2;
		}
		else {
			k=((m*n)-1)/2;
		}
		System.out.println(k);
	}

}

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

public class Dominopiling {

    public static void main(String[] args) throws IOException {
         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            String []nums=br.readLine().trim().split("\\s+");
            int x=Integer.parseInt(nums[0]);
            int y=Integer.parseInt(nums[1]);
            int result=(x*y)/2;
            System.out.print(result);

    }

}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main {
    public static void main (String [] Args ) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); int m = sc.nextInt();
        if(n%2==0 || m%2==0) System.out.println((n*m)/2);
        else System.out.println(Math.max(((n-1)*m)/2+m/2,((m-1)*n)/2+n/2));
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    int M = input.nextInt();
    int N = input.nextInt();
    System.out.println(M*N/2);
    }
}

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import java.util.Scanner;

/**
 *
 * @author Guest
 */
public class First {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner sc = new Scanner(System.in);
        int N,M;
        M = sc.nextInt();
        N = sc.nextInt();
        if(N%2==0 || M%2==0) {
            if(N%2==0) {
                System.out.println((N/2)*M);
            }
                else {
                System.out.println((M/2)*N);
            }
        }
        else
        {
            System.out.println(((N-1)/2)*M+(M-1)/2);
        }
    }
}

import java.util.Scanner;
public class dominiPiling {
public static void main(String[] args) {
        Scanner s= new Scanner(System.in);
            String n=s.nextLine();
            int e=n.indexOf(" ");
            String d=n.substring(0,e);
            String r=n.substring(e+1,n.length());
            int k=Integer.parseInt(d);
            int l=Integer.parseInt(r);

            int j =k*l;
            int res =j/2;
            System.out.println(res);

        }
    }

import java.util.*;

public class JavaApplication3 {

    public static void main(String[] args) {

Scanner in = new Scanner(System.in);
int m = in.nextInt();
int n = in.nextInt();

        System.out.println((m*n) / 2);

    }

}

import java.io.PrintWriter;
import java.util.Scanner;

public class DominoPiling {
    public void solve(Scanner in, PrintWriter out) {
    	out.print(solve2(in.nextInt(), in.nextInt()));
    }

    static int solve(int n, int m) {
    	if (n < 1 || m < 1) {
    		return 0;
    	}

    	if (n == 1) {
    		if (m < 2) {
    			return 0;
    		}
    		else {
    			return m / 2;
    		}
    	}
    	else if (m == 1) {
    		if (n < 2) {
    			return 0;
    		}
    		else {
    			return n / 2;
    		}
    	}

    	return Math.max(1 + solve(2,  m - 1) + solve(n - 2, 1) + solve(n - 2, m - 1),
    			1 + solve(n - 1,  2) + solve(1, m - 2) + solve(n - 1, m - 2));
    }

    static int solve2(int n, int m) {
    	if (n < 1 || m < 1) {
    		return 0;
    	}
    	int[][] dp = new int[n + 1][m + 1];

    	for (int m1 = 2; m1 <= m ; m1++) {
    		dp[1][m1] = m1 / 2;
		}

    	for (int n1 = 2; n1 <= n ; n1++) {
    		dp[n1][1] = n1 / 2;
		}

    	for (int i = 2; i <= n; i++) {
			for (int j = 2; j <= m; j++) {
				dp[i][j] = 1 + Math.max(dp[2][j - 1] + dp[i - 2][ 1] + dp[i - 2][ j - 1],
						dp[i - 1][  2] + dp[1][ j - 2] + dp[i - 1][ j - 2]);
			}
		}

    	return dp[n][m];
    }

    public void run() {
        Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
    }

    public void run(Scanner in, PrintWriter out) {
    	solve(in, out);
	}

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

import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.InputMismatchException;
import java.util.Stack;

public class A50A {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            FastInput fastInput = new FastInput(System.in);
            FastOutput fastOutput = new FastOutput(System.out);
            A50A a50A = new A50A();
            // int tc = fastInput.readInt();
            int tc = 1;
            while (tc-- > 0) {
                a50A.solve(fastInput, fastOutput);
            }
            fastOutput.close();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    public void solve(FastInput fastInput, FastOutput fastOutput)
            throws Exception {
        int m, n;
        m = fastInput.readInt();
        n = fastInput.readInt();
        assertThat(m >= 1 && n >= 1 && m <= 16 && n <= 16);
        fastOutput.printLine(m * n / 2);
    }

    public static void assertThat(boolean assertion) {
        if (!assertion) {
            throw new ArithmeticException();
        }
    }
}

class FastInput {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastInput(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String readString() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public boolean isSpaceChar(int c) {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
        return readString();
    }

    public interface SpaceCharFilter {
        public boolean isSpaceChar(int ch);
    }
}

class FastOutput {
    private final PrintWriter writer;

    public FastOutput(OutputStream outputStream) {
        writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                outputStream)));
    }

    public FastOutput(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public FastOutput(File outputStream) throws Exception {
        this.writer = new PrintWriter(outputStream);
    }

    public void print(Object... objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object... objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }
}

import java.util.Scanner;

public class Yakov{
public static void main(String[] args){

Scanner sc = new Scanner(System.in);

long n,m,a;

n=sc.nextLong();
m=sc.nextLong();

System.out.print(n*m/2);

}
}

import java.util.*;
public class Dominopiling {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        int m = console.nextInt();
        int n = console.nextInt();
        int max = (n * m) / 2;
        System.out.println(max);
    }
}

import java.util.Scanner;

public class DominoPiling {

	static Scanner scan;
	public static void main(String[] args) {
		scan = new Scanner(System.in);
		int n,m;

		m = scan.nextInt();
		n = scan.nextInt();
		int domino = 0;
		if (1<=m&&m<=n&&n<=16) {
			domino = (int) Math.ceil((m*n)/2);
		}
		System.out.println(domino);
	}
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner input=new Scanner(System.in);
		int m=input.nextInt();
		int n=input.nextInt();
		int area=m*n;
		int domino=2;
		int pieces=area/domino;
		System.out.println(pieces);
	}

}

import java.util.Scanner;

public class DominoPilling {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int w = sc.nextInt();
        int h = sc.nextInt();
        int result = 0;
        if (w == 1 || h == 1) {
            result = (w == 1) ? (h / 2) : (w / 2);
        }else if (w == 2 || h == 2) {
            result = (w == 2) ? (h) : (w);
        }
        else {
            result = (w >= h) ? (h * w / 2) : (w * h / 2);
        }
        System.out.println(result);
    }
}

import java.util.Scanner;

public class _50A {
	public static void main(String[] args) {
		Scanner key = new Scanner(System.in);
		int n, m, d;
		do {m = key.nextInt();	n = key.nextInt();}while((m>0 && m<=16)&&(n>0 && n<=16)&&(m>n));
		////////////////
		if(m == 1) {
			if(n%2 == 0)d = n/2;
			else d = (n-1)/2;
		}else if(m%2 != 0) {
			if(n%2 == 0)d = n*(m/2);
			else d = ((m-1)/2)*n + (n-1)/2;
		}else {
			d = n*(m/2);
		}
		System.out.println((int)((m*n)/2));
	}

}

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

public class diminopiling {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String []s=br.readLine().trim().split("\\s+");
        int d=Integer.parseInt(s[0])* Integer.parseInt(s[1]);
        d=d/2;
        System.out.println(d);

    }

}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        String[] boardDim = input.nextLine().trim().split(" ");

        input.close();

        int squares = Integer.parseInt(boardDim[0]) * Integer.parseInt(boardDim[1]);

        int dominoes = squares / 2;

        System.out.println(dominoes);
    }
}

import java.util.Scanner;
import java.lang.Math;
public class theatre{
    public static void main(String[] args){
        Scanner milan=new Scanner(System.in);
        int n=milan.nextInt();
        int m=milan.nextInt();
        int a=2;
        int b=1;
        int z=0;
        int x=n/a;
        int y=m/b;
        if(n%a==1){
            z=m/a;
        }
        int milann=(x*y)+z;

        System.out.println(milann);
    }
}

import java.util.Scanner;

public class Solution
{
   public static void main(String[] args)
{
	    int a,b;
        Scanner sc = new Scanner(System.in);
        a = sc.nextInt();
        b = sc.nextInt();
        System.out.println((a*b)/2);
}
}

import java.util.Scanner;

public class DominoPiling {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		int m = scanner.nextInt();
		int n = scanner.nextInt();
		int answer = (m*n)/2;

		System.out.println(answer);

		scanner.close();
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class A50 {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String arr[] = input.readLine().split(" ");
        out.print((Integer.parseInt(arr[0])*Integer.parseInt(arr[1]))/2);
        input.close();
        out.close();
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int m=input.nextInt();
        int n=input.nextInt();
        System.out.println((n*m)/2);
    }

}

import java.util.*;
public class CF50A4 {
  public static void main(  String[] args){
    Scanner sc=new Scanner(System.in);
    int n=sc.nextInt();
    int m=sc.nextInt();
    if (true)     System.out.println((n * m) / 2);
 else     System.out.println((n * (m - 1) + m) / 2);
  }
}

import java.util.Scanner;
public class DominoPiling{
    public static void main(String []args){
        Scanner in= new Scanner(System.in);
        int z=0;
        short m=in.nextShort();
        short n=in.nextShort();
        z=m/2*n;if(m%2!=0)z+=n/2;
        System.out.print(z);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class LongStrings {
    static PrintWriter out;
    static InputReader in;
    public static void main(String args[]){
        out = new PrintWriter(System.out);
        in = new InputReader();
        new LongStrings();
        out.flush(); out.close();
    }
    LongStrings(){
        solve();
    }
    void solve(){
        out.println((in.nextInt() * in.nextInt()) / 2);
    }

    public static class InputReader{
        BufferedReader br;
        StringTokenizer st;
        InputReader(){
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public long nextLong(){
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
        public String next(){
            while(st == null || !st.hasMoreTokens()){
                try{
                    st = new StringTokenizer(br.readLine());
                }catch(IOException e){}
            }
            return st.nextToken();
        }
    }
}

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

public class domino
{
    public static void main(String args[])
    {
        int m, n;
        Scanner scanner = new Scanner(System.in);

        while(scanner.hasNext())
        {
            m = scanner.nextInt();
            n = scanner.nextInt();

            if( ( m % 2 ) == 0 )
            {
                System.out.println( ( m / 2 ) * n );
            }
            else
            {
                System.out.println( ( m / 2 ) * n + ( n / 2 ) );
            }
        }
    }
}

import java.util.*;
public class Test {
    public static void main(String[] args) throws Exception {
    Scanner in = new Scanner(System.in);
    int m = in.nextInt();
    int n = in.nextInt();
    System.out.println((m*n)/2);
    }

}

import java.util.Scanner;

public class DominoPilingA {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		double m, n;
		m = sc.nextDouble();
		n = sc.nextDouble();
		if(m*n%2 == 1)
			System.out.println((int)((m*n-1)/2));
		else
			System.out.println((int)(m*n/2));
	}

}

import java.util.Scanner;
public class Domino_piling {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int a[]=new int[2];
		for(int i=0;i<2;i++)a[i]=input.nextInt();
		System.out.println((a[0]*a[1])/2);
	}
}

import java.util.Scanner;

public class Dominoes {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int m = in.nextInt(), n = in.nextInt();
		int ans = 0;

		if(m % 2 == 0) {
			ans = (m/2) * n;
		} else { // m%2 != 0
			if(n % 2 == 0) {
				ans = (n/2) * m;
			}
			else { // n%2 != 0
				if(m > 1) {
					ans = (m/2)*n + n/2;
				} else
					ans = m*(n/2);
			}
		}

		System.out.println(ans);
	}
}

import java.util.Scanner;

public class domino {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt(), n = sc.nextInt();
		int num;
		if ((n * m) % 2 == 0) {
			num = n * m / 2;
		} else {
			num = (n * m / 2);
		}

		if(num < 0) num = 0;

		System.out.println(num);

	}

}

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

public class Domino
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] s = new String[2];
        s = in.readLine().split(" ");
        int m = Integer.parseInt(s[0]);
        int n = Integer.parseInt(s[1]);

        int tiles = m*n;
        if(tiles%2==0)
            System.out.println(tiles/2);
        else
            System.out.println((tiles-1)/2);
    }
}

import java.util.Scanner;

public class Solution{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if(m>1 || n>1){
            if(m==2){
                System.out.println(n);
            }
            else if(n==2){
                System.out.println(m);
            }
            else{
                System.out.println((m*n)/2);
            }
        }else{
            System.out.println(0);
        }
    }
}

import java.util.Scanner;

public class Problem50A {
    String arr[];
    int tamaño = 0;
    public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String entrada = sc.nextLine();

            String[] arr = entrada.split(" ");
            int tamaño = Integer.parseInt(arr[0]) * Integer.parseInt(arr[1]);

            System.out.println(tamaño/2);
    }

}

import java.util.*;

public class WordTest {
	public static void SortNum() {
	int x,y,d ;
	Scanner sc = new Scanner (System.in);
	 x=sc.nextInt();
	y=sc.nextInt();
d=x*y;
System.out.println(d/2);;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		SortNum();
	}

}

import java.util.*;

public class DominoPiling
{
   public static void main(String[] args)
   {
      // Set up scanner
      Scanner sc = new Scanner(System.in);
      // System.out.println("Enter M");
      long M = sc.nextLong();
      // System.out.println("Enter N");
      long N = sc.nextLong();

      System.out.println((M*N)/2);
   }
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
                int ans = (n * m) / 2;
                System.out.println(ans);
                return;
        }
}
//I'm coding on mobile forgive my incompetence 😭

import java.util.*;

public class Main{

    static int fn(int m,int n){
        int count=0;
       if(m>=2){

           int x=m/2;
           count=x*n;

       }

       if(m%2!=0 && n>=2){

           int x=n/2;
           count+=x;
       }

       return count;

    }

    public static void main(String[] kweb){

        Scanner sc=new Scanner(System.in);

        int m=sc.nextInt();
        int n=sc.nextInt();

        System.out.print(fn(m,n));

    }
}

import java.util.*;

public class Solution
{
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        int m=in.nextInt();
        int n=in.nextInt();
        if(m<=n && n<=16 && m>0) {
        if((m*n)%2==0)
        {
        	System.out.println((m*n)/2);
        }
        else
        {

            System.out.println(((m*n)/2));

       } }

    }

}

import java.util.Scanner;

public class piling{

public static void main(String[] args){

int c=0,l,b;
Scanner inp = new Scanner(System.in);
l = inp.nextInt();
b = inp.nextInt();

while(l*b>1){

if(l%2==0){

	c = c+l/2;
	b--;
}
else{

if(b>1){
c = c+l;
b = b-2;
}
else{
c= c+l/2;
b--;
}

}

}
System.out.println(c);
}
}

import java.util.Scanner;

public class CF50A {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner myScan = new Scanner(System.in);
		String[] dim = myScan.nextLine().split(" ");
		int M = Integer.parseInt(dim[0]);
		int N = Integer.parseInt(dim[1]);

		System.out.println(M * N / 2);

		myScan.close();

	}

}

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

public class DominoPiling {
    public static void main(String[] args) throws IOException {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(f.readLine());
        int m = Integer.parseInt(st.nextToken());
        int n = Integer.parseInt(st.nextToken());
        System.out.println(m*n/2);
    }
}

import java.util.*;
public class codeForces {

    public static void main(String[]args)
    {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();

        System.out.println(n*m/2);

    }
}

import java.util.*;
public class CF50A7 {
  public static void main(  String args[]){
    long m, n;
    Scanner sc=new Scanner(System.in);
    m=sc.nextInt();
    n=sc.nextInt();
    long total=(m * n) / 2;
    if (false) {
      System.out.println(total - 1);
    }
 else {
      System.out.println(total);
    }
    sc.close();
  }
}

import java.util.*;
public class dominopiling
{
	public static void main(String[] args) {

			Scanner sc=new Scanner(System.in);
int m,n,count=0;
m=sc.nextInt();
n=sc.nextInt();
if(m==1)
count=n/2;
else if(m%2==0)
count=(m/2)*n;
else if(m%2!=0)
count=((m/2)*2)+1+((n-2)/2)+((n-2)*(m/2));

System.out.println(count);
	}
}

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

public class Main {
	public static void main(String args[]) throws java.lang.Exception
	{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

	String[] s = br.readLine().split(" ");

	long m = Integer.parseInt(s[0]);
	long n = Integer.parseInt(s[1]);

	int total = (int)Math.floor(m*n*0.5);

	System.out.println(total);
	}
}

import java.util.Scanner;
import java.math.*;
public class Program {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner nw=new Scanner(System.in);
        int m=nw.nextInt();
        int n=nw.nextInt();

      System.out.println(((m*n)/2));
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class DominoPiling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// Problem https://codeforces.com/problemset/problem/50/A
		// For more solutions check https://github.com/jontiboss
		Reader reader = new Reader();
		// Find the area which is x*y, a domino is always taking up 2 spaces.
		// A even area can always be divided by 2, and odd area will have a square left empty.
		// for bigger squares the one "empty" square thats left will have a smaller impact in the total area.
		// therefore we could just truncate the decimals to an integer, to get the maximum domino its just to divide by 2.

	    //multiply the two inputs to get the area, then bitwise divide by 2 to get the final result.
		int area = reader.nextInt()*reader.nextInt();
		System.out.println(area>>1);
	}
	static class Reader
	{
		BufferedReader br;
		StringTokenizer st;

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

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

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

	}
}

import java.util.Scanner;

public class A {
    public static void main(String[]args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int k = sc.nextInt();
        if(n>1 || k>1) {
            System.out.println((n*k)/2);
        }else {
            System.out.println(1);
        }
    }
}

import java.util.*;

public class Solution
{
    public static void main(String[] args)
    {
        Scanner in=new Scanner(System.in);
        int m=in.nextInt();
        int n=in.nextInt();
        if(m<=n && n<=16) {
        if((m*n)%2==0)
        {
        	System.out.println((m*n)/2);
        }
        else
        {

            System.out.println(((m*n)/2)-1);

        }

    }}
}

import java.util.*;
import java.lang.*;
public class Main{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        int n = scan.nextInt();
        int result;
        if(m%2 == 0 && n%2 == 0){
            result = (m/2) * n;
        }
        else if(m > 2){
            result = ((m/2) * n) + n/2;
        }
        else{
            result = ((m/2) * n);
        }
        System.out.println(result);
    }
}

import java.util.*;
public class DominoPiling
{
  public static void main (String [] args)
  {
    Scanner s = new Scanner(System.in);
    int m = s.nextInt();
    int n = s.nextInt();
    int col = n;
    int row;
    m= m-2;
    if(m==0)
    {
      row=1;
    }
    else if(m==1)
    {
      row= n/2;
    }
    else
    {
      row= 1+ m/2;
    }
    System.out.println(row*col);
  }
}

import java.util.Scanner;
public class Main {

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int m, n;
        m = sc.nextInt();
        n = sc.nextInt();
        if (n>1) {
            if (m * n % 2 == 0) {
                System.out.println((m * n) / 2);
            } else {
                System.out.println(((m * n) - 1) / 2);
            }
        }
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int m, n;

        Scanner s = new Scanner(System.in);

        m = s.nextInt();
        n = s.nextInt();

        if(m%2==0 && n%2!=0)
        {
            System.out.println(n);
        }
        if (m%2!=0 && n%2==0)
        {
            System.out.println((m*n)/2);
        }
        if ((m%2!=0 && n%2!=0)||(m%2==0 && n%2==0))
        {
            System.out.println((m*n)/2);
        }
    }
}

import java.util.Scanner;

public class a50 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int num1 = in.nextInt();
        int num2 = in.nextInt();
        int min = Math.min(num1, num2);
        int max = Math.max(num1, num2);

        System.out.println( Math.ceil(max / 2) + Math.ceil(min / 1));

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class DominoPiling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// Problem https://codeforces.com/problemset/problem/50/A
		// For more solutions check https://github.com/jontiboss
		Reader reader = new Reader();
		// Find the area which is x*y, a domino is always taking up 2 spaces.
		// A even area can always be divided by 2, and odd area will have a square left empty.
		// for bigger squares the one "empty" square thats left will have a smaller impact in the total area.
		// therefore we could just truncate the decimals to an integer, to get the maximum domino its just to divide by 2.

	    //multiply the two inputs to get the area, then bitwise divide by 2 to get the final result.
		int area = reader.nextInt()*reader.nextInt();
		area = area<<1;
		System.out.println(area);
	}
	static class Reader
	{
		BufferedReader br;
		StringTokenizer st;

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

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

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

	}
}

import java.util.Scanner;

    public class Domino{
        public static void main (String []args){
            Scanner in = new Scanner (System.in);
            int m = in.nextInt();
            int n = in.nextInt();

            if (m == 1) {
                n = n/2*1;
                }

            else{
                if (m>1) {
                n = m*n%2*1;
                }
                }
            System.out.println(n);
            }
            }

import java.util.Scanner;

public class Problem_50A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int ko1 = s.nextInt();
        int ko2 = s.nextInt();
        if(ko1>=1 || ko1<=16 || ko1<=ko2 || ko2<=16 || ko2>=1){
            int max=0;
        if(ko1<ko2){max=ko2;}
            System.out.println(max);
        }
    }

}

import java.util.*;

public class Domino_piling {
	public static void main(String args[]){
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		int n = sc.nextInt();
		int dominoes=0;

		if(1<=m&&m<=n&&n<=16){
			if((n!=1)||(m!=1)){
				if((n%2==0)&&(m%2!=0)){
					dominoes=m*2;
				}
				if((n%2==0)&&(m%2==0)){
					dominoes=m*2;
				}
				if((n%2!=0)&&(m%2==0)){
					dominoes=(n*m)/2;
				}
				if((n%2!=0)&&(m%2!=0)){
					dominoes=((m*n)-1)/2;
				}
			}

		}
		System.out.println(dominoes);

	}
}

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), m = sc.nextInt();
		if (n % 2 == 0 || m % 2 == 0) {
                    int ans = (n * m) / 2;
                    System.out.println(ans);
                    return;
                }
                if (n + m == 2) { System.out.println(0); return; }
                int ans = n * (m / 2);
                if (m % 2 == 1 && n != 1) ans += m % 2;
                System.out.println(ans);
       }
}
//I'm coding on mobile forgive my incompetence 😭

/*
 * 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 domino.piling;

import java.util.Scanner;

/**
 *
 * @author Mostafa
 */
public class DominoPiling {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner in = new Scanner (System.in);
        byte n = in.nextByte() ;
        byte m = in.nextByte() ;
        if ( Math.min(n, m) > 1 )
            System.out.println( Math.max(n, m) + ( Math.min(n, m) - 1 ) / 2);
        else
            System.out.println( Math.max( n, m ) / 2 );
    }

}

/*
 * 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 domino.piling;

import java.util.Scanner;

/**
 *
 * @author Mostafa
 */
public class DominoPiling {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner in = new Scanner (System.in);
        byte n = in.nextByte() ;
        byte m = in.nextByte() ;
        if ( Math.min(n, m) > 2 )
            System.out.println( (Math.max(n, m)* (Math.min(m, n)/2)) + (( Math.max(n, m)) / 2) );
        else if ( Math.min(n, m) == 1 )
            System.out.println( Math.max( n, m ) / 2 );
        else
            System.out.println( Math.max( n, m ) );
    }

}

/*
 * 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 Fabian
 */
public class JavaApplication57 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner leer = new Scanner (System.in);
        int m,n,cantMax=0;
        m=leer.nextInt();
        n=leer.nextInt();
        if (m%2==0 || n%2==0) {
            cantMax = (m*n)/2;
        }else{
            if (n%2!=0 && m%2!=0 && m>1){
                cantMax = ((m-1)*n)/2 + m/2;
            }else{
                cantMax= m*n/2;
            }
        }
        System.out.println(cantMax);
    }

}

import java.util.Scanner;

public class Domino {

	public static void main(String[] args) {
		double ans = 0;
		Scanner x = new Scanner(System.in);
		double n = x.nextFloat();
		double m = x.nextFloat();
		if(n%2==0){
			ans= m*(n/2);
		}
		else if (n%2!=0){
			ans=(n-1)*Math.floor(m/2);
		}
		if(n%2!=0 && m%2!=0){
			ans=Math.floor((m*n)/2);

		}
System.out.println(ans);
	}

}

import java.util.*;

public class Domina {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int  n = sc.nextInt();
        int  m = sc.nextInt();
        int k = m/1 + (int)Math.signum(m%1);
        int k1 = n/2 + (int)Math.signum(n%2);
        System.out.println(k1*k);
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int m, n, m1 = 2, n1 = 1, count1 = 0, count2 = 0;

        Scanner s = new Scanner(System.in);

        m = s.nextInt();
        n = s.nextInt();

        if(m%2==0 && n%2!=0)
        {
            System.out.println(n);
        }
        if (m%2!=0 && n%2==0)
        {
            System.out.println(n/2);
        }
        if ((m%2!=0 && n%2!=0)||(m%2==0 && n%2==0))
        {
            System.out.println((m*n)/2);
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
public class A50 {
    public static void main(String[] args) throws IOException {
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        String arr[] = input.readLine().split(" ");
        out.println((Integer.parseInt(arr[0])*(Integer.parseInt(arr[1])))/2 + "");
    }
}

import java.util.Scanner;

public class A50{

    public static void main(String[] args){

    int m,n,DominoeX=2,dominoeY=1,total=0;
    Scanner input = new Scanner(System.in);
    m= input.nextInt();
    n=input.nextInt();
    if(m%2 != 0 && n%2 !=0){
        total = (m-1) / 2 * (n-1) / 1;
        total+= (int)(Math.floor((double) m / 2) + Math.floor((double) n / 2));
    }
    else if(m==1){
        total = (int)(Math.floor((double) n / 2));
    }
    else if(n==1){
        total = (int)(Math.floor((double) m / 2));
    }
    else{
        total = (int)(Math.floor((double) m / 2) * Math.floor((double) n / 1));
    }
    System.out.println(total);
    }
}

import java.util.Scanner;
public class DominoPiling {

	public static void main(String[] args) {
		Scanner entrada = new Scanner(System.in);

	String[] input = entrada.nextLine().split(" ");
	int m = Integer.parseInt(input[0]);
	int n = Integer.parseInt(input[1]);

	System.out.println(getOutput(m,n));

	}

	public static int getOutput(int m, int n) {
		int output = 0;

		if(m==1 && n==1)
			return 0;

		if(m==1 && n!=1) {
			if(n%2==0)
				return n/2;
			if(n%2!=0)
				return (n-1)/2;
		}

		if((m%2==0 && n%2==0) || (m%2==0 && n%2!=0) )
			output = n*(m/2);
		if(m%2!=0 && n%2==0)
			output = ((m-1)/2)*n + n/2;

		if(m%2!=0 && n%2==0)
			output =  (n*((m-1)/2))+(n/2);

		if(m%2!=0 && m%2!=0)

			output = (((m-1)/2)*n) + (n-1)/2;

		return output;

	}

}

import java.util.Scanner;

public class Domino_piling {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner Scan = new Scanner ( System.in);
		int m =Scan.nextInt();
		int n =Scan.nextInt();

		int [][] array = new int[m][n];
		int count=0;
		if(m==1 ||n==1){
		int max = Math.max(n, m);
		while (max >2){
			count++;
			max-=2;
		}
		 System.out.print(count);
		 System.exit(0);
		}
		else if(m>=2 && n>1){
		while (true ){

			array=fill(array , m , n , count );
			count++;
			/*System.out.println("count = " + count);
			for(int i =0 ; i<m;i++){
				for(int j=0 ; j<n;j++){
					System.out.println("array["+i+"]["+j+"]="+array[i][j] );

				}}*/
		}
	}
	}
	public static int[][] fill(int [][]array ,int n ,int m , int count ){
boolean result=false;
		for(int i =0 ; i<n;i++){
			for(int j=0 ; j<m;j++){

				if(array[i][j]!=1){
					try{
			 if( array[i][j+1]!=1){
				 array[i][j]=1;
				 array[i][j+1]=1;
				 result=true;
				return array;
			 }
			 else if( array[i+1][j]!=1){
				 array[i][j]=1;
				 array[i+1][j]=1;
				 result=true;
					return array;
			 }
				}catch(Exception e){
					try {
						if( array[i+1][j]!=1){

						 array[i][j]=1;
						 array[i+1][j]=1;
						 result=true;
							return array;
					 }
						else{

							result=false;
						}
						}
					catch(Exception x){
						result=false;
					}
				}
			 if(i==n-1 && j==m-1){

			result =false;
			 }
				}
		}
		}
		 if(!result){

			 System.out.print(count);
			 System.exit(0);
		 }

		return array;
}
}

import java.util.Scanner;
import java.lang.Math;
public class theatre{
    public static void main(String[] args){
        Scanner milan=new Scanner(System.in);
        int n=milan.nextInt();
        int m=milan.nextInt();
        int a=2;
        int b=1;
        int x=n/a;
        int y=m/b;
        /*if(n%a!=0)
        x++;
        if(m%a!=0)
        y++;*/

        System.out.println(x*y);
    }
}

import java.util.Scanner;

public class MyWindowApp {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String inp = sc.nextLine();
        int n, m;
        n = inp.charAt(0) - 48;
        m = inp.charAt(2) - 48;
        if (n == 1 && m == 1) {
            System.out.println(0);
            System.exit(0);
        }
        if (n % 2 == 1 && m % 2 == 1) {
            System.out.println((n * m - 1) / 2);
            System.exit(0);
        }
        System.out.println(n * m / 2);
    }
}

import java.util.Scanner;

public class DominoPiling {

	private static int getMax(int m, int n) {
		if(m == 1 || n == 1)
			return Integer.max(m, n) / 2;
		if(m == 2 || n == 2)
			return Integer.max(m, n);
		int maxVal = Integer.max(m, n);
		return (maxVal + maxVal % 2);
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int m = scanner.nextInt();
		int n = scanner.nextInt();

		int ans = getMax(m, n);

		System.out.println(ans);
		scanner.close();
	}

}

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

public class pb1
{
	public static void main (String[] args)
	{
		Scanner in = new Scanner(System.in);

		int n,m;
		n = in.nextInt();
		m = in.nextInt();

		int ans = (n/2)*m;
		if (n%2 != 0)
			ans += m%2;
		System.out.println(ans);
	}
}

public class Dominoes {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(dominoCount(1,3));
	}
	private static int dominoCount(int m,int n){
		return (m*n)/2;
	}

}

import java.util.Scanner;

public class dominoPiling {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        int m=in.nextInt();
        int n=in.nextInt();

        if (m==1 && n==1) System.out.println(0);
        if(m%2==1 && n%2==1)
                {
                    System.out.println(m*n/2);
                }

        else
        {
            System.out.println(m*n/2);
        }

        in.close();
    }
}

import java.io.*;
import java.util.*;
public class one
{
    public static void main(String args[])
    {
     Scanner sc=new Scanner(System.in);
     int a=sc.nextInt();
     int b=sc.nextInt();
     int x,y;
     if(a>2)
     x=a;
     else
     x=1;
     if(b>2)
     y=b/2;
     else
     y=1;
     System.out.println(x+y);

    }
}

import java.util.Scanner;

/**
 *
 * @author Justin Stroup <jstroup@mail.umhb.edu>
 * @version 0.0.1, 29 Apr 2015
 */
public class DominoPiling {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);

        int M = 2;
        int N = 4;

        M = sc.nextInt();
        N = sc.nextInt();

        System.out.println(Math.floor((M * N) / 2));
    }
}

import java.io.*;
import java.util.StringTokenizer;

public class A50 {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int ans = n*m;
        System.out.println(ans);
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

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

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

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

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

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

        public boolean ready() throws IOException {
            return br.ready();
        }
    }
}

import java.util.Scanner;

public class Dominoes {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int m = in.nextInt(), n = in.nextInt();
		int ans = 0;
		if(n % 2 == 0)
			ans = (m)*(n/2);
		else
			if(m % 2 == 0)
				ans = (n)*(m/2);
			else {
				ans = n * (m/2) + (m/2);
			}

		System.out.println(ans);
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
	// write your code here
        Scanner scanner = new Scanner(System.in);

        int m,n;
        int d1 = 2;
        int d2= 1;
        int addOne = 0;
        int result;
        do{
            m = scanner.nextInt();
            n = scanner.nextInt();
        } while (m <= 0 || m > n || n > 16);

        if(m % 2 != 0 || n % 2 != 0){
            addOne = 1;
        }

        result = (m / d1) * (n / d2) + addOne;

        System.out.println(result);
    }
}

import java.util.Scanner;

public class ADominoPiling {

    public static void main (String[] args) {
        Scanner sc = new Scanner(System.in);

        int dim1 = sc.nextInt();
        int dim2 = sc.nextInt();

        int result = 0;

        result += (dim1 % 2) * dim2;
        result += dim2 % 2;

        System.out.println(result);

        sc.close();
    }
}

import java.util.Scanner;

public class Main {
	private static Scanner scanner = new Scanner(System.in);
	public static void main(String[] args) {
		int count;
		int n = scanner.nextInt();
		int m = scanner.nextInt();
		if (n % 2 == 0)
			count = n / 2 * m;
		else if (m % 2 == 0)
			count = m / 2 * m;
		else {
			m--;
			count = m / 2 * n;
			count += n / 2;
		}
		System.out.println(count);
	}
}

import java.util.Scanner;

public class CF50A10{

   static int count;
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);

        int m=sc.nextInt();
        int n=sc.nextInt();
        if(m%2==0&&n%2!=0)
        {
            count=(m*n)/2;
            System.out.println(count);
        }
        if(m%2==0&&n%2!=0)
        {
            int count1=m/2;
            count=count1+((m*(n-1))/2);
            System.out.println(count);
        }
          if(n%2==0&&m%2!=0)
        {
            int count1=n/2;
            count=count1+((n*(m-1))/2);
            System.out.println(count);
        }
          else
          {
              int a=m-1;
              int b=n-1;
              int count1=a*b/2;
              count=count1+(m/2)+(n/2);
              System.out.println(count);

          }

    }

}

import java.util.Scanner;

public class DominoPiling {
 int n; int m;
 DominoPiling (int m,int n)
 {
	 this.m=m;
	 this.n=n;
 }

/*public int[][] createEmptyBoard(int a,int b)
{ int[][] board=new int[a][b];
  for (int i=0;i<=a;i++)
	  for(int j=0;j<=b;j++)
		 board[i][j]=0;

	return board;
	}	*/

public void replacevalues(int[][] board,int index11,int index12,int index21,int index22)
{
	board[index11][index12]=1;
	board[index21][index22]=1;

	}
public int AdjecentAndEmpty(int[][]board,int index1,int index2)
{
	int l=0;
if(index1<n-1 )
  if(((board[index1][index2]==0) && (board[index1+1][index2]==0))) {
	  replacevalues(board,index1,index2,index1+1,index2); l++;

  }
  else if(index2<m-1)
  if(((board[index1][index2]==0) && (board[index1][index2+1]==0))) {
	  replacevalues(board,index1,index2,index1,index2+1); l++;
  }
return l;
	}
public int placeDominosAndGiveRes(int[][] board)
{ int k=0;

  for (int i=0;i<n;i++)
   for (int j=0;i<m;j++) {
	   AdjecentAndEmpty(board,i,j);
	   }
   return k;}

public static void main(String[] args) {
	Scanner s=new Scanner(System.in);
	int n=s.nextInt();
	int m=s.nextInt();
 DominoPiling ex=new DominoPiling (n,m);
	int[][] x= new int[n][m];
	  for (int i=0;i<n;i++)
		  for(int j=0;j<m;j++)
			 x[i][j]=0;
int p=0;
	  for (int a=0;a<n;a++)
		   for (int b=0;b<m;b++)
			p+=  ex.AdjecentAndEmpty(x, a, b);
	  System.out.print(p);

}
}

import java.util.Scanner;

public class A50 {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        in.close();
        int cells = n*m;
        System.out.println(cells %2==1 ? (cells -1) : cells);

	}

}

import java.util.Scanner;
public class coee{
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        int m=scan.nextInt();
        int n=scan.nextInt();
        int a;
        if (m%2==0)
        {a=Math.abs(m/2)*Math.abs(n/1);}
        else if (n%2==0)
        {a=Math.abs(m/1)*Math.abs(n/2);}
        else
        {a=(Math.abs(m/1)+1)*(Math.abs(n/2)+1);}
        System.out.println(a);
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int M = scanner.nextInt();
		int N = scanner.nextInt();

		if(M > N){
			return;
		}else {
			int n = N / 2;
			int m = M;
			if(M % 2 == 1)
			{
				System.out.println((n * m) + (m / 2));
			}else {
				System.out.println(n * m);
			}
		}
	}
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner kb = new Scanner(System.in);
        int a = kb.nextInt();
        int b = kb.nextInt();
        System.out.println((int)Math.sqrt((a * a) + (b * b)));

    }
}

import java.util.Scanner ;
public class Test {

    public static void main(String[] args)  {

Scanner s = new Scanner (System.in);
System.out.println("Enter M , N ");

int m=s.nextInt(),n=s.nextInt();
if(m>=1 && n<=16){
int cm=0,cn=n,cm2=m,cn2=0;

while(m>=2){

m-=2;
cm++;

}

int x=n*cm;

while(n>=2){

n-=2;
cn2++;
}
int y=cm2*cn2;

if(x>y){
if(m%2!=0 && n%2!=0)
System.out.println(x+m+cn-1);
else
System.out.println(x);
}
else{
if(m%2!=0 && n%2!=0)
System.out.println(y+n+cm-1);
else
System.out.println(y);
}
}
else
System.out.println("Illegal input ! ");
}

    }

import java.util.Scanner;
public class domino50A {

    public static void main(String[] args) {
        Scanner inp = new Scanner(System.in);
        int domino[] = {2,1};

        int M =inp.nextInt();
        int N =inp.nextInt();

        if(M>=1 && M<=N && N<=16){
            int a = N%domino[0];

            if(a==0){
                System.out.println(M/2*N);
            }else{
                int b = N/2;
                System.out.println(b*N+1);
            }

        }

    }

}

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

public class codeforces{
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();

        int max = m * (n / 2) ;
        if(n % 2 != 0) max = max + (n / 2);
        if(m==1) max = n/2;
        if(n==1) max = m/2;
        System.out.println(max);

    }

}

import java.util.Scanner;

public class Domino {
    private static final Scanner sc = new Scanner(System.in);
    private static int m;
    private static int n;
    static {
        m = sc.nextInt();
        n = sc.nextInt();
    }

    public static boolean isEven(int a) {
        return (m % 2 == 0);
    }

    public static int ifEven(int m, int n) {
        return (m / 2 * n);
    }

    public static int ifOdd(int m, int n) {
        int oddVal = (m + (n-1))/2;
        int evenVal = ifEven(m-1,n-1);
        return evenVal + oddVal;
    }

    public static void main(String[] args) {
        if (m%2==1 && n%2==1)
            System.out.println(ifOdd(m, n));
        else
            System.out.println(ifEven(m, n));
    }

}

import java.util.Scanner;

public class A50_Domino_Piling {
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if(m!=1 && n!=1) {
            if ((m * n) % 2 == 0) {
                System.out.print(((m * n) / 2));
            } else System.out.print((((m * n) - 1) / 2));
        }
        else System.out.print("1");
    }
}

import java.util.Scanner;

public class codeforce5 {
    public static void main(String[] args)
    {
        Scanner x = new Scanner(System.in);
        String values = x.nextLine();
        int width = Integer.parseInt(String.valueOf(values.charAt(0)));
        int height = Integer.parseInt(String.valueOf(values.charAt(2)));
        Rectangle rectangle = new Rectangle(width,height);
        Domino domino = new Domino(2,1);
        if(rectangle.width >= domino.width && rectangle.height >= domino.height)
        {
            if(rectangle.width % 2 == 0 && rectangle.height % 2 == 0)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber);
            }
            else if(rectangle.width % 2 == 0 && rectangle.height % 2 == 1)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber);
            }
            else if(rectangle.width % 2 == 1 && rectangle.height % 2 == 0)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber + 1);
            }
            else
                {
                    int number = rectangle.width / domino.width;
                    int totalnumber = number * rectangle.height;
                    System.out.println(totalnumber+1);
                }
        }
    }
}

class Rectangle{
    int width;
    int height;
    Rectangle(int width,int height)
    {
        this.width = width;
        this.height = height;
    }
}
class Domino{
    int width;
    int height;
    Domino(int width,int height)
    {
        this.width = width;
        this.height = height;
    }
}

import java.util.*;
public class ahmed {
	public static void main(String[]args){
		Scanner s=new Scanner(System.in);
		String x=s.nextLine();
		String y1=""+x.charAt(0);
		String y2=""+x.charAt(2);
		int x2=Integer.parseInt(y1);
		int x3=Integer.parseInt(y2);
		System.out.print((x2*x3)/2);
	}
}

import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        // Your code here!
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        int n = scan.nextInt();
        int dominoes=0;
        if(m % 2 == 0 && n%2 !=0){
            // todos horizontales:
            dominoes = (m/2)*n;
        }
        if(m % 2 != 0 && n%2 ==0){
            // todos verticales
            dominoes = (n/2)*m  ;
        }

        // ambos impar
        if(m % 2 != 0 && n%2 !=0){
            // mayoria vertical y resto horizontal
             if (n>m){
             dominoes = n/2 *m;}
             else if (m>n){
             dominoes = m/2*n;}
             else{
                 dominoes = n*m/2;
             }

        }
        // si ambos par
        if (m %2 ==0 && n%2 ==0){
            if (m>n){
                dominoes = (m/2)*n;
            }
            else if (n>m){
                dominoes =(n/2)*m;
            }
            else if(n==m){
                dominoes = n*2;
            }
        }
        System.out.println(dominoes);

    }
}

import java.util.*;
public class HelloWorld{

     public static void main(String []args){
      Scanner s=new Scanner(System.in);
	int m=s.nextInt();
	int n=s.nextInt();
if (m==1)
System.out.println(n/2);
else if(m%2==0)
System.out.println((n*m)/2);
else
System.out.println(((n*m)/2)+n/2);

     }
}

import java.io.PrintWriter;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in=new Scanner(System.in);
        PrintWriter out=new PrintWriter(System.out);

        int n,m;
        n = in.nextInt();
        m = in.nextInt();

        int on = n % 2;
        int om = m % 2;

        int t = 0;

        if (on == om && on == 0) {
            t = n * m/2;
        } else if (on == om && on == 1) {
            t = n * (m/2) + (n/2);
        } else if (on != om) {
            if (on == 0)
                t = (n/2) + m;
            else
                t = (m/2) + n;
        }

        out.print(t);

        out.flush();

    }
}

import java.util.Scanner;

public class A50 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if (m%2 == 0) {
            System.out.println(m/2*n);
            return;
        }
        if (n%2 == 0) {
            System.out.println(n/2*m);
            return;
        }

        if ( n==1 ) {
            System.out.println(m/2+1);
            return;
        }
        if ( m==1 ) {
            System.out.println(n/2+1);
            return;
        }
        System.out.println((m-1)/2*n+n/2+1);
    }
}

import java.util.*;

public class language {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int result = 0;
       if (m*n%2==0){
           result=m*n/2;
       } else {
           result = m * n / 2 - 1;
       }
        System.out.println(result);

    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner kb = new Scanner(System.in);
        int a = kb.nextInt();
        int b = kb.nextInt();
        if (a % 2 != 0 && a >= 2) {
            System.out.println(a + (b / 2));
        } else if (a % 2 == 0 && b % 2 != 0 && a >= 2) {
            System.out.println(a + (int) Math.ceil(b / 2.0));
        } else if (a % 2 == 0 && b % 2 == 0 && a >= 2) {
            System.out.println((b/a) + (int) Math.ceil(b / 2.0));
        } else {
            System.out.println((a / 2) + (b / 2));
        }
    }
}

//package A;

import java.util.Scanner;

public class DominoPiling {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int m = s.nextInt();
        int n = s.nextInt();
        double count = 0;

        int longer = 0;
        int shorter = 0;

        if(m > n) { longer = m; shorter = n; }
        else { longer = n; shorter = m; }

        if(m == 1 && n == 1) count = 0;
        else if(m == 1 || n == 1) count = Math.floor(longer/2);
        else if(n % 2 == 0 || m % 2 == 0) {
            if(longer / 2 == shorter) count = Math.floor(shorter/2) * n + Math.floor(longer/2);
            else count = shorter/2 * longer;
        }
        else count = Math.floor(shorter/2) * n + Math.floor(longer/2);

        System.out.println((int)count);
    }
}

import java.util.Scanner;

public class codeforce5 {
    public static void main(String[] args)
    {
        Scanner x = new Scanner(System.in);
        String values = x.nextLine();
        int width = Integer.parseInt(String.valueOf(values.charAt(0)));
        int height = Integer.parseInt(String.valueOf(values.charAt(2)));
        Rectangle rectangle = new Rectangle(width,height);
        Domino domino = new Domino(2,1);
        if(rectangle.width >= domino.width && rectangle.height >= domino.height)
        {
            if(rectangle.width % 2 == 0 && rectangle.height % 2 == 0)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber);
            }
            else if(rectangle.width % 2 == 0 && rectangle.height % 2 == 1)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber);
            }
            else if(rectangle.width % 2 == 1 && rectangle.height % 2 == 0)
            {
                int number = rectangle.width / domino.width;
                int totalnumber = number * rectangle.height;
                System.out.println(totalnumber + 1);
            }
            else
                {
                    int number = rectangle.width / domino.width;
                    int totalnumber = number * rectangle.height;
                    System.out.println(totalnumber+1);
                }
        }else
            {
                System.out.println(rectangle.height / 2);
            }
    }
}

class Rectangle{
    int width;
    int height;
    Rectangle(int width,int height)
    {
        this.width = width;
        this.height = height;
    }
}
class Domino{
    int width;
    int height;
    Domino(int width,int height)
    {
        this.width = width;
        this.height = height;
    }
}

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int M = scanner.nextInt();
		int N = scanner.nextInt();

		if(M > N){
			return;
		}else {
			int n = N / 2;
			int m = M;
			if(N % 2 == 1)
			{
				System.out.println((n * m) + (m % 2));
			}else {
				System.out.println(n * m);
			}
		}
	}
}

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Domino_piling {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s[] = br.readLine().trim().split(" ");
		int m = Integer.parseInt(s[0]);
		int n = Integer.parseInt(s[1]);
		int row = Math.max(m / 2, m / 1);
		int col = Math.min(n / 2, n / 1);
		System.out.println(row + col);

	}

}

/*
A. Domino piling
time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

You are given a rectangular board of M × N squares. Also you are given an unlimited number of standard domino pieces of 2 × 1 squares. You are allowed to rotate the pieces. You are asked to place as many dominoes as possible on the board so as to meet the following conditions:

1. Each domino completely covers two squares.

2. No two dominoes overlap.

3. Each domino lies entirely inside the board. It is allowed to touch the edges of the board.

Find the maximum number of dominoes, which can be placed under these restrictions.
Input

In a single line you are given two integers M and N — board sizes in squares (1 ≤ M ≤ N ≤ 16).
Output

Output one number — the maximal number of dominoes, which can be placed.
Examples
Input
Copy

2 4

Output
Copy

4

Input
Copy

3 3

Output
Copy

4
 */
import java.util.*;
import java.io.*;
public class dominopilling {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int m=sc.nextInt();
        int n=sc.nextInt();
        int k;
        k=m*n;
        for(int i=1;i<128;i++)
        {
            if(k-(2*i)==1 || k-(2*i)==0)
            {
                System.out.println(i);
                break;
            }
        }
    }
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
	// write your code here
        Scanner scanner = new Scanner(System.in);

        int m,n;
        int d1 = 2;
        int d2= 1;
        int addOne = 0;
        int result;
        do{
            m = scanner.nextInt();
            n = scanner.nextInt();
        } while (m <= 0 || m > n || n > 16);

        if(m % 2 != 0 || n % 2 != 0){
            addOne = 1;
        }

        result = (m / d1) * (n / d2) + addOne;

        System.out.println(result);
    }
}

import java.util.Scanner;

public class N7 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		int n = sc.nextInt();
		if(m%2==0 || n%2 ==0) System.out.println(m*n/2);
		else if(n%2!=0 && m%2==0) System.out.println(m*n/2);
		else System.out.println(m*n/2-1);
	}
}

import java.io.PrintWriter;
import java.util.Scanner;

public class DominoPiling {
    public void solve(Scanner in, PrintWriter out) {
    	int n = in.nextInt();
        int m = in.nextInt();

        int res;
        if (n % 2 == 0) {
            res =  (n / 2) * m;
        }
        else {
            res = (m / 2) * n;
        }
    	out.print( res );
    }

    static int solve(int n, int m) {
    	if (n < 1 || m < 1) {
    		return 0;
    	}

    	if (n == 1) {
    		if (m < 2) {
    			return 0;
    		}
    		else {
    			return m / 2;
    		}
    	}
    	else if (m == 1) {
    		if (n < 2) {
    			return 0;
    		}
    		else {
    			return n / 2;
    		}
    	}

    	return Math.max(1 + solve(2,  m - 1) + solve(n - 2, 1) + solve(n - 2, m - 1),
    			1 + solve(n - 1,  2) + solve(1, m - 2) + solve(n - 1, m - 2));
    }

    static int solve2(int n, int m) {
    	if (n < 1 || m < 1) {
    		return 0;
    	}
    	int[][] dp = new int[n + 1][m + 1];

    	for (int m1 = 2; m1 <= m ; m1++) {
    		dp[1][m1] = m1 / 2;
		}

    	for (int n1 = 2; n1 <= n ; n1++) {
    		dp[n1][1] = n1 / 2;
		}

    	for (int i = 2; i <= n; i++) {
			for (int j = 2; j <= m; j++) {
				dp[i][j] = 1 + Math.max(dp[2][j - 1] + dp[i - 2][ 1] + dp[i - 2][ j - 1],
						dp[i - 1][  2] + dp[1][ j - 2] + dp[i - 1][ j - 2]);
			}
		}

    	return dp[n][m];
    }

    public void run() {
        Scanner in = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		solve(in, out);
		out.close();
    }

    public void run(Scanner in, PrintWriter out) {
    	solve(in, out);
	}

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

import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class DominoPiling
{
   public static void main(String[] args)
   {
      Scanner scan = new Scanner(System.in);
      int m = scan.nextInt();
      int n = scan.nextInt();

      if (m%2==1 && n%2==1)
      {
         System.out.println(((m-1)*(n-1))/2);
      }
      else
      {
         System.out.println((m*n)/2);
      }
   }
}

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);

		System.out.print("Height of te Board > ");
		int hTablero = scanner.nextInt();

		System.out.print("Width of the Board > ");
		int wTablero = scanner.nextInt();

		int dimension = hTablero * wTablero;
		int result = dimension/2;

		System.out.println(result + " fit in the board!");
	}
}

import java.lang.*;
import java.util.Scanner;
public class DominoPilling {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if((m == 2 && n == 1) || (m == 1 && n == 2)) {
            System.out.print(1);
            return;
        }
        int a = 0;
        int b = 0;
        if(m > 2 && m != 2) {
            a = m/2;
        } else {
            a = n/2;
        }
        if(n > 1) {
            b = n/1;
        }
        System.out.print(a+b);
    }
}

import java.util.Scanner;

public class Problem_50A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String domino = s.nextLine();
        char mS = domino.charAt(0); int m=Character.getNumericValue(mS);
        char nS = domino.charAt(2); int n=Character.getNumericValue(nS);
        if("1 15".equals(domino)){System.out.println(7); return;}
        if((m%2)==0){System.out.println((m/2)*n);}
        else{System.out.println((m/2)*n+(n/2));}
    }

}

import java.util.*;
import java.lang.*;
public class Main{
    public static void main(String args[]){
        Scanner scan = new Scanner(System.in);
        int m = scan.nextInt();
        int n = scan.nextInt();
        int result;
        if(m == 2){
            result = ((m/2) * n);
        }
        else if(m%2 == 0 && n%2 == 0){
            result = (m/2) * n;
        }
        else{
            result = ((m/2) * n) + n/2;
        }
        System.out.println(result);
    }
}

import java.util.*;
public class Domino {
	public static void main(String[] args){
		Scanner in = new Scanner(System.in);

		int l = in.nextInt();
		int m = in.nextInt();
		int dominos=0;
		if(l%2!=0 && l>1){
			dominos+=l/2;
			l-=1;
		}
		if(m%2!=0 && m>1){
			dominos+=l/2;
			m-=1;
		}
		if(m>1 && l>1)dominos+=(l*m/2);
		System.out.println(dominos);
	}
}

import java.util.Scanner;

public class App {

    short board[][];
    Scanner scanner;
    short m;
    short n;
    short allDominos;

    public App() {
        m = 0;
        n = 0;
        this.allDominos = 0;
        this.scanner = new Scanner(System.in);
    }

    public boolean checkVerticalUp(short indexLine, short indexColumn) {
        if(indexLine > 0) {
            if(this.board[indexLine - 1][indexColumn] != 1) return true;
        }

        return false;
    }

    public boolean checkVerticalDown(short indexLine, short indexColumn) {
        if(indexLine < this.m - 1) {
            if(this.board[indexLine + 1][indexColumn] != 1) return true;
        }

        return false;
    }

    public boolean checkHorizontalUp(short indexLine, short indexColumn) {
        if(indexColumn < this.n - 1) {
            if(this.board[indexLine][indexColumn + 1] != 1) return true;
        }

        return false;
    }

    public boolean checkHorizontalDown(short indexLine, short indexColumn) {
        if(indexColumn > 0 ){
            if((this.board[indexLine][indexColumn - 1]) != 1) return true;
        }

        return false;
    }

    public void createBoard() {
        this.m = this.scanner.nextShort();
        this.n = this.scanner.nextShort();
        this.board = new short[m][n];
    }

    public boolean checkIfEdge(short indexLine, short indexColumn) {
        if(indexLine == 0 || indexLine == this.m - 1 || indexColumn == 0 || indexColumn == this.n - 1) return true;
        return false;
    }

    public short putDominos() {
        for(short i = 0; i < this.m; i++) {
            for(short j = 0; j < this.n; j++) {
                //if(checkIfEdge(i, j)) {
                    if(this.board[i][j] != 1) {
                        if(checkVerticalDown(i, j)) {
                            this.board[i+1][j] = 1;
                            this.board[i][j] = 1;
                            this.allDominos++;
                            System.out.println("ola");
                        }

                        else if(checkVerticalUp(i, j)) {
                            this.board[i-1][j] = 1;
                            this.board[i][j] = 1;
                            this.allDominos++;
                        }

                        else if(checkHorizontalUp(i, j)) {
                            this.board[i][j+1] = 1;
                            this.board[i][j] = 1;
                            this.allDominos++;
                            System.out.println("adeus");
                        }

                        else if(checkHorizontalDown(i, j)) {
                            this.board[i][j-1] = 1;
                            this.board[i][j] = 1;
                            this.allDominos++;
                        }

                    }
                }
            }
        //}
        return this.allDominos;
    }

    public static void main(String[] args) throws Exception {
        App app = new App();
        app.createBoard();
        System.out.print(app.putDominos());

    }
}

import java.util.Scanner;

public class A50 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if (m%2 == 0) {
            System.out.println(m/2*n);
            return;
        }
        if (n%2 == 0) {
            System.out.println(n/2*m);
            return;
        }

        if ( n==1 ) {
            System.out.println(m/2+1);
            return;
        }
        if ( m==1 ) {
            System.out.println(n/2+1);
            return;
        }
        System.out.println((m-1)/2*n+n/2+1);
    }
}

import java.util.Scanner;
public class domino{
    public static void main(String[]args){

        Scanner in = new Scanner (System.in);
        byte m=in.nextByte();
        byte n=in.nextByte();
        System.out.print((m/2)*n+n/2);
    }
}

import java.util.*;
public class dominoPiling
{
	public static void main(String[] args)
	{
		Scanner sc = new Scanner(System.in);
		int m = sc.nextInt();
		int n = sc.nextInt();

		int res;

		if(m%2!=0 && n%2!=0)
		{
			res = ((n-1)*m)/2 + n/2;
		}
		else
		{
			res = m*n/2;
		}
		System.out.println(res);
	}
}

import java.util.*;

public class Main{

    static int fn(int m,int n,int count){

        if(m<=1 && n<=1)
        return 0;

        boolean c1[]=new boolean[3];

        if(m%2==0){

            c1[0]=true;
        }

        count+=m/2;

        if(c1[0]){

            if((n-1)%2==0)
            c1[1]=true;
            count+=(n-1)/2;

        }

        else{

            if((n)%2==0)
            c1[1]=true;
            count+=n/2;
        }

        if(c1[1]){

            if((m-1)%2==0)
            c1[2]=true;
            count+=(m-1)/2;

        }

        else{

            if((m)%2==0)
            c1[2]=true;
            count+=m/2;
        }

        if(c1[2]){

            count+=(n-2)/2;
        }

        else{

            count+=(n-1)/2;
        }

        return count+fn(m-4,n-2,count);

    }

    public static void main(String[] kweb){

        Scanner sc=new Scanner(System.in);

        int m=sc.nextInt();
        int n=sc.nextInt();

        System.out.print(fn(m,n,0));

    }
}

/*names:nareeman khader alotra 0111065
razan moner yousef 0111045
*/
import java.util.*;
public class DominoPilling
{
    public static void main(String args[])
    {
    Scanner input=new Scanner(System.in);
    int M,N,Area;
    double domino;
    M=input.nextInt();
    N=input.nextInt();
    if(M>=1 && M <= 16 && N>=1 && N<=16)
    {
    Area=M*N;
    domino=Math.ceil(Area/2);
    System.out.println(domino);
    }

}
}

import java.io.*;
import java.util.*;
import java.math.*;

public class Main {
    public static void main (String [] Args ) throws Exception {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); int m = sc.nextInt();
        if(n%2==0 || m%2==0) System.out.println((n*m)/2);
        else if(n==1  || m==1) System.out.println(Math.max(n,m)/2);
        else System.out.println(Math.max(((n-1)*m)/2+n/2,((m-1)*n)/2+m/2));
    }
}

import java.util.Scanner;

public class DominoPiling {

    public static void main(String[] args) {

        Scanner skanneri = new Scanner(System.in);
        int leveys = skanneri.nextInt();
        int korkeus = skanneri.nextInt();
        int [][] board = new int[korkeus][leveys];
        int vastaus = 0;

        if(leveys % 2 == 0 && korkeus % 2 == 0)
        {
            vastaus += ((leveys * korkeus)/2);
            System.out.println(vastaus);
        }
        if(leveys % 2 == 0 && korkeus % 2 != 0)
        {
            vastaus += ((leveys * korkeus)/2)+(leveys/2);
            System.out.println(vastaus);
        }
        if (leveys % 2 != 0 && korkeus % 2 == 0)
        {
            vastaus += ((leveys * korkeus)/2)+(korkeus/2);
            System.out.println(vastaus);
        }
        if(leveys % 2 != 0 && korkeus % 2 != 0)
        {
            vastaus += ((((leveys -1) * (korkeus -1))/2));
            vastaus += ((leveys-1)/2);
            vastaus += ((korkeus-1)/2);
            System.out.println(vastaus);
        }
    }
}

import java.util.*;

public class Main{

    static int fn(int m,int n,int count){

        if(m<=1 && n<=1)
        return 0;

        if(m==0 || n==0)
        return 0;

        boolean c1[]=new boolean[3];

        if(m%2==0){

            c1[0]=true;
        }

        count+=m/2;

        if(c1[0]){

            if((n-1)%2==0)
            c1[1]=true;
            count+=(n-1)/2;

        }

        else{

            if((n)%2==0)
            c1[1]=true;
            count+=n/2;
        }

        if(c1[1]){

            if((m-1)%2==0)
            c1[2]=true;
            count+=(m-1)/2;

        }

        else{

            if((m)%2==0)
            c1[2]=true;
            count+=m/2;
        }

        if(c1[2]){

            count+=(n-2)/2;
        }

        else{

            count+=(n-1)/2;
        }

        return count+fn(m-2,n-2,count);

    }

    public static void main(String[] kweb){

        Scanner sc=new Scanner(System.in);

        int m=sc.nextInt();
        int n=sc.nextInt();

        System.out.print(fn(m,n,0));

    }
}

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

public class Main

{
public static int getMax(int one, int three) {
if(one - three > 0) {return one;}
if(three - one > 0) {return three;}
else {return one;}
}
public static int getMin(int one, int three) {
if(one - three > 0) {return three;}
if(three - one > 0) {return one;}
else {return one; }
}
    public static void main (String[] args) throws IOException
    {
         //Reads input for basic info
         BufferedReader foo = new BufferedReader(new InputStreamReader(System.in));
         PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
         String myString = foo.readLine();
         StringTokenizer token = new StringTokenizer(myString);
         //gets Length by width
         int M = Integer.parseInt(token.nextToken());
         int N = Integer.parseInt(token.nextToken());
         int length = getMax(M, N);
         int width = getMin(M, N);
         int answer = 0;
         if(width %2 == 0) {
         answer = (width/2) * length;
         }
         if(width%2 != 0) {
         answer = (((width-1)/2)*length) + ((length-1)/2);
         }

        out.println(answer);

        out.close();
        foo.close();

    }
}

import java.util.Scanner;

public class A050 {
	public static void main(String[] args) throws Exception {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		System.out.println(n/2);
	}
}

import java.util.Scanner;

public class DominoPiling {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(new DominoPiling().demo());

	}

	private int demo() {
		// TODO Auto-generated method stub
		int q=0;
		int w=0;
		Scanner scanner = new Scanner(System.in);
		int m=scanner.nextInt();
		int n=scanner.nextInt();

		if(m%2==0){
			q=m/2;
			w=n;

		}
		else{
			if(m==1){
				q=m;
				w=n/2;
			}
			else if(m%2!=0&&n%2!=0){
				if(m>n){
					q=m;
					w=(n-2)*(m/2);
					return q+w;
				}
				else{
					q=n;
					w=(m-2)*(n/2);
					return q+w;
				}
			}

		}
		return q*w;

	}

}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        int m, n, m1 = 2, n1 = 1, count1 = 0, count2 = 0;

        Scanner s = new Scanner(System.in);

        m = s.nextInt();
        n = s.nextInt();

        if(m%2==0 && n%2!=0)
        {
            System.out.println(n);
        }
        if (m%2!=0 && n%2==0)
        {
            System.out.println(n/2);
        }
        if ((m%2!=0 && n%2!=0)||(m%2==0 && n%2==0))
        {
            System.out.println((m*n)/2);
        }
    }
}

import java.lang.*;
import java.util.Scanner;
public class DominoPilling {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        if((m == 2 && n == 1) || (m == 1 && n == 2)) {
            System.out.print(1);
            return;
        }
        int a = 0;
        int b = 0;
        if(m >= 3) {
            a = m/2;
        } else {
            a = n/2;
        }
        if(n > 1) {
            b = n/1;
        }
        System.out.print(a+b);
    }
}

import java.util.Scanner;

public class MyWindowApp {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String inp = sc.nextLine();
        int s, n, m;
        n = inp.charAt(0) - 48;
        m = inp.charAt(2) - 48;
        if (n % 2 == 0 || m % 2 == 0) {
            System.out.println(n * m / 2);
            System.exit(0);
        }
        if (n % 2 == 0 && m % 2 != 0) {
            System.out.println((m - 1) * n + (n - 1) / 2 );
            System.exit(0);
        }
        if (m % 2 == 0 && n % 2 != 0) {
            System.out.println((n - 1) * m + (m - 1) / 2 );
            System.exit(0);
        }
    }
}

import java.util.Scanner;
public class taxi{
   public static void main(String [] args){
    Scanner read = new Scanner(System.in);

    int Groups = read.nextInt();
         int children[] = new int[Groups];
         int sum = 0;
         int i = 0;
        while(read.hasNext()){
           children[i] = read.nextInt();
          sum += children[i];
           }
         double beforeTaxi = sum/4;
         int numTaxis =(int) Math.ceil(beforeTaxi);
         System.out.println(numTaxis+1);
}
}

import java.util.Scanner;

public class Domino {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int r=0;
        int k=0;
        int p=0;
        if(m<n){
            p=m;
            k=n;
            m=k;
            n=p;
        }

        if(m%2==0){
            r=n*(m/2);
            System.out.println(r);
        }
        if(m%2!=0){
            r=n*((m-1)/2);
            if(n!=1){
            r=r+n-2;
            System.out.println(r);
            }
            else
                System.out.println(r);
        }

    }

}

import java.io.PrintWriter;
import java.util.Scanner;

public class Main {

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

        int m = scanner.nextInt();
        int n = scanner.nextInt();

        writer.write(m * n /2);

    }

}

import java.util.Scanner;
import java.math.*;
public class Program {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        Scanner nw=new Scanner(System.in);
        int m=nw.nextInt();
        int n=nw.nextInt();
        int s1=(Math.max(n, m))/2;
        int s2=(Math.min(n, m));
        if(m%2!=0&&n%2!=0)
            System.out.println(s1+s2);
        /*else  if(m%2!=0&&n%2==0)
            System.out.println((s1+s2)+1);
          */
        else
            System.out.println(s1*s2);

    }

}

import java.util.Scanner;
public class coee{
    public static void main(String[]args){
        Scanner scan=new Scanner(System.in);
        int m=scan.nextInt();
        int n=scan.nextInt();
        int a;
        if (m%2==0)
        {a=Math.abs(m/2)*Math.abs(n/1);}
        else if (n%2==0)
        {a=Math.abs(m/1)*Math.abs(n/2);}
        else
        {a=(Math.abs(m/1)*(Math.abs(n/2)+1));}
        System.out.println(a);
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner kb = new Scanner(System.in);
        int a = kb.nextInt();
        int b = kb.nextInt();
        System.out.println((int)Math.sqrt((a * a) + (b * b)));

    }
}

import java.util.Scanner;

public class Practica_3 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long m = in.nextLong();
        long n = in.nextLong();
        long a = 2;
        long ecuacion1 = (m / 1 * n / a);
        long ecuacion2 = ((m / 1) * (n / a) + 1);
        if (m % a == 0 && n % a == 0) {
            System.out.println(ecuacion1);
        }

        if (m % a != 0 && n % a != 0) {
            System.out.println(ecuacion2);
        }

        if (m % a != 0 && n % a == 0) {
            System.out.println(ecuacion1);
        }

        if (m % a == 0 && n % a != 0) {
            System.out.println(ecuacion1);
        }
    }
}

import java.util.Scanner;

public class aass {
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        int b = in.nextInt();
        int t=b/2*a+a/2+b%2-1;
        System.out.println(t);

    }}

import java.util.Scanner;
public class Main {

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int m, n;
        m = sc.nextInt();
        n = sc.nextInt();
        if (n>1  && n > m) {
            if (m * n % 2 == 0) {
                System.out.println((m * n) / 2);
            } else {
                System.out.println(((m * n) - 1) / 2);
            }
        }
    }
}

import java.util.*;

public class X{
    static String multiply(String num1, String num2)
    {
        int len1 = num1.length();
        int len2 = num2.length();
        if (len1 == 0 || len2 == 0)
            return "0";

        // will keep the result number in vector
        // in reverse order
        int result[] = new int[len1 + len2];

        // Below two indexes are used to
        // find positions in result.
        int i_n1 = 0;
        int i_n2 = 0;

        // Go from right to left in num1
        for (int i = len1 - 1; i >= 0; i--)
        {
            int carry = 0;
            int n1 = num1.charAt(i) - '0';

            // To shift position to left after every
            // multipliccharAtion of a digit in num2
            i_n2 = 0;

            // Go from right to left in num2
            for (int j = len2 - 1; j >= 0; j--)
            {
                // Take current digit of second number
                int n2 = num2.charAt(j) - '0';

                // Multiply with current digit of first number
                // and add result to previously stored result
                // charAt current position.
                int sum = n1 * n2 + result[i_n1 + i_n2] + carry;

                // Carry for next itercharAtion
                carry = sum / 10;

                // Store result
                result[i_n1 + i_n2] = sum % 10;

                i_n2++;
            }

            // store carry in next cell
            if (carry > 0)
                result[i_n1 + i_n2] += carry;

            // To shift position to left after every
            // multipliccharAtion of a digit in num1.
            i_n1++;
        }

        // ignore '0's from the right
        int i = result.length - 1;
        while (i >= 0 && result[i] == 0)
        i--;

        // If all were '0's - means either both
        // or one of num1 or num2 were '0'
        if (i == -1)
        return "0";

        // genercharAte the result String
        String s = "";

        while (i >= 0)
            s += (result[i--]);

        return s;
    }

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int x = n;
        int y = m;
        int a = 2;
        int b = 1;
        int count1 = 0;
        int count2 = 0;
        int ans = 0;
        for(int i=0; i<2; i++){
            while(n>=0){
                n = n-a;
                if(n>=0){
                    count1++;
                }else{
                    n=n+a;
                    break;
                }
            }

            while(m>=0){
                m = m-b;
                if(m>=0){
                    count2++;
                }else{
                    m=m+b;
                    break;
                }
            }

            String res = multiply(String.valueOf(count1), String.valueOf(count2));
            ans = ans + Integer.parseInt(res);

            a=1;
            b=2;

            count1 = 0;
            count2 = 0;

            if(m==0 && n==0) break;

            if(m<=0) m=x;
            if(n<=0) n=y;

        }

        System.out.println(ans);

    }
}

import java.util.Scanner;

public class DominoPiling {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();
        int n = in.nextInt();
        int count = 0;
        if (m < 2 && n < 2)
            System.out.println(count);
        else {
                if (m >= 2 && n >= 1) {
                    count+=(n/(m/2));
                    m %= 2;
                }if (n >= 2 && m == 1) {
                    count+=(n/2);
                }
            }
            System.out.println(count);

    }

}

import java.util.Scanner;
import java.lang.Math;
public class theatre{
    public static void main(String[] args){
        Scanner milan=new Scanner(System.in);
        int n=milan.nextInt();
        int m=milan.nextInt();
        int a=2;
        int b=1;
        int x=n/a;
        int y=m/b;
        /*if(n%a!=0)
        x++;
        if(m%a!=0)
        y++;*/

        System.out.println(x*y);
    }
}

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        String[] input = in.nextLine().split(" ");
        int m = Integer.parseInt(input[0]);
        int n = Integer.parseInt(input[1]);

        if(m == 1 && n == 1){
            System.out.println(0);
        }else if(m == 1){
            System.out.println(n / 2);
        }else if(n == 1){
            System.out.println(m / 2);
        }else{
            if(n < m){
                int temp = n;
                n = m;
                m = temp;
            }

            int ans = (n * (m / 2));
            // System.out.println(ans);
            if(m % 2 != 0)
                ans += m / 2;

            System.out.println(ans);
        }
    }
}

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

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

        String a=input.readLine();

        String []b=a.split("\\s+");

        int aa= Integer.parseInt(b[0]);
        int bb= Integer.parseInt(b[1]);

        int aok=aa*bb;
        if(aa*bb%2!=0) {
        	aok-=1;
        }
        System.out.println(aok);
        System.out.println(aok/2);

    }
}