from itertools import permutations, product

TARGET_X = 9
TARGET_Y = 10
TARGET_Z = 11


def pow2(exponent):
    assert 0 <= exponent < 63
    return 1 << exponent


def solve_box(x, y, z):
    return 3 * (pow2(x) + pow2(y) + pow2(z) - 4) * pow2(x + y + z - 1)


def parity(perm):
    inversions = 0
    for i in range(3):
        for j in range(i + 1, 3):
            if perm[i] > perm[j]:
                inversions += 1
    return 1 if inversions % 2 == 0 else -1


def signed_axis(axis, sign):
    return 2 * axis + (1 if sign < 0 else 0)


def orientations():
    result = []
    for perm in permutations(range(3)):
        for signs in product((1, -1), repeat=3):
            if parity(perm) * signs[0] * signs[1] * signs[2] != 1:
                continue
            face = [0] * 6
            for axis in range(3):
                face[2 * axis] = signed_axis(perm[axis], signs[axis])
                face[2 * axis + 1] = signed_axis(perm[axis], -signs[axis])
            result.append(tuple(face))
    return result


def brute_count(x, y, z):
    all_orientations = orientations()
    cells = [(i, j, k) for k in range(z) for j in range(y) for i in range(x)]
    grid = [-1] * (x * y * z)

    def index(i, j, k):
        return (k * y + j) * x + i

    def search(position):
        if position == len(cells):
            return 1

        i, j, k = cells[position]
        total = 0
        for o, current in enumerate(all_orientations):
            if i > 0:
                previous = all_orientations[grid[index(i - 1, j, k)]]
                if previous[0] != current[1]:
                    continue
            if j > 0:
                previous = all_orientations[grid[index(i, j - 1, k)]]
                if previous[2] != current[3]:
                    continue
            if k > 0:
                previous = all_orientations[grid[index(i, j, k - 1)]]
                if previous[4] != current[5]:
                    continue

            grid[index(i, j, k)] = o
            total += search(position + 1)
            grid[index(i, j, k)] = -1
        return total

    return search(0)


def run_checkpoints():
    assert len(orientations()) == 24
    assert solve_box(1, 1, 1) == 24
    assert solve_box(2, 3, 4) == 18432
    assert solve_box(1, 1, 2) == brute_count(1, 1, 2)
    assert solve_box(1, 2, 2) == brute_count(1, 2, 2)
    assert solve_box(2, 2, 1) == brute_count(2, 2, 1)
    assert solve_box(2, 2, 2) == brute_count(2, 2, 2)


def main():
    run_checkpoints()
    print(solve_box(TARGET_X, TARGET_Y, TARGET_Z))


if __name__ == "__main__":
    main()