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;

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.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;
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;

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;
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;
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();
        }
    }
}