The winter in Berland lasts *n* days. For each day we know the forecast for the average air temperature that day. 

Vasya has a new set of winter tires which allows him to drive safely no more than *k* days at any average air temperature. After *k* days of using it (regardless of the temperature of these days) the set of winter tires wears down and cannot be used more. It is not necessary that these *k* days form a continuous segment of days.

Before the first winter day Vasya still uses summer tires. It is possible to drive safely on summer tires any number of days when the average air temperature is non-negative. It is impossible to drive on summer tires at days when the average air temperature is negative. 

Vasya can change summer tires to winter tires and vice versa at the beginning of any day.

Find the minimum number of times Vasya needs to change summer tires to winter tires and vice versa to drive safely during the winter. At the end of the winter the car can be with any set of tires.
The first line contains two positive integers *n* and *k* (1 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>, 0 ≤ *k* ≤ *n*) — the number of winter days and the number of days winter tires can be used. It is allowed to drive on winter tires at any temperature, but no more than *k* days in total.

The second line contains a sequence of *n* integers *t*<sub class="lower-index">1</sub>, *t*<sub class="lower-index">2</sub>, ..., *t*<sub class="lower-index">*n*</sub> ( - 20 ≤ *t*<sub class="lower-index">*i*</sub> ≤ 20) — the average air temperature in the *i*-th winter day.
In the first example before the first winter day Vasya should change summer tires to winter tires, use it for three days, and then change winter tires to summer tires because he can drive safely with the winter tires for just three days. Thus, the total number of tires' changes equals two. 

In the second example before the first winter day Vasya should change summer tires to winter tires, and then after the first winter day change winter tires to summer tires. After the second day it is necessary to change summer tires to winter tires again, and after the third day it is necessary to change winter tires to summer tires. Thus, the total number of tires' changes equals four.
4 3
-5 20 -3 0
2
4 2
-5 20 -3 0
4
10 6
2 -5 1 3 0 0 -4 -3 1 0
3
4 4
-5 20 -3 0
1
4 1
-5 20 -3 0
-1
1 0
-13
-1
2 0
-12 -13
-1
3 1
9 -16 -7
-1
5 5
-15 -10 -20 -19 -14
1
7 3
-2 -14 3 -17 -20 -13 -17
-1
10 10
-9 4 -3 16 -15 12 -12 8 -14 15
1
30 9
12 8 -20 0 11 -17 -11 -6 -2 -18 -19 -19 -18 -12 -17 8 10 -17 10 -9 7 1 -10 -11 -17 -2 -12 -9 -8 6
-1
50 3
6 20 17 19 15 17 3 17 5 16 20 18 9 19 18 18 2 -3 11 11 5 15 4 18 16 16 19 11 20 17 2 1 11 14 18 -8 13 17 19 9 9 20 19 20 19 5 12 19 6 9
4
100 50
-7 -3 9 2 16 -19 0 -10 3 -11 17 7 -7 -10 -14 -14 -7 -15 -15 -8 8 -18 -17 -5 -19 -15 -14 0 8 -3 -19 -13 -3 11 -3 -16 16 -16 -12 -2 -17 7 -16 -14 -10 0 -10 -18 -16 -11 -2 -12 -15 -8 -1 -11 -3 -17 -14 -6 -9 -15 -14 -11 -20 -20 -4 -20 -8 -2 0 -2 -20 17 -17 2 0 1 2 6 -5 -13 -16 -5 -11 0 16 -16 -4 -18 -18 -8 12 8 0 -12 -5 -7 -16 -15
-1
10 10
-3 -3 -3 -3 -3 -3 -3 -3 -3 -4
1
10 0
2 2 2 2 2 2 2 2 2 0
0
10 5
-3 3 -3 3 -3 3 -3 3 -3 3
10
17 17
-16 -19 10 -15 6 -11 -11 2 -17 -3 7 -5 -8 1 -20 -8 -11
1
9 8
12 20 0 19 20 14 7 17 12
0
10 10
-13 -9 -8 -20 -10 -12 -17 7 -15 -16
1
15 15
-14 -15 -8 -12 -10 -20 -14 -2 -1 2 -20 -15 5 -1 -9
1
1 1
11
0
14 11
10 12 9 12 -2 15 1 17 8 17 18 7 10 14
1
1 1
12
0
1 1
-1
1
1 0
1
0
1 0
0
0
1 0
-1
-1
2 1
-1 1
2
1 1
1
0
8 3
14 9 10 1 2 -1 6 13
1
3 3
0 0 0
0
11 7
0 0 -1 -1 0 0 0 -1 -1 0 0
2
7 5
-1 1 1 1 -1 1 1
2
3 3
1 2 3
0
5 4
-1 1 1 -1 1
2
3 3
1 1 1
0
5 4
-1 0 0 -1 0
2
import copy
import gc
import itertools
from array import array
from fractions import Fraction
import heapq
import math
import operator
import os, sys
import profile
import cProfile
import random
import re
import string
from bisect import bisect_left, bisect_right
from collections import defaultdict, deque, Counter
from functools import reduce
from io import IOBase, BytesIO
from itertools import count, groupby, accumulate, permutations, combinations_with_replacement, product
from math import gcd
from operator import xor, add
from typing import List

# region fastio
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")


# print = lambda d: sys.stdout.write(str(d)+"\n")
def read_int_list(): return list(map(int, input().split()))


def read_int_tuple(): return tuple(map(int, input().split()))


def read_int(): return int(input())


# endregion

### CODE HERE



# sys.setrecursionlimit(212345)

def solve(n, k, temps):
    # print(temps)
    rem = k - sum(temps)
    if rem < 0: return -1

    cate = [(t, len([*g])) for t, g in groupby(temps)]
    n = len(cate)
    res = n - 1

    if n & 1:
        _, last = cate.pop()
        n -= 1
    else:
        last = 1234567890

    # print([cate[i][1] for i in range(2, n, 2)], last)

    cur = 0

    for x in sorted([cate[i][1] for i in range(2, n, 2)]):
        if cur + x > rem: break
        cur += x
        res -= 2

    if cur + last <= rem:
        res -= 1

    return res

def main():
    n, k = read_int_tuple()
    temps = [0] + [1 if t < 0 else 0 for t in read_int_list()]
    print(solve(n, k, temps))


if __name__ == "__main__":
    main()
# cProfile.run("main()")
