Problem:
Score : 300 points

Problem Statement

Given any integer x, Aoki can do the operation below.

Operation: Replace x with the absolute difference of x and K.

You are given the initial value of an integer N. Find the minimum possible value taken by N after Aoki does the operation zero or more times.

Constraints

0 ≤ N ≤ 10^{18}

1 ≤ K ≤ 10^{18}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K

Output

Print the minimum possible value taken by N after Aoki does the operation zero or more times.

Sample Input 1

7 4

Sample Output 1

1

Initially, N=7.

After one operation, N becomes |7-4| = 3.

After two operations, N becomes |3-4| = 1, which is the minimum value taken by N.

Sample Input 2

2 6

Sample Output 2

2

N=2 after zero operations is the minimum.

Sample Input 3

1000000000000000000 1

Sample Output 3

0

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using static System.Math;
using Number = System.Int32;
using System.Numerics;
using static System.Numerics.BigInteger;
namespace Program {
	public class Solver {
		Random rnd = new Random(0);
		public void Solve() {
			var n = rl;
			var k = rl;
			if (n > k) n -= (n / k) * k;
			var min = n;
			for (int i = 0; i < 100; i++) {
				n = Abs(k - n);
				min = Min(min, n);
				Debug.WriteLine(n);
			}
			Console.WriteLine(min);
		}
		const long INF = 1L << 60; static int[] dx = { -1, 0, 1, 0 }; static int[] dy = { 0, 1, 0, -1 }; int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput()); static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n]; for (int i = 0; i < a.Length; ++i) a[i] = f(i); return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = false });
		var solver = new Program.Solver();
		//* 
		var t = new System.Threading.Thread(solver.Solve, 200000000);
		t.Start();
		t.Join();
		//*/
		// solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion


#region Disjoint Set
/// <summary>
/// いくつかの要素を素集合に分割して保持するコレクションです．
/// </summary>
public class DisjointSet {
	int[] par;
	byte[] rank;
	/// <summary>
	/// 0 から <paramref name="N"/>-1 までの番号がついた <paramref name="N"/> 個の要素からなる集合を作成します．
	/// </summary>
	/// <param name="N">要素数</param>
	/// <remarks>このコンストラクタは O(N) で実行されます．</remarks>
	public DisjointSet(int N) {
		par = new int[N];
		rank = new byte[N];
		for (int i = 0; i < N; i++)
			par[i] = -1;
	}
	/// <summary>
	/// 指定した要素が属する集合の代表値を取得します．
	/// </summary>
	/// <param name="id">調べたい要素の 0-indexed での番号</param>
	/// <returns>指定した要素が属する集合の代表値</returns>
	/// <remarks>最悪計算量 O(α(N)) で実行されます．</remarks>
	public int this[int id] {
		get {
			if ((par[id] < 0)) return id;
			return par[id] = this[par[id]];
		}
	}
	/// <summary>
	/// 指定した 2 つの要素が属する集合同士を 1 つに統合することを試みます．
	/// </summary>
	/// <param name="x">最初の要素の 0-indexed での番号</param>
	/// <param name="y">2 つ目の要素の 0-indexed での番号</param>
	/// <returns>統合に成功したならば true，そうでなければ false．</returns>
	/// <remarks>最悪計算量 O(α(N)) で実行されます．</remarks>
	public bool Unite(int x, int y) {
		x = this[x]; y = this[y];
		if (x == y) return false;
		if (rank[x] < rank[y]) { var tmp = x; x = y; y = tmp; }
		par[x] += par[y];
		par[y] = x;
		if (rank[x] == rank[y])
			rank[x]++;
		return true;
	}
	/// <summary>
	/// 指定した要素が属する集合のサイズを取得します．
	/// </summary>
	/// <param name="x">指定する要素の 0-indexed での番号</param>
	/// <returns>集合のサイズ</returns>
	/// <remarks>最悪計算量 O(α(N)) で実行されます．</remarks>
	public int Size(int x) { return -par[this[x]]; }

	/// <summary>
	/// 指定した 2 つの要素が属する集合が同じかどうかを判定する．計算量 O(α(N))．
	/// </summary>
	/// <param name="x">最初の要素の 0-indexed での番号</param>
	/// <param name="y">2 つ目の要素の 0-indexed での番号</param>
	/// <returns>同じならば true，そうでなければ false．</returns>
	/// <remarks>最悪計算量 O(α(N)) で実行されます．</remarks>
	public bool Same(int x, int y) { return this[x] == this[y]; }

}
#endregion