Problem: The only difference between easy and hard versions is constraints.

You are given n segments on the coordinate axis OX. Segments can intersect, lie inside each other and even coincide. The i-th segment is [l_i; r_i] (l_i ≤ r_i) and it covers all integer points j such that l_i ≤ j ≤ r_i.

The integer point is called bad if it is covered by strictly more than k segments.

Your task is to remove the minimum number of segments so that there are no bad points at all.

Input

The first line of the input contains two integers n and k (1 ≤ k ≤ n ≤ 200) — the number of segments and the maximum number of segments by which each integer point can be covered.

The next n lines contain segments. The i-th line contains two integers l_i and r_i (1 ≤ l_i ≤ r_i ≤ 200) — the endpoints of the i-th segment.

Output

In the first line print one integer m (0 ≤ m ≤ n) — the minimum number of segments you need to remove so that there are no bad points.

In the second line print m distinct integers p_1, p_2, ..., p_m (1 ≤ p_i ≤ n) — indices of segments you remove in any order. If there are multiple answers, you can print any of them.

Examples

Input


7 2
11 11
9 11
7 8
8 9
7 8
9 11
7 9


Output


3
1 4 7 


Input


5 1
29 30
30 30
29 29
28 30
30 30


Output


3
1 2 4 


Input


6 1
2 3
3 3
2 3
2 2
2 3
2 3


Output


4
1 3 5 6 

Solution (in PYTHON3):

Solution:
# ------------------- fast io --------------------
import os
import sys
from io import BytesIO, IOBase
 
BUFSIZE = 8192
 
class FastIO(IOBase):
    newlines = 0
    def __init__(self, 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")
 
# ------------------- fast io --------------------

n,k=map(int,input().split())
segs={}
cord=[0 for s in range(200)]
dict1={}
ks=set([])
for s in range(n):
    l,r=map(int,input().split())
    l-=1
    r-=1
    if not((l,r) in segs):
        segs[(l,r)]=1
        dict1[(l,r)]=[s+1]
    else:
        segs[(l,r)]+=1
        dict1[(l,r)].append(s+1)
    for b in range(l,r+1):
        cord[b]+=1
        if cord[b]>k:
            ks.add(b)
#loop through the segments and take off the segments that cover the most
ans=0
indices=[]
ks=list(ks)
ks.sort()
while len(ks)>0:
    #find all the segs that cover it
    v0=ks.pop()
    if cord[v0]>k:
        seg1=[]
        for b in segs:
            seg=b
            if seg[0]<=v0<=seg[1]:
                a1=[]
                for s in range(seg[0],seg[1]+1):
                    if cord[s]>k:
                        a1.append(s)
                for l in range(segs[b]):
                    seg1.append((seg,a1))
        seg1.sort(key= lambda x: len(x[1]))
        while cord[v0]>k:
            v1=seg1.pop()
            segs[v1[0]]-=1
            if segs[v1[0]]==0:
                segs.pop(v1[0])
            ans+=1
            indices.append(dict1[v1[0]].pop())
            for b in v1[1]:
                cord[b]-=1
print(ans)
indices.sort()
print(*indices)