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.util.*;
		import java.util.*;
		import javax.swing.plaf.synth.SynthSpinnerUI;
		import javax.swing.plaf.synth.SynthStyle;
		import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
		import java.util.StringTokenizer;
		import java.io.BufferedReader;
		import java.io.IOException;
		import java.io.InputStreamReader;
		
		public class mohamedy23
				{
			
			      public static void main (String args[])throws NumberFormatException, IOException, InterruptedException
				    {
				    	Scanner sc=new Scanner(System.in);
				    	int n=sc.nextInt();int m=sc.nextInt();Integer a[]=new Integer[n];Integer b[]=new Integer[m];
				    	for(int i=0;i<n;i++)a[i]=sc.nextInt();
				    	for(int i=0;i<m;i++)b[i]=sc.nextInt();
				    	Arrays.sort(a);
//				    	System.out.println(Arrays.toString(a));
//				    	System.out.println(Arrays.toString(b));
				    	int l=0;int h=a.length-1;int k=(l+h)/2;
				    	for(int i=0;i<b.length;i++) {
				    	l=0;h=a.length-1;  k=(l+h)/2;
				    	 //System.out.print(b[i]);
				    	  for(;l<=h;) {k=(l+h)/2;
				    		  if(b[i]<a[k]) {
				    			  h=k-1;
				    		  }else {
				    			  l=k+1;	
				    		  }
				    	  }
				    	  System.out.print((int)(h+1)+" ");
				    	}
				    }
			      
			   
			      
			      
			      
			      




				//	Bubble Sort    
			      static void bubbleSort(int a[]) 
			      { 
			          int n = a.length; 
			          for (int i = 0; i < n-1; i++) 
			              for (int j = 0; j < n-i-1; j++) 
			                  if (a[j] > a[j+1]) 
			                  { 
			                      // swap arr[j+1] and arr[i] 
			                      int temp = a[j]; 
			                      a[j] = a[j+1]; 
			                      a[j+1] = temp; 
			                  } 
			      }      
			    //Merge Sort
			      
			      	public static void mergeSort(int[] a, int n) {
			      	    if (n < 2) {
			      	        return;
			      	    }
			      	    int mid = n / 2;
			      	    int[] l = new int[mid];
			      	    int[] r = new int[n - mid];
			      	 
			      	    for (int i = 0; i < mid; i++) {
			      	        l[i] = a[i];
			      	    }
			      	    for (int i = mid; i < n; i++) {
			      	        r[i - mid] = a[i];
			      	    }
			      	    mergeSort(l, mid);
			      	    mergeSort(r, n - mid);
			      	 
			      	    merge(a, l, r, mid, n - mid);
			      	}
			      	
			      	public static void merge(
			      			  int[] a, int[] l, int[] r, int left, int right) {
			      			  
			      			    int i = 0, j = 0, k = 0;
			      			    while (i < left && j < right) {
			      			        if (l[i] <= r[j]) {
			      			            a[k++] = l[i++];
			      			        }
			      			        else {
			      			            a[k++] = r[j++];
			      			        }
			      			    }
			      			    while (i < left) {
			      			        a[k++] = l[i++];
			      			    }
			      			    while (j < right) {
			      			        a[k++] = r[j++];
			      			    }
			      			}
			      //Comparable Class to sort 2d array[n][2] according the first column
			    	class Pair implements Comparable<Pair> {
				  		int a, b;
				   
				  		public Pair(int a, int b) {
				  			this.a = a;
				  			this.b = b;
				  		}
				   
				  		public int compareTo(Pair A) {
				  			return this.a>A.a?1:-1;
				  		}
				   
				  		
				  	}
			      
			      static class Scanner {
				  		StringTokenizer st;
				  		BufferedReader br;

				  		public Scanner(InputStream system) {
				  			br = new BufferedReader(new InputStreamReader(system));
				  		}

				  		public Scanner(String file) throws Exception {
				  			br = new BufferedReader(new FileReader(file));
				  		}

				  		public String next() throws IOException {
				  			while (st == null || !st.hasMoreTokens())
				  				st = new StringTokenizer(br.readLine());
				  			return st.nextToken();
				  		}

				  		public String nextLine() throws IOException {
				  			return br.readLine();
				  		}

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

				  		public double nextDouble() throws IOException {
				  			return Double.parseDouble(next());
				  		}

				  		public char nextChar() throws IOException {
				  			return next().charAt(0);
				  		}

				  		public Long nextLong() throws IOException {
				  			return Long.parseLong(next());
				  		}

				  		public boolean ready() throws IOException {
				  			return br.ready();
				  		}

				  		public void waitForInput() throws InterruptedException {
				  			Thread.sleep(3000);
				  		}
				  	}
			      }
				 