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).
# def bubble_sort(arr):
#     def swap(i, j):
#         arr[i], arr[j] = arr[j], arr[i]

#     n = len(arr)
#     swapped = True
    
#     x = -1
#     while swapped:
#         swapped = False
#         x = x + 1
#         for i in range(1, n-x):
#             if arr[i - 1] > arr[i]:
#                 swap(i - 1, i)
#                 swapped = True
#     return arr            
# arr = [6, 1, 5, 2, 4, 3]
# print(bubble_sort(arr))

# def selection_sort(arr):        
#     for i in range(len(arr)):
#         minimum = i
        
#         for j in range(i + 1, len(arr)):
#             # Выбор наименьшего значения
#             if arr[j] < arr[minimum]:
#                 minimum = j

#         # Помещаем это перед отсортированным концом массива
#         arr[minimum], arr[i] = arr[i], arr[minimum]
            
#     return arr
# arr = [6, 1, 5, 2, 4, 3]
# print(selection_sort(arr))

# def merge_sort(arr):
#     # Последнее разделение массива
#     if len(arr) <= 1:
#         return arr
#     mid = len(arr) // 2
#     # Выполняем merge_sort рекурсивно с двух сторон
#     left, right = merge_sort(arr[:mid]), merge_sort(arr[mid:])
# 	# Объединяем стороны вместе
#     return merge(left, right, arr.copy())
# def merge(left, right, merged):
# 	left_cursor, right_cursor = 0, 0
#     while left_cursor < len(left) and right_cursor < len(right):
#     	# Сортируем каждый и помещаем в результат
#         if left[left_cursor] <= right[right_cursor]:
#             merged[left_cursor+right_cursor]=left[left_cursor]
#             left_cursor += 1
#         else:
#             merged[left_cursor + right_cursor] = right[right_cursor]
#             right_cursor += 1    
#     for left_cursor in range(left_cursor, len(left)):
#         merged[left_cursor + right_cursor] = left[left_cursor]        
#     for right_cursor in range(right_cursor, len(right)):
#         merged[left_cursor + right_cursor] = right[right_cursor]
#     return merged

# arr = [6, 5, 3, 1, 8, 7, 2, 4]
# a = merge_sort(arr)
# print(merge(a)) 

# def factorial(a):
# 	if a == 0:
# 		return 1
# 	else:
# 		return a * factorial(a - 1)	
# a = int(input())
# print(factorial(a))

# def find(A, n, x):
# 	p = 1
# 	r = n
# 	while p <= r:
# 		q = (p + r)//2
# 		if A[q] == x:
# 			return q + 1
# 		elif A[q] != 0 and x < a[q]:
# 			r = q - 1
# 		else:
# 			r = q + 1
# 	return "NOT-FOUND"			
# A = []
# a = input().split()
# x = int(input())
# for i in range(len(a)):
# 	a[i] = int(a[i])
# 	A.append(a[i])
# n = len(A)
# print(find(A, n, x))

n = input().split()
for i in range(len(n)):
	n[i] = int(n[i])
print(n[0] * n[1] // 2)