/*
A min(N*K, K^2 log K) solution to jewel thief. Should TLE. 
*/

import java.util.*;
import java.io.*;

public class thiefslowish_font
{
   public static void main(String[] args) throws Exception
   {
      PrintWriter out = new PrintWriter(System.out);
      new thiefslowish_font(new FastScanner(System.in), out);
      out.close();
   }

   final static int MAX_S = 300;
   public thiefslowish_font(FastScanner in, PrintWriter out)
   {
      int N = in.nextInt();
      int K = in.nextInt();
      
      ArrayList<Integer>[] jewels = new ArrayList[MAX_S+1];
      for (int x=0; x<jewels.length; x++)
         jewels[x] = new ArrayList<Integer>();
      
      for (int i=0; i<N; i++)
      {
         int s = in.nextInt();
         int v = in.nextInt();
         jewels[s].add(v);
      }
      for (int x=0; x<jewels.length; x++)
         Collections.sort(jewels[x], Collections.reverseOrder());

      long[] dp = new long[K+1];
      Curve[] dq = new Curve[K+1];
      for (int s=0; s<jewels.length; s++) if (jewels[s].size() > 0)
      {
         int L = jewels[s].size();
         long[] sum = new long[L];
         for (int i=0; i<L; i++)
            sum[i] = jewels[s].get(i);

         for (int i=0; i+1<L; i++)
            sum[i+1] += sum[i];
         Curve.sum = sum;
         // Update each congruence class
         for (int m=0; m<s; m++)
         {
            int start=K-m, j=1, fptr = 0, bptr = 0;
            for (int i=0; start-i*s>=0; i++)
            {
               // Relax outdated
               while (bptr-fptr > 0 && dq[fptr].a <= i)
                  fptr++;
               
               while (j-i <= L && (start-j*s) >= 0)
               {
                  int pos = start-j*s;
                  Curve nc = new Curve(j, i, dp[pos]);
                  while (fptr < bptr && dq[bptr-1].f(i) <= nc.f(i))
                     bptr--;
                  
                  dq[bptr++] = nc;
                  j++;
               }


               // Relax overtaken
               while (bptr-fptr > 1 && dq[fptr].f(i) <= dq[fptr+1].f(i))
                  fptr++;

               // Update solution
               if (fptr < bptr)
               {
                  int pos = start-i*s;
                  for (int pp=fptr; pp<bptr; pp++)
                     dp[pos] = Math.max(dp[pos], dq[pp].f(i));
               }
            }
         }
      }
   
      out.printf("%d", dp[1]);
      for (int x=2; x<=K; x++)
         out.printf(" %d", dp[x]);
      out.println();
   }
}

class Curve
{
   static long[] sum;
   int a, b;
   long c;

   Curve(int aa, int bb, long cc)
   {
      a=aa; b=bb; c=cc; 
   }

   long f(int x)
   {
      return x >= a ? 0 : (sum[a-x-1] + c);
   }
}

class FastScanner{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    
    public FastScanner(InputStream stream)
    {
        this.stream = stream;
    }
    
    int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars){
            curChar = 0;
            try{
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }
    
    boolean isSpaceChar(int c)
    {
        return c==' '||c=='\n'||c=='\r'||c=='\t'||c==-1;
    }
    
    boolean isEndline(int c)
    {
        return c=='\n'||c=='\r'||c==-1;
    }
    
    int nextInt()
    {
        return Integer.parseInt(next());
    }
    
    long nextLong()
    {
        return Long.parseLong(next());
    }
    
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
    
    String next(){
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isSpaceChar(c));
        return res.toString();
    }
    
    String nextLine(){
        int c = read();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do{
            res.appendCodePoint(c);
            c = read();
        }while(!isEndline(c));
        return res.toString();
    }
}