using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Numerics; using System.Text; using static System.Console; using static System.Convert; using static System.Math; using static Extentions; class IO { int idx; string[] input = In.ReadToEnd().Split(new[] { " ", "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries); T Get(Func parser) => parser(input[idx++]); public string S => Get(s => s); public char C => Get(char.Parse); public int I => Get(int.Parse); public long L => Get(long.Parse); public double F => Get(double.Parse); public decimal D => Get(decimal.Parse); public BigInteger B => Get(BigInteger.Parse); T[] Gets(int n, Func parser) => input.Skip((idx += n) - n).Take(n).Select(parser).ToArray(); public string[] Ss(int n) => Gets(n, s => s); public char[] Cs(int n) => Gets(n, char.Parse); public int[] Is(int n) => Gets(n, int.Parse); public long[] Ls(int n) => Gets(n, long.Parse); public double[] Fs(int n) => Gets(n, double.Parse); public decimal[] Ds(int n) => Gets(n, decimal.Parse); public BigInteger[] Bs(int n) => Gets(n, BigInteger.Parse); public void Write(params T[] xs) => WriteLine(string.Join(" ", xs)); public void Write(params object[] xs) => WriteLine(string.Join(" ", xs)); } interface IMonoid { T Mempty { get; } T Mappend(T a, T b); } class Monoid : IMonoid { public T Mempty { get; private set; } public Func mappend; public T Mappend(T a, T b) => mappend(a, b); public Monoid(T mempty, Func mappend) { this.Mempty = mempty; this.mappend = mappend; } } class IntSumMonoid : IMonoid { public int Mempty => 0; public int Mappend(int a, int b) => a + b; } interface IGroup : IMonoid { T InvMappend(T a, T b); } class IntSumGroup : IntSumMonoid, IGroup { public int InvMappend(int a, int b) => a - b; } class BinaryIndexedTree { T[] tree; public readonly int N; public readonly IMonoid Monoid; readonly bool supportsGroup = false; // O(N) public BinaryIndexedTree(int n, IMonoid monoid) { N = n; Monoid = monoid; tree = Enumerable.Repeat(monoid.Mempty, n + 1).ToArray(); } // O(N) public BinaryIndexedTree(IEnumerable collection, IMonoid monoid) { N = collection.Count(); Monoid = monoid; tree = new T[N + 1]; for (var i = 0; i < N; i++) tree[i + 1] = collection.ElementAt(i); for (var i = 1; i < N; i++) { var j = i + (i & -i); if (j < N) tree[j] = monoid.Mappend(tree[j], tree[i]); } } // O(N) public BinaryIndexedTree(int n, IGroup group) : this(n, (IMonoid)group) { supportsGroup = true; } // O(N) public BinaryIndexedTree(IEnumerable collection, IGroup group) : this(collection, (IMonoid)group) { supportsGroup = true; } public T this[int i] { // O(log N) get { return this[i, i]; } // O(log N) set { if (!supportsGroup) throw new InvalidOperationException(); var group = (IGroup)Monoid; Append(i, group.InvMappend(value, this[i])); } } public T this[int i, int j] { // O(log N) get { if (!supportsGroup) throw new InvalidOperationException(); var group = (IGroup)Monoid; var acc = group.Mempty; j++; for (; j > i; j -= j & -j) acc = group.Mappend(acc, tree[j]); for (; i > j; i -= i & -i) acc = group.InvMappend(acc, tree[i]); return acc; } } // O(log N) public T Concat(int i) { var acc = Monoid.Mempty; for (i++; i > 0; i -= i & -i) acc = Monoid.Mappend(acc, tree[i]); return acc; } // O(log N) public void Append(int i, T d) { for (i++; i <= N; i += i & -i) tree[i] = Monoid.Mappend(tree[i], d); } } static class Extentions { } static class Program { public static void Main() { var sw = new StreamWriter(OpenStandardOutput()) { NewLine = "\n" }; #if DEBUG sw.AutoFlush = true; #else sw.AutoFlush = false; #endif SetOut(sw); Solve(new IO()); Out.Flush(); } static void Solve(IO io) { const int wMax = 1000000; var n = io.I; var k = io.I; var bit = new BinaryIndexedTree(wMax, new IntSumGroup()); for (var i = 0; i < n; i++) { var w = io.I; if (w > 0 && bit[w, wMax - 1] < k) bit[w]++; if (w < 0 && bit[-w] > 0) bit[-w]--; } io.Write(bit.Concat(wMax - 1)); } }