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).
# Import helpful pages
from logging.handlers import WatchedFileHandler
import queue
from re import A
from sys import stdin, stdout
from collections import defaultdict
import copy
import math
import itertools
import heapq
import time
import bisect
from unicodedata import name
 
# Helper methods for execution
def get_int_dd():
  def def_value():
    return 0
  return defaultdict(def_value)
  
def get_counts(li):
  dd = get_int_dd()
  for i in li:
    dd[i] += 1
  return dd
 
 
def get_li_dd():
  def def_value():
    return []
  return defaultdict(def_value)
 
def get_set_dd():
  def def_value():
    return set()
  return defaultdict(def_value)
 
def get_index_map(li, w_offset=False):
  dd = get_li_dd()
  for i,n in enumerate(li):
    dd[n].append(i + (1 if w_offset else 0))
  return dd
 
def to_int_list(str):
  str.strip()
  return [int(i) for i in str.split()]
 
def to_char_list(str):
  str.strip()
  return [str[i] for i in range(len(str))]
 
# INPUT METHODS
 
def read_line():
  return stdin.readline().strip()
 
def read_int():
  return int(read_line())
 
def read_ints():
  return [int(i) for i in read_line().split()]
 
def read_str_list(read_n=True):
  n = read_int()
  return [read_line() for i in range(n)]
 
# OUTPUT METHODS
 
def write_out(value):
  stdout.write(str(value))
 
def write_line(value):
  stdout.write(str(value) + '\n')
 
COMMENTS_ON = True
 
def comment(value):
  if COMMENTS_ON:
    stdout.write(str(value) + '\n')
 
def execute_on_input(calc_ans, read_case=read_line, t=None, write_output=write_line):
  if not t:
    t = read_int()
  for eval in [calc_ans(read_case()) for input in range(t)]:
    write_output(eval)
 
def qA():
 
  def read():
    return read_ints()
   
  def calc(input):
    a = min(input)
    b = max(input)

    return (b // 2) * a + a // 2
    
  # Execute on each input line.
  execute_on_input(calc, read_case=read, t=1)

def qTemplate():
 
  def read():
    return read_int(), read_ints()
   
  def calc(input):
    return input
    
  # Execute on each input line.
  execute_on_input(calc, read_case=read)

# Call the methods
if __name__ == "__main__":
    qA()