George decided to prepare a Codesecrof round, so he has prepared m problems for the round. Let's number the problems with integers 1 through m. George estimates the i-th problem's complexity by integer b_{i}.

To make the round good, he needs to put at least n problems there. Besides, he needs to have at least one problem with complexity exactly a_1, at least one with complexity exactly a_2, ..., and at least one with complexity exactly a_{n}. Of course, the round can also have problems with other complexities.

George has a poor imagination. It's easier for him to make some already prepared problem simpler than to come up with a new one and prepare it. George is magnificent at simplifying problems. He can simplify any already prepared problem with complexity c to any positive integer complexity d (c ≥ d), by changing limits on the input data.

However, nothing is so simple. George understood that even if he simplifies some problems, he can run out of problems for a good round. That's why he decided to find out the minimum number of problems he needs to come up with in addition to the m he's prepared in order to make a good round. Note that George can come up with a new problem of any complexity.


-----Input-----

The first line contains two integers n and m (1 ≤ n, m ≤ 3000) — the minimal number of problems in a good round and the number of problems George's prepared. The second line contains space-separated integers a_1, a_2, ..., a_{n} (1 ≤ a_1 < a_2 < ... < a_{n} ≤ 10^6) — the requirements for the complexity of the problems in a good round. The third line contains space-separated integers b_1, b_2, ..., b_{m} (1 ≤ b_1 ≤ b_2... ≤ b_{m} ≤ 10^6) — the complexities of the problems prepared by George. 


-----Output-----

Print a single integer — the answer to the problem.


-----Examples-----
Input
3 5
1 2 3
1 2 2 3 3

Output
0

Input
3 5
1 2 3
1 1 1 1 1

Output
2

Input
3 1
2 3 4
1

Output
3



-----Note-----

In the first sample the set of the prepared problems meets the requirements for a good round.

In the second sample, it is enough to come up with and prepare two problems with complexities 2 and 3 to get a good round.

In the third sample it is very easy to get a good round if come up with and prepare extra problems with complexities: 2, 3, 4.

Difficulty: interview

Starter code:

Solutions:
n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
i, j = 0, 0
while i < n:
    while j < m and b[j] < a[i]:
        j += 1
    if j == m:
        break
    j += 1
    i += 1
print(n - i)

n, m = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A.sort()
B.sort()
i, j = len(A) - 1, len(B) - 1
res = 0

while i >= 0 and j >= 0:
    if A[i] > B[j]:
        res += 1
        i -= 1
    else:
        j -= 1
        i -= 1
res += i + 1
print(res)


n, m = map(int, input().split())
georg = list(map(int, input().split()))

good = list(map(int, input().split()))
good.sort()
georg.sort()
candoc = 0
j = 0
for i in range(min(n, m)):
    while j < m and good[j] < georg[i]: j += 1
    if j>=m:break
    if good[j] >= georg[i]:
        candoc += 1
        j+=1
    if j>=m:break
print(n-candoc)

n,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
a.sort()
b.sort()
i=0
j=0
while i<n and j<m:
    if a[i]<=b[j]:
        i+=1
    j+=1
print(n-i)

n,m=map(int,input().split())
treb=list(map(int,input().split()))
est=list(map(int,input().split()))
c=[0 for i in range(max(treb[-1],est[-1])+1)]
for i in range(n):
    c[treb[i]-1]+=1
i=m-1
e=n
q=treb[-1]
while i!=-1:
    d=True
    for j in range(min(est[i]-1,q),-1,-1):
        if c[j]>0:
            q=j
            c[j]-=1
            d=False
            e-=1
            break
    if d:
        print(e)
        return
    i-=1
print(e)

import sys
import math
import heapq
import random
import collections
import bisect
import datetime

def main():
    # sys.stdin = open('input.txt', 'r')
    # sys.stdout = open('output.txt', 'w')

    n = list(map(int, input().strip().split()))
    l1 = list(map(int, input().strip().split()))
    l2 = list(map(int, input().strip().split()))
    count = 0

    for i in l1:
        pos = bisect.bisect_left(l2, i)

        if pos < len(l2) and l2[pos] >= i:
                l2 = l2[pos+1:]

        else:
            count = count + 1

    print(count)

    # sys.stdin.close()
    # sys.stdout.close()

def __starting_point():
    main()

__starting_point()

def main():
    n,m=list(map(int,input().split()))
    a=list(map(int,input().split()))
    b=list(map(int,input().split()))
    
    c=list()

    for x in a:
        if x in b:
            b.pop(b.index(x))
        else:
            c.append(x)
    L=0
    if len(c)==0:
        return 0
    i=0
    while len(c):
        while i<len(b) and (b[i]<c[0]):
            i+=1
        if i==len(b):
            return len(c)
        b.pop(i)
        c.pop(0)
    return len(c)

        
print(main())


n, m = tuple(map(int,input().split(' ')))
a = list(map(int,input().split(' ')))
b = list(map(int,input().split(' ')))
while len(a)>0 and len(b)>0:
    if a[0]<=b[0]: a.pop(0)
    b.pop(0)
print(len(a))


from bisect import bisect_left
def binr(a, x, lo=0, hi=None):   
    hi = hi if hi is not None else len(a)  
    pos = bisect_left(a,x,lo,hi)    
    if pos < hi:
        return pos
    else:
        return -1
n,m = map(int,input().split())
d = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
fl = True
ans = 0
for i in d:
    if (i not in a):
        fl = False
if fl == True:
    print(0)
    return
for i in range(n):
    if d[i] in a:
        d[i] = 0
    r = binr(a,d[i])
    if r == -1:
        ans += 1
    else:
        a[r] = -1
    a.sort()
print(ans)   

import re

temp=input()
temp=re.split(' ',temp)
n=eval(temp[0])
m=eval(temp[1])
temp=input()
temp=re.split(' ',temp)
a=[]
for i in range(n):
  a.append(eval(temp[i]))
i=0
temp=input()
temp=re.split(' ',temp)
for j in range(m):
  x=eval(temp[j])
  if i>=n: continue
  if x>=a[i]: i+=1
ans=n-i
print(ans)

n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
i = j = 0
while i < n:
    while j < m and b[j] < a[i]: j += 1
    if j == m: break
    j += 1
    i += 1
print(n - i)

R = lambda: list(map(int, input().split()))
n, m = R()
a = R()
b = R()
c = 0
i = j = 0
while i < n:
  while j < m and b[j] < a[i]:
    j += 1
  if j == m:
    break
  c += 1
  i += 1
  j += 1
print(n - c)

R = lambda: list(map(int, input().split()))
n, m = R()
a = R()
b = R()
i = j = 0
while i < n and j < m:
  if b[j] < a[i]:
    j += 1
  else:
    i += 1
    j += 1
print(n - i)

R = lambda: list(map(int, input().split()))
n, m = R()
a = R()
b = R()
i = j = 0
while i < n and j < m:
  if b[j] >= a[i]:
    i += 1
  j += 1
print(n - i)

'''
Created on Jun 4, 2014

@author: Nathaniel
'''

import bisect

def nexti():
    return list(map(int, input().split()))
def nextl():
    return list(map(int, input().split()))

n, m = nexti()
a = sorted(nextl())
b = sorted(nextl())
count = 0
i=0
j=0
n = len(a)

while i < n:
    bis = bisect.bisect_left(b, a[i])
    if bis != len(b):
        count+=1
        del b[bis]
    i+=1
print(n - count)
        



n, m = list(map(int, input().split()))
a = sorted(list(map(int, input().split())))
b = sorted(list(map(int, input().split())))

i, j = 0, 0
while i < n and j < m:
	if a[i] <= b[j]:
		i += 1
	j += 1
print(n-i)


import sys
import math

n, m = [int(x) for x in (sys.stdin.readline()).split()]
an = [int(x) for x in (sys.stdin.readline()).split()]
bm = [int(x) for x in (sys.stdin.readline()).split()]

i = 0
j = 0
res = n
while(i < n):
    while(j < m and an[i] > bm[j]):
        j += 1  
        
    if(j < m and an[i] <= bm[j]):
        res -= 1
        j += 1
    
    i += 1
    
print(res)


n, m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
b = [int(x) for x in input().split()]
ptr = 0
found = 0
for task in a:
	while ptr < m and b[ptr] < task:
		ptr += 1
	if ptr < m and b[ptr] >= task:
		found += 1
		ptr += 1
print(n - found)


def main():
    n, m = map(int, input().split())
    aa = list(map(int, input().split()))
    it = iter(list(map(int, input().split())))
    try:
        for i, a in enumerate(aa, 1):
            b = next(it)
            while b < a:
                b = next(it)
    except StopIteration:
        i -= 1
    print(n - i)


def __starting_point():
    main()
__starting_point()

I=lambda:list(map(int,input().split()))
n,m=I();a=I();b=I()
i=j=0
while(i<n and j<m):
    i+=1*(a[i]<=b[j]);j+=1
print(n-i)

# coding: utf-8
from collections import Counter
n, m = [int(i) for i in input().split()]
a = Counter([int(i) for i in input().split()])
b = Counter([int(i) for i in input().split()])
aa = list((a-b).elements())
bb = list((b-a).elements())
cnt = sum(a.values())-len(aa)
aa.sort()
bb.sort()
i = 0
j = 0
while i < len(aa):
    while j < len(bb) and bb[j]<aa[i]:
        j += 1
    if j < len(bb) and bb[j]>aa[i]:
        cnt += 1
        j += 1
    i += 1
print(n-cnt)


# coding: utf-8
from collections import Counter
n, m = [int(i) for i in input().split()]
a = Counter([int(i) for i in input().split()])
b = Counter([int(i) for i in input().split()])
aa = sorted(list((a-b).elements()))
bb = sorted(list((b-a).elements()))
cnt = sum(a.values())-len(aa)
i = 0
j = 0
while i < len(aa):
    while j < len(bb) and bb[j]<aa[i]:
        j += 1
    if j < len(bb) and bb[j]>aa[i]:
        cnt += 1
        j += 1
    i += 1
print(n-cnt)


R = lambda:list(map(int,input().split()))
n,m = R()
a = R()
b = R()
r = 0
for x in a:
    c = 0
    for y in b:
        if y>=x:
            c = 1
            b.pop(b.index(y))
            break
    if c == 0:
        r += 1
print(r)

n, m = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))

a.sort()
b.sort()

j = -1

cnt = 0

for v in a:
    j += 1
    while j < m and v > b[j]:
        j += 1

    if j >= m:
        cnt += 1

print(cnt)

n, m = map(int, input().split())
c = list(sorted(map(int, input().split())))
d = list(sorted(map(int, input().split())))
i, j = 0, 0
while i < n and j < m:
    if c[i] <= d[j]:
        i += 1
    j += 1
print(n-i)