You are given two arrays of integers a and b. For each element of the second array bj you should find the number of elements in array a that are less than or equal to the value bj.

Input

The first line contains two integers n, m (1 ≤ n, m ≤ 2·105) — the sizes of arrays a and b.

The second line contains n integers — the elements of array a ( - 109 ≤ ai ≤ 109).

The third line contains m integers — the elements of array b ( - 109 ≤ bj ≤ 109).

Output

Print m integers, separated by spaces: the j-th of which is equal to the number of such elements in array a that are less than or equal to the value bj.

Examples

Input

5 4
1 3 5 7 9
6 4 2 8


Output

3 2 1 4


Input

5 5
1 2 1 2 5
3 1 4 1 5


Output

4 2 4 2 5
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Solution {

//		public static final double eps = 1e-9;
//		public static final int mod = 1000000007;
//		public static final double pi = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679;
//		public static final int dx[] = {1, -1, 0, 0};
//		public static final int dy[] = {0, 0, 1, -1};

	public static void main(String[] args) throws IOException {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		Task solver = new Task();
		solver.solve(1, in, out);
		out.close();
	}

	static class Task {

		public void solve(int testNumber, InputReader in, OutputWriter out) throws IOException {
			int n = in.nextInt(), m = in.nextInt();
			int[] a = in.nextIntArray(n);
			int[] b = in.nextIntArray(m);
			a = shuffle(a, new Random());
			Arrays.sort(a);
			for (int i = 0; i < m; i++) {
				int lo = 0, hi = n - 1;
				int tot = 0;
				while (lo <= hi) {
					int mid = (lo + hi) / 2;
					if (a[mid] <= b[i]) {
						tot += (mid - lo + 1);
						lo = mid + 1;
					}
					else hi = mid - 1;
				}
				out.print(tot);
			}
		}

//		static class Node {
//			String name;
//			LinkedList<Node> list;
//			
//			public Node(String name) {
//				this.name = name;
//				list = new LinkedList<>();
//			}
//		}
//        
//		static class Pair<T> {   	
//	      	T first, second;
//		        	
//		    public Pair(T first, T second) {
//	    		this.first = first;
//				this.second = second;
//			}
//	    }
		
//		public final int sievesize = (int) (1e6);
//		public boolean[] prime;
//		
//		public void sieve(){
//			prime = new boolean[sievesize + 1];
//			Arrays.fill(prime, true);
//		    for(int x = 2; x * x < sievesize; x++)
//		    { 
//		    	if(prime[x])
//		    		for(int y = x * 2; y < sievesize; y += x) 
//		    			prime[y] = false; 
//		    }
//		}
	}

		public static int[] shuffle(int arr[], Random gen) {
			for (int i = arr.length - 1; i > 0; i--) {
	            int index = gen.nextInt(i + 1);
	            int temp = arr[index];
	            arr[index] = arr[i];
	            arr[i] = temp;
	        }
			return arr;
		}
	//
	//	public static boolean triangle(long a, long b, long c){
	//	    return ((a+b) > c && (b+c) >a && (a+c) > b);
	//	}
	//		
	//	public static boolean isPerfectSquare(long n){
	//		if (n < 0) 
	//	    	return false;
	//	    long test = (long) (Math.sqrt(n) + 0.5);
	//	    return test*test == n;
	//	}
	//		
	//	public static int isnum(char s){
	//		if(s=='1' || s=='2' || s=='3' || s=='4' || s=='5' || s=='6' || s=='7' || s=='8' || s=='9' || s=='0') 
	//	    	return 1; 
	//		return 0;
	//	}
	//		
	//	public static long nextPowerOf2(long n){
	//	    n--;
	//	    n |= n >> 1;
	//	    n |= n >> 2;
	//	    n |= n >> 4;
	//	    n |= n >> 8;
	//	    n |= n >> 16;
	//	    n++;
	//	    return n;
	//	}
	//		
//		public static int gcd(int a, int b){
//		    int t; 
//		    while (b > 0){ 
//		    	a = a % b; 
//		    	t = a; 
//		    	a = b; 
//		    	b = t; 
//	    	}
//		    return a;
//		}
	//		

	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream), 32768);
			tokenizer = null;
		}

		public String next() {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

		public int nextInt() {
			return Integer.parseInt(next());
		}

		public long nextLong() {
			return Long.parseLong(next());
		}
		
		public char nextChar() {
			return next().charAt(0);
		}
		
		public float nextFloat() {
			return Float.parseFloat(next());
		}
		
		public double nextDouble() {
			return Double.parseDouble(next());
		}

		public int[] nextIntArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			int[] arr=new int[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Integer.parseInt(tokenizer.nextToken());
			return arr;
		}

		public long[] nextLongArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			long[] arr=new long[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Long.parseLong(tokenizer.nextToken());
			return arr;
		}
		
		public float[] nextFloatArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			float[] arr=new float[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Float.parseFloat(tokenizer.nextToken());
			return arr;
		}

		public double[] nextDoubleArray(int size) {
			while (tokenizer == null || !tokenizer.hasMoreTokens()) {
				try {
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) {
					throw new RuntimeException(e);
				}
			}
			double[] arr=new double[size];
			for(int i = 0; i < size; i++) 
				arr[i] = Double.parseDouble(tokenizer.nextToken());
			return arr;
		}

		public String[] nextStringArray(int size) throws IOException {
			String[] arr=new String[size];
			for(int i = 0; i < size; i++) 
				arr[i] = reader.readLine();
			return arr;
		}

		public char[] nextCharArray(int size) throws IOException {
			return reader.readLine().toCharArray();
		}
	}

	static class OutputWriter {
		public PrintWriter pw;

		public OutputWriter(OutputStream stream) {
			pw = new PrintWriter(stream);
		}
		
		public void println() {
			pw.println();
		}

		public void println(Object str) {
			pw.println(str);
		}

		public void print(Object str) {
			pw.print(str + " ");
		}

		public void close() {
			pw.close();
		}

		public void flush() {
			pw.flush();
		}

		public void printStringArray(String[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.println(arr[i]);
		}

		public void printIntArray(int[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printLongArray(long[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printCharArray(char[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printFloatArray(float[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}

		public void printDoubleArray(double[] arr) {
			for(int i = 0; i < arr.length; i++)
				pw.print(arr[i] + " ");
		}
	}
}