using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using static System.Math;
namespace A
{
    class Program
    {
        static void Main()
        {
            var XKD = CinLAr;
            var XA = Abs(XKD[0]);
            long mig = XA / XKD[2];
            if(mig > XKD[1])
            {
                Cout = XA - XKD[1] * XKD[2];
            }
            else
            {
                var mod = XA % XKD[2];
                bool rt = (XKD[1] - mig) % 2 == 0;
                if (rt) { Cout = mod; } else
                {
                    Cout = Abs(mod - XKD[2]);
                }
            }

            Wait();
        } //main

        static int MOD10_9_7 = (1000000000 + 7);
        static Random Rand = new Random();
        static string Yes = "Yes";
        static string No = "No";
        static char[] AlphTab = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
        static int GetDigits(long n) { return (int)Floor(Log10(n)) + 1; }
        static int GetNumByDigit(long n, int d) { return (int)((n / ((int)Pow(10, d - 1))) % 10); }
        static int Loop(int n, int max)
        {
            if (n > max) { return n % max - 1; }
            else if (n < 0) { return max - (-n) % max + 1; }
            else { return n; }
        }
        static long PW10(int n) { return (long)Pow(10, n); }
        static long GCD(long a, long b)
        {
            if (a < b) { return GCD(b, a); } if (a % b == 0) { return b; } else { return GCD(b, a % b); }
        }
        static long LCM(long a, long b) { return a * b / GCD(a, b); }
        static void Swap<T>(ref T a, ref T b) { T t = a; a = b; b = t; }
        static void SwapArE<T>(T[] a, int i, int j) { T t = a[i]; a[i] = a[j]; a[j] = t; }
        static void SwapLiE<T>(List<T> a, int i, int j) { T t = a[i]; a[i] = a[j]; a[j] = t; }
        static bool IsInt(double d) { return (int)d == d; }
        static string Wait() { return Console.ReadLine(); }
        static string Cin { get { return Wait(); } }
        static string[] CinAr { get { return Cin.Split(' ').Where(x => x != "").ToArray(); } }
        static int CinT { get { return S2i(Cin); } }
        static int[] CinTAr { get { return CinAr.Select((x, i) => { return S2i(x); }).ToArray(); } }
        static long CinL { get { return S2L(Cin); } }
        static long[] CinLAr { get { return CinAr.Select((x, i) => { return S2L(x); }).ToArray(); } }
        static double CinD { get { return S2D(Cin); } }
        static double[] CinDAr { get { return CinAr.Select((x, i) => { return S2D(x); }).ToArray(); } }
        static int S2i(string s) { return int.Parse(s); }
        static long S2L(string s) { return long.Parse(s); }
        static double S2D(string s) { return double.Parse(s); }
        static object Cout{ set { Console.WriteLine(value); } }
        static object WCout{ set { Console.Write(value); } }
        static string RevStr(string s) { return new string(s.Reverse().ToArray()); }
        static void AFOR(long m, Action<long> ActI) { for(long i = 0;i < m; i++) { ActI(i); } }
        static void AFOR(long m, Action Act) { AFOR(m, i => Act()); }
        static long[] Divisor(long n)
        {
            if (n == 1) { return new long[] { 1 }; } List<long> r = new List<long>() { 1, n };
            for (long i = 2; i <= Sqrt(n); i++)
            {
                if (n % i == 0)
                {
                    r.Add(i); long f = n / i; if (f != i) { r.Add(f); }
                }
            }
            return r.ToArray();
        }
        static IEnumerable<decimal> PrimeFactors(decimal n)
        {
            decimal i = 2, t = n;
            while (i * i <= n)
            {
                if (t % i == 0){ t /= i; yield return i; } else { i++; }
            }
            if (t != 1) { yield return t; }
        }
        static bool IsPrime(long n)
        {
            if (n == 1) { return false; }
            for (long i = 2; i <= Sqrt(n) + 1; i++) { if (n % i == 0) { return false; } }return true;
        }
        static void CoutAr<Type>(IEnumerable<Type> t) { Cout = string.Join(" ", t); }
        static long nCr(int n, int r) { return nPr(n, r) / Factorial(r); }
        static long nPr(int n, int r) { return FactorDiv(n, n - r); }
        static long FactorDiv(int t, int d) { long r = 1; for (int i = t; i > d; i--) { r *= i; } return r; }
        static long Factorial(int i) { if (i <= 1) { return 1; } return i * Factorial(i - 1); }
        static void CoutPaAr<Type>(IEnumerable<Pair<Type>> p) { CoutAr(p.Select(x => $"({x.a}, {x.b}, {x.c})")); }
    }
    public struct Pair<T>
    {
        public T a, b, c;
        public Pair(T _a, T _b, T _c = default(T)) { a = _a; b = _b; c = _c; }
    }
}


Measured memory_bytes: 19912