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 prime_factors(n):
    factors = []

    while n % 2 == 0:
        factors.append(2)
        n //= 2

    for i in range(3, int(math.sqrt(n)) + 1, 2):
        while n % i == 0:
            factors.append(i)
            n //= i

    if n > 2:
        factors.append(n)

    return factors


def convert_to_decimal(N, X):
    decimal = 0
    power = 0
    size = len(N)

    for i in range(size - 1, -1, -1):
        digit = N[i]
        value = int(digit) if digit.isdigit() else ord(digit) - ord('A') + 10
        decimal += value * X**power
        power += 1

    return decimal

def convert_from_decimal(N, X):
    baseX = ''

    while N > 0:
        remainder = N % X

        if remainder < 10:
            baseX = str(remainder) + baseX
        else:
            baseX = chr(ord('A') + remainder - 10) + baseX

        N //= X

    return baseX

def add_large_numbers(num1, num2):
    sum_str = ''
    carry = 0
    i, j = len(num1) - 1, len(num2) - 1

    while i >= 0 or j >= 0 or carry > 0:
        digit1 = int(num1[i]) if i >= 0 else 0
        digit2 = int(num2[j]) if j >= 0 else 0

        sum_digits = digit1 + digit2 + carry
        carry = sum_digits // 10
        sum_str = str(sum_digits % 10) + sum_str

        i -= 1
        j -= 1

    return sum_str

def multiply_large_number(num, multiplier):
    product_str = ''
    carry = 0

    for i in range(len(num) - 1, -1, -1):
        digit = int(num[i])
        product_digits = digit * multiplier + carry
        carry = product_digits // 10
        product_str = str(product_digits % 10) + product_str

    if carry > 0:
        product_str = str(carry) + product_str

    return product_str



def redirect_io():
    sys.stdin = open("input.txt", "r")  # Redirect standard input to read from 'input.txt'
    sys.stdout = open("output.txt", "w")  # Redirect standard output to write to 'output.txt'

def factors_n(n):
    factors = []
    for i in range(1, int(math.sqrt(n)) + 1):
        if n % i == 0:
            factors.append(i)
            if n // i != i:
                factors.append(n // i)
    return factors

def sum_n(n):
    return (n * (n + 1)) // 2

def solve_quadratic_equation(a, b, c):
    discriminant = b * b - 4 * a * c
    roots = []

    if discriminant > 0:
        roots.append((-b + math.sqrt(discriminant)) / (2 * a))
        roots.append((-b - math.sqrt(discriminant)) / (2 * a))
    elif discriminant == 0:
        roots.append(-b / (2 * a))

    return roots



def factorial(n, memo):
    if n <= 1:
        return 1

    if n in memo:
        return memo[n]

    result = ((n % MOD) * (factorial(n - 1, memo) % MOD)) % MOD
    memo[n] = result
    return result

def combination(n, r):
    if r > n:
        return 0

    memo = {}
    numerator = factorial(n, memo)
    denominator = factorial(r, memo) * factorial(n - r, memo)

    return numerator // denominator

def permutation(n, r):
    if r > n:
        return 0

    memo = {}
    numerator = factorial(n, memo)
    denominator = factorial(n - r, memo)

    return numerator // denominator

from math import *
import sys

INF = 998244353
MOD = 10**9 + 7


def solve(tc):
    n,m=map(int,input().split())
    print(max(floor(n/2 *m ),floor(m/2 *n )))


def main():


    t=1
    # t = int(input())
    for i in range(1, t + 1):
        solve(i)

if __name__ == "__main__":
    main()
