Several ages ago Berland was a kingdom. The King of Berland adored math. That's why, when he first visited one of his many palaces, he first of all paid attention to the floor in one hall. The floor was tiled with hexagonal tiles.The hall also turned out hexagonal in its shape. The King walked along the perimeter of the hall and concluded that each of the six sides has a, b, c, a, b and c adjacent tiles, correspondingly.To better visualize the situation, look at the picture showing a similar hexagon for a = 2, b = 3 and c = 4.  According to the legend, as the King of Berland obtained the values a, b and c, he almost immediately calculated the total number of tiles on the hall floor. Can you do the same?

The first line contains three integers: a, b and c (2 ≤ a, b, c ≤ 1000).

Print a single number — the total number of tiles on the hall floor.

using System;
using System.Linq;

namespace Tiling.With.Hexagons
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();

            Console.WriteLine((input[0]*input[1]) + (input[1]*(input[2]-1)) + ((input[0]-1)*(input[2]-1)));
        }
    }
}

using System;
class Test {
    static void Main() {
        string [] str = Console.ReadLine().Split();
        int a = int.Parse(str[0]);
        int b = int.Parse(str[1]);
        int c = int.Parse(str[2]);
        if(b>c){
            int tmp = b;
            b = c;
            c = tmp;
        }
        long col = b+c-1;
        long ans = 0;
        int i;
        for(i=0 ; i<b-1 ; i++){
            ans += 2*(a+i);
        }
        ans += (col-(2*(b-1)))*(a+i);
        Console.WriteLine(ans);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace A14_08_12
{
    class Program
    {
        static void Main()
        {
            string  st = Console.ReadLine();
            string[] str = Regex.Split(st, " ");
            int[] a=new int[3];

            for (int i = 0; i < 3; i++)
                a[i] = int.Parse(str[i]);

            int t;
            if (a[0] < a[1])
            {
                t = a[0];
                a[0] = a[1];
                a[1] = t;
            }
            if (a[0] < a[2])
            {
                t = a[0];
                a[0] = a[2];
                a[2] = t;
            }
            int s = a[2];
            int l = a[2];
            for(int i=1; i<a[1]; i++)
            {
                l++;
                s+=l;
            }
            s *= 2;
            int k = (a[0] - a[1] - 1) * l;
            s += k;
            Console.WriteLine("{0}", s);
            //Console.ReadLine();

        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] str = Console.ReadLine().Split(' ');

            List<int> arr = new List<int>();
            arr.Add(int.Parse(str[0]));
            arr.Add(int.Parse(str[1]));
            arr.Add(int.Parse(str[2]));
            arr.Sort();

            int a = arr[0];
            int b = arr[1];
            int c = arr[2];

            long res = 0;

            int side = a;

            for (int i = 0; i < b; i++)
            {
                side = a + i;
                res += side;
            }

            res *= 2;

            res += side * (c-b-1);

            Console.WriteLine(res);

        }
    }
}

using System;

class Program
{
    static int Main()
    {
        int a, b, c;
        string []s = Console.ReadLine().Split(' ');
        a = Convert.ToInt32(s[0]);
        b = Convert.ToInt32(s[1]);
        c = Convert.ToInt32(s[2]);
        Console.WriteLine(a * b * c - (a - 1) * (b - 1) * (c - 1));
        return 0;
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

namespace AcmSolution4
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
#if !ACM_HOME
            Do();
#else
            var tmp = Console.In;
            Console.SetIn(new StreamReader("a.txt"));
            while (Console.In.Peek() > 0)
            {
                Do();
                WL(GetStr());
            }
            Console.In.Close();
            Console.SetIn(tmp);
#endif
            Console.ReadLine();
        }

        private static void Do()
        {
            int a,b,c;
            GetInts(out a, out b, out c);

            long ans = 0;
            long max = Math.Min(a + b - 1, a + c - 1);

            for (int i = 0; i < c - 1; i++)
                ans += Math.Min(a + i, max);

            for (int i = 0; i < b; i++)
                ans += Math.Min(a + i, max);

            WL(ans);
        }

        #region Utils
        private const double Epsilon = 0.00000001;

        private static string GetStr()
        {
            return Console.ReadLine();
        }

        private static string[] GetStrs()
        {
            return GetStr().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }

        private static string[] GetStrs(int cnt)
        {
            var s = new string[cnt];
            for (var i = 0; i < cnt; ++i)
                s[i] = GetStr();
            return s;
        }

        private static int GetInt()
        {
            return int.Parse(GetStr());
        }

        private static void GetInts(out int a, out int b)
        {
            var q = GetInts();
            a = q[0];
            b = q[1];
        }

        private static void GetInts(out int a, out int b, out int c)
        {
            var q = GetInts();
            a = q[0];
            b = q[1];
            c = q[2];
        }

        private static int[] GetInts()
        {
            var s = GetStrs();
            var a = new int[s.Length];
            for (var i = 0; i < s.Length; ++i)
                a[i] = int.Parse(s[i]);
            return a;
        }

        private static long GetLong()
        {
            return long.Parse(GetStr());
        }

        private static IEnumerable<long> GetLongs()
        {
            return GetStrs().Select(long.Parse);
        }

        private static void WriteDouble<T>(T d)
        {
            Console.WriteLine(string.Format("{0:0.000000000}", d).Replace(',', '.'));
        }

        private static void WL<T>(T s)
        {
            Console.WriteLine(s);
        }

        private static void W<T>(T s)
        {
            Console.Write(s);
        }

        private static void Assert(bool b)
        {
            if (!b) throw new Exception();
        }

        private static void Swap<T>(ref T a, ref T b)
        {
            var temp = a;
            a = b;
            b = temp;
        }

        #endregion
    }
}

using System;

class Program
{
    static void Main(string[] args)
    {
        string[] abc = Console.ReadLine().Split(' ');

        long a, b, c;
        a = long.Parse(abc[0]);
        b = long.Parse(abc[1]);
        c = long.Parse(abc[2]);

        long s = b * c + a * c + b * a - a - b - c + 1;

        Console.WriteLine(s);
    }
}

using System;
using System.Linq;
using System.Text.RegularExpressions;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] Num = Console.ReadLine().Split().Select(x => Convert.ToInt32(x)).ToArray();
            Console.WriteLine((Num[1] * Num[2]) + ((Num[0] - 1) * (Num[1] + Num[2] - 1)));
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Ejercicio3
{
    class Program
    {
        static void Main(string[] args)
        {
            int a;
            int b;
            int c;
            string input;
            string[] inputElements;
            int result;

            input = Console.ReadLine();
            inputElements = input.Split(' ');

            a = (Convert.ToInt32(inputElements[0]));
            b = (Convert.ToInt32(inputElements[1]));
            c = (Convert.ToInt32(inputElements[2]));

            if (a >= 2 && b >= 2 && c >= 2 && a <= 1000 && b <= 1000 && c <= 1000)
            {
                result = ((a * b) + (b * c) + (c * a)) - (a + b + c) + 1;
                Console.WriteLine(result);
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Diagnostics;
using System.IO;

namespace Solution
{
    class Solution
    {
        public void Solve()
        {
            var ss = Console.ReadLine().Split(' ');
            var list = new int[3];
            for (int i = 0; i < 3; i++)
                list[i] = int.Parse(ss[i]);

            int res = 0;
            int h = list[1] + list[2] - 1;
            int max = Math.Max(list[1], list[2]);
            int min = Math.Min(list[1], list[2]);
            int d = list[0];
            for (int i = 0;i<h;i++)
            {
                res += d;
                if (i < min-1)
                    d++;
                if (i >= max-1)
                    d--;
            }
            Console.WriteLine(res);

        }

#if !DEBUG
    static void Main(string[] args)
    {
        new Solution().Solve();
    }
#endif
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] inp = Console.ReadLine().Split(' ');
            Int64[] n = new long[3];

            List<Int64> nn = new List<long>();

            for (int i = 0; i < 3; i++)
                nn.Add( Convert.ToInt64(inp[i]));

            nn.Sort();
            int k = 0;
            foreach (Int64 ii in nn)
                n[k++] = ii;

            Int64 sum = 0;

            while (n[0] != 1)
            {
                sum += n.Sum() * 2 - 6;
                n[0]--;
                n[1]--;
                n[2]--;
            }

            sum += n[1] * n[2];

            Console.WriteLine(sum);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;

public class taskA
{
    static void Main(string[] args)
    {
        string inp = Console.ReadLine();

        string[] spl = inp.Split(' ');

        int a = int.Parse(spl[0]);
        int b = int.Parse(spl[1]);
        int c = int.Parse(spl[2]);

        int res = 0;

        while (Math.Min(Math.Min(a, b), c) > 1)
        {
            int o = 2 * (a + b + c) - 6;

            a--;
            b--;
            c--;

            res += o;
        }

        res += a * b * c;

        Console.WriteLine(res);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace capp
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] data = Array.ConvertAll(Console.ReadLine().Split(' '), x => long.Parse(x));
            long a = data[0];
            long b = data[1];
            long c = data[2];
            long s = 0;
            while (a != 1 && b != 1 && c != 1)
                s += (a-- + b-- + c--) * 2 - 6;
            s += a * b * c;
            Console.WriteLine(s);

        }
    }

}

//

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Threading;
using System.Diagnostics;
using System.Globalization;
using System.Text.RegularExpressions;
using System.Linq;

namespace sar_cs
{
    static class Helpers
    {
        public static string Join<T>(this IEnumerable<T> objs, string sep)
        {
            var sb = new StringBuilder();
            foreach (var s in objs) { if (sb.Length != 0) sb.Append(sep); sb.Append(s); }
            return sb.ToString();
        }

        public static string AsString(this double a, int digits)
        {
            return a.ToString("F" + digits, CultureInfo.InvariantCulture);
        }

        public static Stopwatch SW = Stopwatch.StartNew();
    }

    public class Program
    {
        #region Helpers

        public class Parser
        {
            const int BufSize = 8000;
            TextReader s;
            char[] buf = new char[BufSize];
            int bufPos;
            int bufDataSize;
            bool eos;   // eos read to buffer
            int lastChar = -2;
            int nextChar = -2;
            StringBuilder sb = new StringBuilder();

            void FillBuf()
            {
                if (eos) return;
                bufDataSize = s.Read(buf, 0, BufSize);
                if (bufDataSize == 0) eos = true;
                bufPos = 0;
            }

            int Read()
            {
                if (nextChar != -2)
                {
                    lastChar = nextChar;
                    nextChar = -2;
                }
                else
                {
                    if (bufPos == bufDataSize) FillBuf();
                    if (eos) lastChar = -1;
                    else lastChar = buf[bufPos++];
                }
                return lastChar;
            }

            void Back()
            {
                if (lastChar == -2) throw new Exception();  // no chars were ever read
                nextChar = lastChar;
            }

            public Parser()
            {
                s = Console.In;
            }

            public int ReadInt()
            {
                int res = 0;
                int sign = -1;
                int c;
                do { c = Read(); } while (c >= 0 && char.IsWhiteSpace((char)c));
                if (c == '-') { sign = 1; c = Read(); }
                int len = 0;
                while (c >= 0 && !char.IsWhiteSpace((char)c))
                {
                    if ((uint)(c -= 48) >= 10) throw new FormatException();
                    len++;
                    res = checked(res * 10 - c);
                    c = Read();
                }
                if (len == 0) throw new FormatException();
                Back();
                return checked(res * sign);
            }

            public long ReadLong()
            {
                long res = 0;
                int sign = -1;
                int c;
                do { c = Read(); } while (c >= 0 && char.IsWhiteSpace((char)c));
                if (c == '-')
                {
                    sign = 1;
                    c = Read();
                }
                int len = 0;

                while (c >= 0 && !char.IsWhiteSpace((char)c))
                {
                    if ((uint)(c -= 48) >= 10) throw new FormatException();
                    len++;
                    res = checked(res * 10 - c);
                    c = Read();
                }
                if (len == 0) throw new FormatException();
                Back();
                return checked(res * sign);
            }

            public int ReadLnInt()
            {
                int res = ReadInt(); ReadLine(); return res;
            }

            public long ReadLnLong()
            {
                long res = ReadLong(); ReadLine(); return res;
            }

            public double ReadDouble()
            {
                int c;
                do { c = Read(); } while (c >= 0 && char.IsWhiteSpace((char)c));

                int sign = 1;
                if (c == '-') { sign = -1; c = Read(); }

                sb.Length = 0;
                while (c >= 0 && !char.IsWhiteSpace((char)c))
                {
                    sb.Append((char)c); c = Read();
                }

                Back();
                var res = double.Parse(sb.ToString(), CultureInfo.InvariantCulture);
                return res * sign;
            }

            public string ReadLine()
            {
                int c = Read();
                sb.Length = 0;
                while (c != -1 && c != 13 && c != 10)
                {
                    sb.Append((char)c); c = Read();
                }
                if (c == 13) { c = Read(); if (c != 10) Back(); }
                return sb.ToString();
            }

            public bool SeekEOF
            {
                get
                {
                L0:
                    int c = Read();
                    if (c == -1) return true;
                    if (char.IsWhiteSpace((char)c)) goto L0;
                    Back();
                    return false;
                }
            }

            public int[] ReadIntArr(int n)
            {
                var a = new int[n]; for (int i = 0; i < n; i++) a[i] = ReadInt(); return a;
            }

            public long[] ReadLongArr(int n)
            {
                var a = new long[n]; for (int i = 0; i < n; i++) a[i] = ReadLong(); return a;
            }
        }

        static void pe() { Console.WriteLine("???"); Environment.Exit(0); }
        static void re() { Environment.Exit(55); }
        static void Swap<T>(ref T a, ref T b) { T t = a; a = b; b = t; }
        static int Sqr(int a) { return a * a; }
        static long SqrL(int a) { return (long)a * a; }
        static long Sqr(long a) { return a * a; }
        static double Sqr(double a) { return a * a; }

        static StringBuilder sb = new StringBuilder();
        static Random rand = new Random(5);

        #endregion Helpers

        static void Main(string[] args)
        {
            checked
            {
                //Console.SetIn(File.OpenText("_input"));
                var parser = new Parser();
                while (!parser.SeekEOF)
                {
                    long a = parser.ReadInt();
                    long b = parser.ReadInt();
                    long c = parser.ReadInt();
                    long res = c * b + (b + c - 1) * (a - 1);

                    Console.WriteLine(res);
                }
            }
        }

        //static void Main(string[] args)
        //{
        //    new Thread(Main2, 50 << 20).Start();
        //}
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace canada1
{
    class Program
    {
        static void Main(string[] args)
        {

            string input = "";
            string[] inputElements = new string[3];
            input = Console.ReadLine();
            inputElements = input.Split(' ');

            int a = Convert.ToInt32(inputElements[0]);
            int b = Convert.ToInt32(inputElements[1]);
            int c = Convert.ToInt32(inputElements[2]);

            int first = (a * b) + (b * c) + (c * a);
            int second = a + b + c;

            Console.WriteLine(first - second + 1);
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Threading;

namespace CodeForces {
    struct Node {
        public int X, Y, D;
        public Node(int x,int y, int d) {
            X = x;
            Y = y;
            D = d;
        }
    }

    class Pair : IComparable<Pair> {
        public int Vertex, Danger;
        public Pair(int f, int s) {
            Vertex = f;
            Danger = s;
        }

        public int CompareTo(Pair other) {
            return Vertex.CompareTo(Danger);
        }
    }

    class Desc : IComparer<int> {
        public int Compare(int x, int y) {
            return y.CompareTo(x);
        }
    }

    class Cf {
        static TextReader input;
        static void Main(string[] args) {
#if TESTS
            Stopwatch sw = new Stopwatch();
            sw.Start();
            input = new StreamReader("input.txt");
#else
            input = Console.In;
#endif
            Solve();
#if TESTS
            Console.WriteLine();
            Console.WriteLine("Milliseconds: {0}", sw.ElapsedMilliseconds);
            Console.ReadLine();
#endif
        }

        const int MOD = 1000000007;
        static int n, m;
        static void Solve() {
            int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            if (a == 1) {
                Console.WriteLine(b * c);
                return;
            }
            if (b == 1) {
                Console.WriteLine(a * c);
                return;
            }
            if (c == 1) {
                Console.WriteLine(b * a);
                return;
            }
            int res = (b + a-1) * (c + a-1);
            int sum = 0;
            for (int i = 1; i < a; i++) {
                sum += i;
            }
            Console.WriteLine(res - 2 * sum);
        }

        static int[] _bitcounts;
        static void InitializeBitcounts() {
            _bitcounts = new int[65536];
            int position1 = -1;
            int position2 = -1;
            for (int i = 1; i < 65536; i++, position1++) {
                if (position1 == position2) {
                    position1 = 0;
                    position2 = i;
                }
                _bitcounts[i] = _bitcounts[position1] + 1;
            }
        }

        static int Bitcount(int value) {
            return _bitcounts[value & 65535] + _bitcounts[(value >> 16)];
        }

        static int First(int mask) {
            for (int i = 0; i < 32; i++) {
                if ((mask & (1 << i)) > 0)
                    return i;
            }
            return -1;
        }

        #region math
        static long gcd(long a, long b) {
            return b != 0 ? gcd(b, a % b) : a;
        }

        static long lcm(long a, long b) {
            return a / gcd(a, b) * b;
        }

        //static int SquaredDistanceBetweenSegments(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
        //    return Math.Min(Math.Min(SquaredDistanceToSegment(x1, y1, xx1, yy1, xx2, yy2), SquaredDistanceToSegment(x2, y2, xx1, yy1, xx2, yy2)),
        //        Math.Min(SquaredDistanceToSegment(xx1, yy1, x1, y1, x2, y2), SquaredDistanceToSegment(xx2, yy2, x1, y1, x2, y2)));
        //}

        //static int SquaredDistanceToSegment(int x, int y, int x1, int y1, int x2, int y2) {
        //    int result = Math.Min(SquaredDistance(x, y, x1, y1), SquaredDistance(x, y, x2, y2));
        //    if (x1 == x2 && y1 <= y && y <= y2)
        //        result = (x - x1) * (x - x1);
        //    else if (y1 == y2 && x1 <= x && x <= x2)
        //        result = (y - y1) * (y - y1);
        //    return result;
        //}

        static long SquaredDistance(long ax, long ay, long bx, long by) {
            return (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
        }
        #endregion

        #region read helpers
        static int nextPositive() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        static int nextInt() {
            int t = input.Read();
            while ((t < '0' || t > '9') && t != '-') t = input.Read();
            int sign = 1;
            if (t == '-') {
                sign = -1;
                t = input.Read();
            }
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x * sign;
        }

        static long nextLong() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            long x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        public static List<int> ReadIntList() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToList();
        }

        public static int[] ReadIntArray() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        }

        public static double[] ReadDoubleArray() {
            return input.ReadLine().Split(' ').Select(x => double.Parse(x)).ToArray();
        }

        public static long[] ReadLongArray() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        }

        public static List<long> ReadLongList() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToList();
        }

        public static string ReadLine() {
            return input.ReadLine();
        }

        public static int ReadInt() {
            return int.Parse(input.ReadLine());
        }

        public static long ReadLong() {
            return long.Parse(input.ReadLine());
        }
#endregion
    }

    public class SegmentTree {
        private int[] a, t;
        private int n;
        public SegmentTree(int[] a) {
            n = a.Length;
            this.a = a;
            t = new int[n << 2];
            buildSegmentTree(0, n - 1, 1);
        }

        private void buildSegmentTree(int l, int r, int v) {
            if (l == r)
                t[v] = a[l];
            else {
                int m = (l + r) >> 1;
                int vl = v << 1;
                int vr = (v << 1) | 1;
                buildSegmentTree(l, m, vl);
                buildSegmentTree(m + 1, r, vr);
                t[v] = t[vl] + t[vr];
            }
        }

        public int QuerySegmentTree(int l, int r) {
            return querySegmentTree(1, l, r, 0, n - 1);
        }

        public void Update(int v, int tl, int tr, int pos, int new_val) {
            if (tl == tr)
                t[v] = new_val;
            else {
                int tm = (tl + tr) / 2;
                if (pos <= tm)
                    Update(v << 1, tl, tm, pos, new_val);
                else
                    Update(v << 1 + 1, tm + 1, tr, pos, new_val);
                t[v] = t[v << 1] + t[v << 1 + 1];
            }
        }

        private int querySegmentTree(int v, int l, int r, int tl, int tr) {
            if (l > r)
                return 0;
            if (l == tl && r == tr)
                return t[v];
            int m = (tl + tr) >> 1;
            return querySegmentTree(v << 1, l, Math.Min(r, m), tl, m) + querySegmentTree((v << 1) | 1, Math.Max(l, m + 1), r, m + 1, tr);
        }
    }
    class Graph : List<List<int>> {
        public Graph(int num): base(num) {
            for (int i = 0; i < num; i++) {
                this.Add(new List<int>());
            }
        }
    }
    class Heap<T> : IEnumerable<T> {
        List<T> items = new List<T>();
        IComparer<T> comparer;
        public Heap(IComparer<T> comparer) {
            this.comparer = comparer;
        }
        public Heap() {
            comparer = Comparer<T>.Default;
        }

        public void Add(T item) {
            items.Add(item);
            MoveUp(Count - 1);
        }

        public T Extract() {
            CheckHeap();
            T item = items[0];
            items.Swap(0, Count - 1);
            items.RemoveAt(Count - 1);
            MoveDown(0);
            return item;
        }

        public int Count {
            get {
                return items.Count;
            }
        }

        public bool IsEmpty {
            get {
                return items.Count == 0;
            }
        }

        public T Top {
            get {
                CheckHeap();
                return items[0];
            }
        }

        void CheckHeap() {
            if (items.Count == 0)
                throw new ArgumentException("Heap is empty");
        }

        void MoveDown(int v) {
            int left = 2 * v + 1;
            int right = 2 * v + 2;
            if (left >= Count)
                return;
            if (right >= Count) {
                if (comparer.Compare(items[v], items[left]) < 0) {
                    items.Swap(v, left);
                }
                return;
            }
            int max = comparer.Compare(items[left], items[right]) < 0 ? right : left;
            if (comparer.Compare(items[v], items[max]) < 0) {
                items.Swap(v, max);
                MoveDown(max);
            }
        }

        void MoveUp(int v) {
            int parent = (v - 1) / 2;
            if (comparer.Compare(items[parent], items[v]) < 0) {
                items.Swap(v, parent);
                MoveUp(parent);
            }
        }

        public IEnumerator<T> GetEnumerator() {
            return items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            throw new NotImplementedException();
        }
    }
    public static class Extensions {
        public static void Swap<T>(this IList<T> arr, int i, int j) {
            T temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        public static int Max(this int a, int b) {
            return Math.Max(a, b);
        }

        public static int Min(this int a, int b) {
            return Math.Min(a, b);
        }

        public static void Fill(this int[] array, int val) {
            for (int i = 0; i < array.Length; i++) {
                array[i] = val;
            }
        }

        public static int ToInt(this string s) {
            return int.Parse(s);
        }

        public static void Print<T>(this IEnumerable<T> arr) {
            foreach (T t in arr)
                Console.Write("{0} ", t);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace Codeforces
{
    class A
    {
        private static ThreadStart s_threadStart = new A().Go;
        private static bool s_time = false;

        private void Go()
        {
            int a = GetInt();
            int b = GetInt();
            int c = GetInt();

            Wl(a * b + b * c + c * a - a - b - c + 1);
        }

        #region Template

        public static void Main(string[] args)
        {
            System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch();
            Thread main = new Thread(new ThreadStart(s_threadStart), 512 * 1024 * 1024);
            timer.Start();
            main.Start();
            main.Join();
            timer.Stop();
            if (s_time)
                Wl(timer.ElapsedMilliseconds);
        }

        private static IEnumerator<string> ioEnum;
        private static string GetString()
        {
            while (ioEnum == null || !ioEnum.MoveNext())
            {
                ioEnum = Console.ReadLine().Split().AsEnumerable().GetEnumerator();
            }

            return ioEnum.Current;
        }

        private static int GetInt()
        {
            return int.Parse(GetString());
        }

        private static long GetLong()
        {
            return long.Parse(GetString());
        }

        private static double GetDouble()
        {
            return double.Parse(GetString());
        }

        private static List<int> GetIntArr(int n)
        {
            List<int> ret = new List<int>(n);
            for (int i = 0; i < n; i++)
            {
                ret.Add(GetInt());
            }
            return ret;
        }

        private static void Wl<T>(T o)
        {
            if (o is double)
            {
                Wld((o as double?).Value, "");
            }
            else if (o is float)
            {
                Wld((o as float?).Value, "");
            }
            else
                Console.WriteLine(o.ToString());
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            Wl(string.Join(" ", enumerable.Select(e => e.ToString()).ToArray()));
        }

        private static void Wld(double d, string format)
        {
            Wl(d.ToString(format, CultureInfo.InvariantCulture));
        }

        public struct Tuple<T, K> : IComparable<Tuple<T, K>>
            where T : IComparable<T>
            where K : IComparable<K>
        {
            public T Item1;
            public K Item2;

            public Tuple(T t, K k)
            {
                Item1 = t;
                Item2 = k;
            }

            public override bool Equals(object obj)
            {
                var o = (Tuple<T, K>)obj;
                return o.Item1.Equals(Item1) && o.Item2.Equals(Item2);
            }

            public override int GetHashCode()
            {
                return Item1.GetHashCode() ^ Item2.GetHashCode();
            }

            public override string ToString()
            {
                return "(" + Item1 + " " + Item2 + ")";
            }

            #region IComparable<Tuple<T,K>> Members

            public int CompareTo(Tuple<T, K> other)
            {
                int ret = Item1.CompareTo(other.Item1);
                if (ret != 0) return ret;
                return Item2.CompareTo(other.Item2);
            }

            #endregion
        }

        #endregion
    }
}

using System; using System.Linq;

class P {
  static void Main() {
    var s = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
    var a = s[0]; var b = s[1]; var c = s[2];
    var res = b*c + (a-1)*(b+c-1);
    Console.Write(res);
  }
}

using System;
using System.IO;
using System.Text;

namespace Tiling_with_Hexagons
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            int a = Next();
            int b = Next();
            int c = Next();

            a += c - 1;
            b += c - 1;
            int t = c*(c - 1);

            writer.WriteLine(a*b - t);
            writer.Flush();
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace _216A
{
    class Program
    {
        static void Main()
        {
            String[] k = Console.ReadLine().Split(' ');
            int a = Convert.ToInt32(k[0]);
            int b = Convert.ToInt32(k[1]);
            int c = Convert.ToInt32(k[2]);
            int d = 0;
            if (a > b && a>c)
            {
                d = c;
                c = a;
                a = d;
                if (a > b)
                {
                    d = b;
                    b = a;
                    a = d;
                }
            }
            else if (a > b && a <= c)
            {
                d = b;
                b = a;
                a = d;
            }
            else if (a < b && a < c)
            {
                if (b > c)
                {
                    d = b;
                    b = c;
                    c = d;
                }
            }
            Console.Write(calculate(a, b, c));
        }
        static int calculate(int a, int b, int c)
        {
            int output = b * (2 * a + (b - 1)) + (c - b - 1) * (a + b - 1);

            return output;
        }
    }
}

using System;

namespace AllProblems
{
    class Program
    {
        static void Main(string[] args)
        {
            _216A_TilingWithHexagon.Run();
        }
    }

    class _216A_TilingWithHexagon
    {
        public static void Run()
        {
            var l = Console.ReadLine().Trim().Split(' ');
            var a = short.Parse(l[0]);
            var b = short.Parse(l[1]);
            var c = short.Parse(l[2]);

            var sum = 0;
            var aa = a;
            for (short i = 0; i < b; i++)
            {
                sum += aa;
                if (i+1 < c && i+1 < b) ++aa;
            }

            for (short i = 0; i < c-b; i++)
                sum += aa;

            for (var i = aa - 1; i >= a; i--)
                sum += i;

            Console.WriteLine(sum);
            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;

namespace MakeCalendar
{
    public static class MainClass
    {

        static int ReadIntLine()
        {
            return int.Parse(Console.ReadLine());
        }

        static void ReadInt(ref int a)
        {
            a = ReadIntArrayLine()[0];
        }

        static void ReadInts(ref int a, ref int b)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1];
        }

        static void ReadInts(ref int a, ref int b, ref int c)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2];
        }

        static void ReadInts(ref int a, ref int b, ref int c, ref int d)
        {
            var x = ReadIntArrayLine();
            a = x[0]; b = x[1]; c = x[2]; d = x[3];
        }

        static int[] ReadIntArrayLine()
        {
            char[] sep = { ' ' };
            return Console.ReadLine().Split(sep, StringSplitOptions.RemoveEmptyEntries).Select(x => int.Parse(x)).ToArray();
        }

        static void PrintLn(object obj)
        {
            Console.WriteLine(obj.ToString());
        }

        public static string Reverse(string s)
        {
            char[] charArray = s.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }

        public static void PrintLnCollection<T>(IEnumerable<T> col)
        {
            PrintLn(string.Join(" ",col));
        }

        public static string ReadLine()
        {
            return Console.ReadLine();
        }

        public static string MySubstring(this string str, int start, int finish)
        {
            return str.Substring(start, finish - start + 1);
        }

        public static bool IsInRange(this int a, int lb, int ub)
        {
            return (a>=lb) && (a<=ub);
        }

//----------------------------------------------------------------------------

        static void Main(string[] args)
        {
            int a = 0, b = 0, c = 0;

            ReadInts(ref a, ref b, ref c);

            PrintLn((b+a-1)*(c+a-1)-a*(a-1));
        }

    }
}

using System;
using System.Linq;

namespace Tiling.With.Hexagons
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();

            Console.WriteLine((input[0]*input[1]) + (input[1]*(input[2]-1)) + (input[2]-1));
        }
    }
}

using System;
using System.Linq;

namespace Tiling.With.Hexagons
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();

            Console.WriteLine((2*input[0])+ (2 * input[1])+ (2 * input[2]));
        }
    }
}

using System;
class Test {
    static void Main() {
        string [] str = Console.ReadLine().Split();
        long a = Int64.Parse(str[0]);
        long b = Int64.Parse(str[1]);
        long c = Int64.Parse(str[2]);
        long col = b+c-1;
        long ans = 0;
        int i;
        for( i=0 ; i<b ; i++){
            ans += a+i;
        }
        ans *= 2;
        if(b==c){
            ans -= a+i-1;
        }else{
            ans += (a+i)*Convert.ToInt64(Math.Abs(col-2*b));
        }
        Console.WriteLine(ans);
    }
}

using System;
class Test {
    static void Main() {
        string [] str = Console.ReadLine().Split();
        long a = Int64.Parse(str[0]);
        long b = Int64.Parse(str[1]);
        long c = Int64.Parse(str[2]);
        long col = b+c-1;
        long ans = 0;
        long i;
        for(i=0 ; i<col/2 ; i++){
            ans += (a+i)*2;
        }
        if(col%2!=0){
            ans += a+i;
        }
        Console.WriteLine(ans);
    }
}

using System;
class Test {
    static void Main() {
        string [] str = Console.ReadLine().Split();
        long a = Int64.Parse(str[0]);
        long b = Int64.Parse(str[1]);
        long c = Int64.Parse(str[2]);
        long col = b+c-1;
        long ans = 0;
        int i;
        for(i=0 ; i<col/2 ; i++){
            ans += (a+i)*2;
        }
        if(col%2!=0){
            ans += a+i;
        }
        Console.WriteLine(ans);
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;

namespace AcmSolution4
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
#if !ACM_HOME
            Do();
#else
            var tmp = Console.In;
            Console.SetIn(new StreamReader("a.txt"));
            while (Console.In.Peek() > 0)
            {
                Do();
                WL(GetStr());
            }
            Console.In.Close();
            Console.SetIn(tmp);
#endif
            Console.ReadLine();
        }

        private static void Do()
        {
            int a,b,c;
            GetInts(out a, out b, out c);

            long ans = 0;
            for (int i = 0; i < c - 1; i++)
                ans += a + i;

            for (int i = 0; i < b; i++)
                ans += a + i;

            WL(ans);
        }

        #region Utils
        private const double Epsilon = 0.00000001;

        private static string GetStr()
        {
            return Console.ReadLine();
        }

        private static string[] GetStrs()
        {
            return GetStr().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }

        private static string[] GetStrs(int cnt)
        {
            var s = new string[cnt];
            for (var i = 0; i < cnt; ++i)
                s[i] = GetStr();
            return s;
        }

        private static int GetInt()
        {
            return int.Parse(GetStr());
        }

        private static void GetInts(out int a, out int b)
        {
            var q = GetInts();
            a = q[0];
            b = q[1];
        }

        private static void GetInts(out int a, out int b, out int c)
        {
            var q = GetInts();
            a = q[0];
            b = q[1];
            c = q[2];
        }

        private static int[] GetInts()
        {
            var s = GetStrs();
            var a = new int[s.Length];
            for (var i = 0; i < s.Length; ++i)
                a[i] = int.Parse(s[i]);
            return a;
        }

        private static long GetLong()
        {
            return long.Parse(GetStr());
        }

        private static IEnumerable<long> GetLongs()
        {
            return GetStrs().Select(long.Parse);
        }

        private static void WriteDouble<T>(T d)
        {
            Console.WriteLine(string.Format("{0:0.000000000}", d).Replace(',', '.'));
        }

        private static void WL<T>(T s)
        {
            Console.WriteLine(s);
        }

        private static void W<T>(T s)
        {
            Console.Write(s);
        }

        private static void Assert(bool b)
        {
            if (!b) throw new Exception();
        }

        private static void Swap<T>(ref T a, ref T b)
        {
            var temp = a;
            a = b;
            b = temp;
        }

        #endregion
    }
}

using System;

class Program
{
    static void Main(string[] args)
    {
        string[] abc = Console.ReadLine().Split(' ');

        long a, b, c;
        a = long.Parse(abc[0]);
        b = long.Parse(abc[1]);
        c = long.Parse(abc[2]);

        long s = (a + b + c) * 2;
        Console.WriteLine(s);
    }
}

using System;

class Program
{
    static long NOD(long m, long n)
    {
        long nod = 0;
        for (long i = 1; i < (n * m + 1); i++)
        {
            if (m % i == 0 && n % i == 0)
            {
                nod = i;
            }
        }
        return nod;
    }

    static void Main(string[] args)
    {
        string[] abc = Console.ReadLine().Split(' ');

        long a, b;
        a = long.Parse(abc[0]);
        b = long.Parse(abc[1]);
        long c = 6;

        long max = (long)Math.Max(a, b);

        long nushnie = 6 - max + 1;

        long nod = NOD(nushnie, c);

        Console.WriteLine(nushnie / nod + "/" + c / nod);
        //Console.ReadLine();

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace canada1
{
    class Program
    {
        static void Main(string[] args)
        {

            string input = "";
            string[] inputElements = new string[3];
            input = Console.ReadLine();
            inputElements = input.Split(' ');

            int a = Convert.ToInt32(inputElements[0]);
            int b = Convert.ToInt32(inputElements[1]);
            int c = Convert.ToInt32(inputElements[2]);

            Console.WriteLine((a + c) * b);

        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Threading;

namespace CodeForces {
    struct Node {
        public int X, Y, D;
        public Node(int x,int y, int d) {
            X = x;
            Y = y;
            D = d;
        }
    }

    class Pair : IComparable<Pair> {
        public int Vertex, Danger;
        public Pair(int f, int s) {
            Vertex = f;
            Danger = s;
        }

        public int CompareTo(Pair other) {
            return Vertex.CompareTo(Danger);
        }
    }

    class Desc : IComparer<int> {
        public int Compare(int x, int y) {
            return y.CompareTo(x);
        }
    }

    class Cf {
        static TextReader input;
        static void Main(string[] args) {
#if TESTS
            Stopwatch sw = new Stopwatch();
            sw.Start();
            input = new StreamReader("input.txt");
#else
            input = Console.In;
#endif
            Solve();
#if TESTS
            Console.WriteLine();
            Console.WriteLine("Milliseconds: {0}", sw.ElapsedMilliseconds);
            Console.ReadLine();
#endif
        }

        const int MOD = 1000000007;
        static int n, m;
        static void Solve() {
             int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            if (a == 1) {
                Console.WriteLine(b * c);
                return;
            }
            int res = (b + 1) * (c + 1);
            int sum = 0;
            for (int i = 1; i < a; i++) {
                sum += i;
            }
            Console.WriteLine(res - 2*sum);
        }

        static int[] _bitcounts;
        static void InitializeBitcounts() {
            _bitcounts = new int[65536];
            int position1 = -1;
            int position2 = -1;
            for (int i = 1; i < 65536; i++, position1++) {
                if (position1 == position2) {
                    position1 = 0;
                    position2 = i;
                }
                _bitcounts[i] = _bitcounts[position1] + 1;
            }
        }

        static int Bitcount(int value) {
            return _bitcounts[value & 65535] + _bitcounts[(value >> 16)];
        }

        static int First(int mask) {
            for (int i = 0; i < 32; i++) {
                if ((mask & (1 << i)) > 0)
                    return i;
            }
            return -1;
        }

        #region math
        static long gcd(long a, long b) {
            return b != 0 ? gcd(b, a % b) : a;
        }

        static long lcm(long a, long b) {
            return a / gcd(a, b) * b;
        }

        //static int SquaredDistanceBetweenSegments(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
        //    return Math.Min(Math.Min(SquaredDistanceToSegment(x1, y1, xx1, yy1, xx2, yy2), SquaredDistanceToSegment(x2, y2, xx1, yy1, xx2, yy2)),
        //        Math.Min(SquaredDistanceToSegment(xx1, yy1, x1, y1, x2, y2), SquaredDistanceToSegment(xx2, yy2, x1, y1, x2, y2)));
        //}

        //static int SquaredDistanceToSegment(int x, int y, int x1, int y1, int x2, int y2) {
        //    int result = Math.Min(SquaredDistance(x, y, x1, y1), SquaredDistance(x, y, x2, y2));
        //    if (x1 == x2 && y1 <= y && y <= y2)
        //        result = (x - x1) * (x - x1);
        //    else if (y1 == y2 && x1 <= x && x <= x2)
        //        result = (y - y1) * (y - y1);
        //    return result;
        //}

        static long SquaredDistance(long ax, long ay, long bx, long by) {
            return (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
        }
        #endregion

        #region read helpers
        static int nextPositive() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        static int nextInt() {
            int t = input.Read();
            while ((t < '0' || t > '9') && t != '-') t = input.Read();
            int sign = 1;
            if (t == '-') {
                sign = -1;
                t = input.Read();
            }
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x * sign;
        }

        static long nextLong() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            long x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        public static List<int> ReadIntList() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToList();
        }

        public static int[] ReadIntArray() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        }

        public static double[] ReadDoubleArray() {
            return input.ReadLine().Split(' ').Select(x => double.Parse(x)).ToArray();
        }

        public static long[] ReadLongArray() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        }

        public static List<long> ReadLongList() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToList();
        }

        public static string ReadLine() {
            return input.ReadLine();
        }

        public static int ReadInt() {
            return int.Parse(input.ReadLine());
        }

        public static long ReadLong() {
            return long.Parse(input.ReadLine());
        }
#endregion
    }

    public class SegmentTree {
        private int[] a, t;
        private int n;
        public SegmentTree(int[] a) {
            n = a.Length;
            this.a = a;
            t = new int[n << 2];
            buildSegmentTree(0, n - 1, 1);
        }

        private void buildSegmentTree(int l, int r, int v) {
            if (l == r)
                t[v] = a[l];
            else {
                int m = (l + r) >> 1;
                int vl = v << 1;
                int vr = (v << 1) | 1;
                buildSegmentTree(l, m, vl);
                buildSegmentTree(m + 1, r, vr);
                t[v] = t[vl] + t[vr];
            }
        }

        public int QuerySegmentTree(int l, int r) {
            return querySegmentTree(1, l, r, 0, n - 1);
        }

        public void Update(int v, int tl, int tr, int pos, int new_val) {
            if (tl == tr)
                t[v] = new_val;
            else {
                int tm = (tl + tr) / 2;
                if (pos <= tm)
                    Update(v << 1, tl, tm, pos, new_val);
                else
                    Update(v << 1 + 1, tm + 1, tr, pos, new_val);
                t[v] = t[v << 1] + t[v << 1 + 1];
            }
        }

        private int querySegmentTree(int v, int l, int r, int tl, int tr) {
            if (l > r)
                return 0;
            if (l == tl && r == tr)
                return t[v];
            int m = (tl + tr) >> 1;
            return querySegmentTree(v << 1, l, Math.Min(r, m), tl, m) + querySegmentTree((v << 1) | 1, Math.Max(l, m + 1), r, m + 1, tr);
        }
    }
    class Graph : List<List<int>> {
        public Graph(int num): base(num) {
            for (int i = 0; i < num; i++) {
                this.Add(new List<int>());
            }
        }
    }
    class Heap<T> : IEnumerable<T> {
        List<T> items = new List<T>();
        IComparer<T> comparer;
        public Heap(IComparer<T> comparer) {
            this.comparer = comparer;
        }
        public Heap() {
            comparer = Comparer<T>.Default;
        }

        public void Add(T item) {
            items.Add(item);
            MoveUp(Count - 1);
        }

        public T Extract() {
            CheckHeap();
            T item = items[0];
            items.Swap(0, Count - 1);
            items.RemoveAt(Count - 1);
            MoveDown(0);
            return item;
        }

        public int Count {
            get {
                return items.Count;
            }
        }

        public bool IsEmpty {
            get {
                return items.Count == 0;
            }
        }

        public T Top {
            get {
                CheckHeap();
                return items[0];
            }
        }

        void CheckHeap() {
            if (items.Count == 0)
                throw new ArgumentException("Heap is empty");
        }

        void MoveDown(int v) {
            int left = 2 * v + 1;
            int right = 2 * v + 2;
            if (left >= Count)
                return;
            if (right >= Count) {
                if (comparer.Compare(items[v], items[left]) < 0) {
                    items.Swap(v, left);
                }
                return;
            }
            int max = comparer.Compare(items[left], items[right]) < 0 ? right : left;
            if (comparer.Compare(items[v], items[max]) < 0) {
                items.Swap(v, max);
                MoveDown(max);
            }
        }

        void MoveUp(int v) {
            int parent = (v - 1) / 2;
            if (comparer.Compare(items[parent], items[v]) < 0) {
                items.Swap(v, parent);
                MoveUp(parent);
            }
        }

        public IEnumerator<T> GetEnumerator() {
            return items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            throw new NotImplementedException();
        }
    }
    public static class Extensions {
        public static void Swap<T>(this IList<T> arr, int i, int j) {
            T temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        public static int Max(this int a, int b) {
            return Math.Max(a, b);
        }

        public static int Min(this int a, int b) {
            return Math.Min(a, b);
        }

        public static void Fill(this int[] array, int val) {
            for (int i = 0; i < array.Length; i++) {
                array[i] = val;
            }
        }

        public static int ToInt(this string s) {
            return int.Parse(s);
        }

        public static void Print<T>(this IEnumerable<T> arr) {
            foreach (T t in arr)
                Console.Write("{0} ", t);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Threading;

namespace CodeForces {
    struct Node {
        public int X, Y, D;
        public Node(int x,int y, int d) {
            X = x;
            Y = y;
            D = d;
        }
    }

    class Pair : IComparable<Pair> {
        public int Vertex, Danger;
        public Pair(int f, int s) {
            Vertex = f;
            Danger = s;
        }

        public int CompareTo(Pair other) {
            return Vertex.CompareTo(Danger);
        }
    }

    class Desc : IComparer<int> {
        public int Compare(int x, int y) {
            return y.CompareTo(x);
        }
    }

    class Cf {
        static TextReader input;
        static void Main(string[] args) {
#if TESTS
            Stopwatch sw = new Stopwatch();
            sw.Start();
            input = new StreamReader("input.txt");
#else
            input = Console.In;
#endif
            Solve();
#if TESTS
            Console.WriteLine();
            Console.WriteLine("Milliseconds: {0}", sw.ElapsedMilliseconds);
            Console.ReadLine();
#endif
        }

        const int MOD = 1000000007;
        static int n, m;
        static void Solve() {
             int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            int res = (b + 1) * (c + 1);
            int sum = 0;
            for (int i = 1; i < a; i++) {
                sum += i;
            }
            Console.WriteLine(res - 2*sum);
        }

        static int[] _bitcounts;
        static void InitializeBitcounts() {
            _bitcounts = new int[65536];
            int position1 = -1;
            int position2 = -1;
            for (int i = 1; i < 65536; i++, position1++) {
                if (position1 == position2) {
                    position1 = 0;
                    position2 = i;
                }
                _bitcounts[i] = _bitcounts[position1] + 1;
            }
        }

        static int Bitcount(int value) {
            return _bitcounts[value & 65535] + _bitcounts[(value >> 16)];
        }

        static int First(int mask) {
            for (int i = 0; i < 32; i++) {
                if ((mask & (1 << i)) > 0)
                    return i;
            }
            return -1;
        }

        #region math
        static long gcd(long a, long b) {
            return b != 0 ? gcd(b, a % b) : a;
        }

        static long lcm(long a, long b) {
            return a / gcd(a, b) * b;
        }

        //static int SquaredDistanceBetweenSegments(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
        //    return Math.Min(Math.Min(SquaredDistanceToSegment(x1, y1, xx1, yy1, xx2, yy2), SquaredDistanceToSegment(x2, y2, xx1, yy1, xx2, yy2)),
        //        Math.Min(SquaredDistanceToSegment(xx1, yy1, x1, y1, x2, y2), SquaredDistanceToSegment(xx2, yy2, x1, y1, x2, y2)));
        //}

        //static int SquaredDistanceToSegment(int x, int y, int x1, int y1, int x2, int y2) {
        //    int result = Math.Min(SquaredDistance(x, y, x1, y1), SquaredDistance(x, y, x2, y2));
        //    if (x1 == x2 && y1 <= y && y <= y2)
        //        result = (x - x1) * (x - x1);
        //    else if (y1 == y2 && x1 <= x && x <= x2)
        //        result = (y - y1) * (y - y1);
        //    return result;
        //}

        static long SquaredDistance(long ax, long ay, long bx, long by) {
            return (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
        }
        #endregion

        #region read helpers
        static int nextPositive() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        static int nextInt() {
            int t = input.Read();
            while ((t < '0' || t > '9') && t != '-') t = input.Read();
            int sign = 1;
            if (t == '-') {
                sign = -1;
                t = input.Read();
            }
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x * sign;
        }

        static long nextLong() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            long x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        public static List<int> ReadIntList() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToList();
        }

        public static int[] ReadIntArray() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        }

        public static double[] ReadDoubleArray() {
            return input.ReadLine().Split(' ').Select(x => double.Parse(x)).ToArray();
        }

        public static long[] ReadLongArray() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        }

        public static List<long> ReadLongList() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToList();
        }

        public static string ReadLine() {
            return input.ReadLine();
        }

        public static int ReadInt() {
            return int.Parse(input.ReadLine());
        }

        public static long ReadLong() {
            return long.Parse(input.ReadLine());
        }
#endregion
    }

    public class SegmentTree {
        private int[] a, t;
        private int n;
        public SegmentTree(int[] a) {
            n = a.Length;
            this.a = a;
            t = new int[n << 2];
            buildSegmentTree(0, n - 1, 1);
        }

        private void buildSegmentTree(int l, int r, int v) {
            if (l == r)
                t[v] = a[l];
            else {
                int m = (l + r) >> 1;
                int vl = v << 1;
                int vr = (v << 1) | 1;
                buildSegmentTree(l, m, vl);
                buildSegmentTree(m + 1, r, vr);
                t[v] = t[vl] + t[vr];
            }
        }

        public int QuerySegmentTree(int l, int r) {
            return querySegmentTree(1, l, r, 0, n - 1);
        }

        public void Update(int v, int tl, int tr, int pos, int new_val) {
            if (tl == tr)
                t[v] = new_val;
            else {
                int tm = (tl + tr) / 2;
                if (pos <= tm)
                    Update(v << 1, tl, tm, pos, new_val);
                else
                    Update(v << 1 + 1, tm + 1, tr, pos, new_val);
                t[v] = t[v << 1] + t[v << 1 + 1];
            }
        }

        private int querySegmentTree(int v, int l, int r, int tl, int tr) {
            if (l > r)
                return 0;
            if (l == tl && r == tr)
                return t[v];
            int m = (tl + tr) >> 1;
            return querySegmentTree(v << 1, l, Math.Min(r, m), tl, m) + querySegmentTree((v << 1) | 1, Math.Max(l, m + 1), r, m + 1, tr);
        }
    }
    class Graph : List<List<int>> {
        public Graph(int num): base(num) {
            for (int i = 0; i < num; i++) {
                this.Add(new List<int>());
            }
        }
    }
    class Heap<T> : IEnumerable<T> {
        List<T> items = new List<T>();
        IComparer<T> comparer;
        public Heap(IComparer<T> comparer) {
            this.comparer = comparer;
        }
        public Heap() {
            comparer = Comparer<T>.Default;
        }

        public void Add(T item) {
            items.Add(item);
            MoveUp(Count - 1);
        }

        public T Extract() {
            CheckHeap();
            T item = items[0];
            items.Swap(0, Count - 1);
            items.RemoveAt(Count - 1);
            MoveDown(0);
            return item;
        }

        public int Count {
            get {
                return items.Count;
            }
        }

        public bool IsEmpty {
            get {
                return items.Count == 0;
            }
        }

        public T Top {
            get {
                CheckHeap();
                return items[0];
            }
        }

        void CheckHeap() {
            if (items.Count == 0)
                throw new ArgumentException("Heap is empty");
        }

        void MoveDown(int v) {
            int left = 2 * v + 1;
            int right = 2 * v + 2;
            if (left >= Count)
                return;
            if (right >= Count) {
                if (comparer.Compare(items[v], items[left]) < 0) {
                    items.Swap(v, left);
                }
                return;
            }
            int max = comparer.Compare(items[left], items[right]) < 0 ? right : left;
            if (comparer.Compare(items[v], items[max]) < 0) {
                items.Swap(v, max);
                MoveDown(max);
            }
        }

        void MoveUp(int v) {
            int parent = (v - 1) / 2;
            if (comparer.Compare(items[parent], items[v]) < 0) {
                items.Swap(v, parent);
                MoveUp(parent);
            }
        }

        public IEnumerator<T> GetEnumerator() {
            return items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            throw new NotImplementedException();
        }
    }
    public static class Extensions {
        public static void Swap<T>(this IList<T> arr, int i, int j) {
            T temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        public static int Max(this int a, int b) {
            return Math.Max(a, b);
        }

        public static int Min(this int a, int b) {
            return Math.Min(a, b);
        }

        public static void Fill(this int[] array, int val) {
            for (int i = 0; i < array.Length; i++) {
                array[i] = val;
            }
        }

        public static int ToInt(this string s) {
            return int.Parse(s);
        }

        public static void Print<T>(this IEnumerable<T> arr) {
            foreach (T t in arr)
                Console.Write("{0} ", t);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Collections;
using System.Diagnostics;
using System.Globalization;
using System.Threading;

namespace CodeForces {
    struct Node {
        public int X, Y, D;
        public Node(int x,int y, int d) {
            X = x;
            Y = y;
            D = d;
        }
    }

    class Pair : IComparable<Pair> {
        public int Vertex, Danger;
        public Pair(int f, int s) {
            Vertex = f;
            Danger = s;
        }

        public int CompareTo(Pair other) {
            return Vertex.CompareTo(Danger);
        }
    }

    class Desc : IComparer<int> {
        public int Compare(int x, int y) {
            return y.CompareTo(x);
        }
    }

    class Cf {
        static TextReader input;
        static void Main(string[] args) {
#if TESTS
            Stopwatch sw = new Stopwatch();
            sw.Start();
            input = new StreamReader("input.txt");
#else
            input = Console.In;
#endif
            Solve();
#if TESTS
            Console.WriteLine();
            Console.WriteLine("Milliseconds: {0}", sw.ElapsedMilliseconds);
            Console.ReadLine();
#endif
        }

        const int MOD = 1000000007;
        static int n, m;
        static void Solve() {
             int a = nextInt();
            int b = nextInt();
            int c = nextInt();
            if (a == 1) {
                Console.WriteLine(b * c);
                return;
            }
            if (b == 1) {
                Console.WriteLine(a * c);
                return;
            }
            if (c == 1) {
                Console.WriteLine(b * a);
                return;
            }
            int res = (b + 1) * (c + 1);
            int sum = 0;
            for (int i = 1; i < a; i++) {
                sum += i;
            }
            Console.WriteLine(res - 2*sum);
        }

        static int[] _bitcounts;
        static void InitializeBitcounts() {
            _bitcounts = new int[65536];
            int position1 = -1;
            int position2 = -1;
            for (int i = 1; i < 65536; i++, position1++) {
                if (position1 == position2) {
                    position1 = 0;
                    position2 = i;
                }
                _bitcounts[i] = _bitcounts[position1] + 1;
            }
        }

        static int Bitcount(int value) {
            return _bitcounts[value & 65535] + _bitcounts[(value >> 16)];
        }

        static int First(int mask) {
            for (int i = 0; i < 32; i++) {
                if ((mask & (1 << i)) > 0)
                    return i;
            }
            return -1;
        }

        #region math
        static long gcd(long a, long b) {
            return b != 0 ? gcd(b, a % b) : a;
        }

        static long lcm(long a, long b) {
            return a / gcd(a, b) * b;
        }

        //static int SquaredDistanceBetweenSegments(int x1, int y1, int x2, int y2, int xx1, int yy1, int xx2, int yy2) {
        //    return Math.Min(Math.Min(SquaredDistanceToSegment(x1, y1, xx1, yy1, xx2, yy2), SquaredDistanceToSegment(x2, y2, xx1, yy1, xx2, yy2)),
        //        Math.Min(SquaredDistanceToSegment(xx1, yy1, x1, y1, x2, y2), SquaredDistanceToSegment(xx2, yy2, x1, y1, x2, y2)));
        //}

        //static int SquaredDistanceToSegment(int x, int y, int x1, int y1, int x2, int y2) {
        //    int result = Math.Min(SquaredDistance(x, y, x1, y1), SquaredDistance(x, y, x2, y2));
        //    if (x1 == x2 && y1 <= y && y <= y2)
        //        result = (x - x1) * (x - x1);
        //    else if (y1 == y2 && x1 <= x && x <= x2)
        //        result = (y - y1) * (y - y1);
        //    return result;
        //}

        static long SquaredDistance(long ax, long ay, long bx, long by) {
            return (ax - bx) * (ax - bx) + (ay - by) * (ay - by);
        }
        #endregion

        #region read helpers
        static int nextPositive() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        static int nextInt() {
            int t = input.Read();
            while ((t < '0' || t > '9') && t != '-') t = input.Read();
            int sign = 1;
            if (t == '-') {
                sign = -1;
                t = input.Read();
            }
            int x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x * sign;
        }

        static long nextLong() {
            int t = input.Read();
            while (t < '0' || t > '9') t = input.Read();
            long x = 0;
            while (t >= '0' && t <= '9') {
                x *= 10;
                x += t - '0';
                t = input.Read();
            }
            return x;
        }

        public static List<int> ReadIntList() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToList();
        }

        public static int[] ReadIntArray() {
            return input.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
        }

        public static double[] ReadDoubleArray() {
            return input.ReadLine().Split(' ').Select(x => double.Parse(x)).ToArray();
        }

        public static long[] ReadLongArray() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToArray();
        }

        public static List<long> ReadLongList() {
            return input.ReadLine().Split(' ').Select(x => long.Parse(x)).ToList();
        }

        public static string ReadLine() {
            return input.ReadLine();
        }

        public static int ReadInt() {
            return int.Parse(input.ReadLine());
        }

        public static long ReadLong() {
            return long.Parse(input.ReadLine());
        }
#endregion
    }

    public class SegmentTree {
        private int[] a, t;
        private int n;
        public SegmentTree(int[] a) {
            n = a.Length;
            this.a = a;
            t = new int[n << 2];
            buildSegmentTree(0, n - 1, 1);
        }

        private void buildSegmentTree(int l, int r, int v) {
            if (l == r)
                t[v] = a[l];
            else {
                int m = (l + r) >> 1;
                int vl = v << 1;
                int vr = (v << 1) | 1;
                buildSegmentTree(l, m, vl);
                buildSegmentTree(m + 1, r, vr);
                t[v] = t[vl] + t[vr];
            }
        }

        public int QuerySegmentTree(int l, int r) {
            return querySegmentTree(1, l, r, 0, n - 1);
        }

        public void Update(int v, int tl, int tr, int pos, int new_val) {
            if (tl == tr)
                t[v] = new_val;
            else {
                int tm = (tl + tr) / 2;
                if (pos <= tm)
                    Update(v << 1, tl, tm, pos, new_val);
                else
                    Update(v << 1 + 1, tm + 1, tr, pos, new_val);
                t[v] = t[v << 1] + t[v << 1 + 1];
            }
        }

        private int querySegmentTree(int v, int l, int r, int tl, int tr) {
            if (l > r)
                return 0;
            if (l == tl && r == tr)
                return t[v];
            int m = (tl + tr) >> 1;
            return querySegmentTree(v << 1, l, Math.Min(r, m), tl, m) + querySegmentTree((v << 1) | 1, Math.Max(l, m + 1), r, m + 1, tr);
        }
    }
    class Graph : List<List<int>> {
        public Graph(int num): base(num) {
            for (int i = 0; i < num; i++) {
                this.Add(new List<int>());
            }
        }
    }
    class Heap<T> : IEnumerable<T> {
        List<T> items = new List<T>();
        IComparer<T> comparer;
        public Heap(IComparer<T> comparer) {
            this.comparer = comparer;
        }
        public Heap() {
            comparer = Comparer<T>.Default;
        }

        public void Add(T item) {
            items.Add(item);
            MoveUp(Count - 1);
        }

        public T Extract() {
            CheckHeap();
            T item = items[0];
            items.Swap(0, Count - 1);
            items.RemoveAt(Count - 1);
            MoveDown(0);
            return item;
        }

        public int Count {
            get {
                return items.Count;
            }
        }

        public bool IsEmpty {
            get {
                return items.Count == 0;
            }
        }

        public T Top {
            get {
                CheckHeap();
                return items[0];
            }
        }

        void CheckHeap() {
            if (items.Count == 0)
                throw new ArgumentException("Heap is empty");
        }

        void MoveDown(int v) {
            int left = 2 * v + 1;
            int right = 2 * v + 2;
            if (left >= Count)
                return;
            if (right >= Count) {
                if (comparer.Compare(items[v], items[left]) < 0) {
                    items.Swap(v, left);
                }
                return;
            }
            int max = comparer.Compare(items[left], items[right]) < 0 ? right : left;
            if (comparer.Compare(items[v], items[max]) < 0) {
                items.Swap(v, max);
                MoveDown(max);
            }
        }

        void MoveUp(int v) {
            int parent = (v - 1) / 2;
            if (comparer.Compare(items[parent], items[v]) < 0) {
                items.Swap(v, parent);
                MoveUp(parent);
            }
        }

        public IEnumerator<T> GetEnumerator() {
            return items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator() {
            throw new NotImplementedException();
        }
    }
    public static class Extensions {
        public static void Swap<T>(this IList<T> arr, int i, int j) {
            T temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        public static int Max(this int a, int b) {
            return Math.Max(a, b);
        }

        public static int Min(this int a, int b) {
            return Math.Min(a, b);
        }

        public static void Fill(this int[] array, int val) {
            for (int i = 0; i < array.Length; i++) {
                array[i] = val;
            }
        }

        public static int ToInt(this string s) {
            return int.Parse(s);
        }

        public static void Print<T>(this IEnumerable<T> arr) {
            foreach (T t in arr)
                Console.Write("{0} ", t);
        }
    }
}

using System; using System.Linq;

class P {
  static void Main() {
    var s = Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
    var a = s[0]; var b = s[1]; var c = s[2];
    var res = c * (a+b-1) + b - 1;
    Console.Write(res);
  }
}

using System;

namespace AllProblems
{
    class Program
    {
        static void Main(string[] args)
        {
            _216A_TilingWithHexagon.Run();
        }
    }

    class _216A_TilingWithHexagon
    {
        public static void Run()
        {
            var l = Console.ReadLine().Trim().Split(' ');
            var a = short.Parse(l[0]);
            var b = short.Parse(l[1]);
            var c = short.Parse(l[2]);
            var x = a*b + (b + 1)*(c - 1);

            Console.WriteLine(x);
            Console.ReadLine();
        }
    }
}