# -*- coding: utf-8 -*-

import bisect

import heapq

import math

import random

import sys

from collections import Counter, defaultdict, deque

from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal

from functools import lru_cache, reduce

from itertools import combinations, combinations_with_replacement, product, permutations

from operator import add, mul, sub



sys.setrecursionlimit(100000)

input = sys.stdin.readline

INF = 2**62-1



def read_int():

    return int(input())





def read_int_n():

    return list(map(int, input().split()))





def read_float():

    return float(input())





def read_float_n():

    return list(map(float, input().split()))





def read_str():

    return input().strip()





def read_str_n():

    return list(map(str, input().split()))





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap







@mt

def slv(N, T, AB):

    AB.sort(key=lambda x: x[0])



    dp = [[0] * (N+1) for _ in range(T)]



    for t in range(T):

        for i in range(len(AB)):

            a, b = AB[i]

            if t >= a:

                dp[t][i] = max(dp[t-a][i-1] + b, dp[t-1][i], dp[t][i-1])

            else:

                dp[t][i] = max(dp[t-1][i], dp[t][i-1])



    B = list(map(lambda x: x[1], AB))

    B.append(0)

    

    dp = dp[-1]

    dp.pop()

    ans = 0

    for i, v in enumerate(dp):

        ans = max(ans, v + max(B[i+1:]))

    return ans





def main():

    N, T = read_int_n()

    AB = [read_int_n() for _ in range(N)]

    print(slv(N, T, AB))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-

import sys

# sys.setrecursionlimit(10**6)

# buff_readline = sys.stdin.buffer.readline

buff_readline = sys.stdin.readline

readline = sys.stdin.readline



INF = 2**62-1





def read_int():

    return int(buff_readline())





def read_int_n():

    return list(map(int, buff_readline().split()))





def read_float():

    return float(buff_readline())





def read_float_n():

    return list(map(float, buff_readline().split()))





def read_str():

    return readline().strip()





def read_str_n():

    return readline().strip().split()





def error_print(*args):

    print(*args, file=sys.stderr)





def mt(f):

    import time



    def wrap(*args, **kwargs):

        s = time.time()

        ret = f(*args, **kwargs)

        e = time.time()



        error_print(e - s, 'sec')

        return ret



    return wrap





class Mod:

    def __init__(self, m):

        self.m = m



    def add(self, a, b):

        return (a + b) % self.m



    def sub(self, a, b):

        return (a - b) % self.m



    def mul(self, a, b):

        return ((a % self.m) * (b % self.m)) % self.m



    def div(self, a, b):

        return self.mul(a, pow(b, self.m-2, self.m))



    def pow(self, a, b):

        return pow(a, b, self.m)





class Bisect:

    def __init__(self, func):

        self.__func = func



    def bisect_left(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if self.__func(mid) < x:

                lo = mid+1

            else:

                hi = mid

        return lo



    def bisect_right(self, x, lo, hi):

        while lo < hi:

            mid = (lo+hi)//2

            if x < self.__func(mid):

                hi = mid

            else:

                lo = mid+1

        return lo





@mt

def slv(N, T, AB):

    AB.sort()

    memo = [-1] * (T + max(a for a, b in AB))



    memo[0] = 0

    for a, b in AB:

        nm = memo[:]

        for t in range(T):

            if memo[t] == -1:

                continue

            nm[t+a] = max(nm[t+a], memo[t]+b)

        memo = nm

    # print(memo)

    return max(memo)





def main():

    N, T = read_int_n()

    AB = [read_int_n() for _ in range(N)]

    print(slv(N, T, AB))





if __name__ == '__main__':

    main()

# -*- coding: utf-8 -*-
import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(input())


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


def read_float():
    return float(input())


def read_float_n():
    return list(map(float, input().split()))


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


@mt
def slv(N, T, AB):
    AB.sort(key=lambda x: x[0])
    dp = [[0] * (N + 1) for _ in range(T)]
    for t in range(T):
        for i in range(len(AB)):
            a, b = AB[i]
            if t >= a:
                dp[t][i] = max(dp[t - a][i - 1] + b, dp[t - 1][i], dp[t][i - 1])
            else:
                dp[t][i] = max(dp[t - 1][i], dp[t][i - 1])
    B = list(map(lambda x: x[1], AB))
    B.append(0)
    dp = dp[-1]
    dp.pop()
    ans = 0
    for i, v in enumerate(dp):
        ans = max(ans, v + max(B[i + 1 :]))
    return ans


def main():
    N, T = read_int_n()
    AB = [read_int_n() for _ in range(N)]
    print(slv(N, T, AB))


if __name__ == "__main__":
    main()

# -*- coding: utf-8 -*-
import sys

# sys.setrecursionlimit(10**6)
# buff_readline = sys.stdin.buffer.readline
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2**62 - 1


def read_int():
    return int(buff_readline())


def read_int_n():
    return list(map(int, buff_readline().split()))


def read_float():
    return float(buff_readline())


def read_float_n():
    return list(map(float, buff_readline().split()))


def read_str():
    return readline().strip()


def read_str_n():
    return readline().strip().split()


def error_print(*args):
    print(*args, file=sys.stderr)


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()
        error_print(e - s, "sec")
        return ret

    return wrap


class Mod:
    def __init__(self, m):
        self.m = m

    def add(self, a, b):
        return (a + b) % self.m

    def sub(self, a, b):
        return (a - b) % self.m

    def mul(self, a, b):
        return ((a % self.m) * (b % self.m)) % self.m

    def div(self, a, b):
        return self.mul(a, pow(b, self.m - 2, self.m))

    def pow(self, a, b):
        return pow(a, b, self.m)


class Bisect:
    def __init__(self, func):
        self.__func = func

    def bisect_left(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if self.__func(mid) < x:
                lo = mid + 1
            else:
                hi = mid
        return lo

    def bisect_right(self, x, lo, hi):
        while lo < hi:
            mid = (lo + hi) // 2
            if x < self.__func(mid):
                hi = mid
            else:
                lo = mid + 1
        return lo


@mt
def slv(N, T, AB):
    AB.sort()
    memo = [-1] * (T + max(a for a, b in AB))
    memo[0] = 0
    for a, b in AB:
        nm = memo[:]
        for t in range(T):
            if memo[t] == -1:
                continue
            nm[t + a] = max(nm[t + a], memo[t] + b)
        memo = nm
    # print(memo)
    return max(memo)


def main():
    N, T = read_int_n()
    AB = [read_int_n() for _ in range(N)]
    print(slv(N, T, AB))


if __name__ == "__main__":
    main()

-import bisect -import heapq -import math -import random -from collections import Counter, defaultdict, deque -from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal -from functools import lru_cache, reduce -from itertools import combinations, combinations_with_replacement, product, permutations -from operator import add, mul, sub -sys.setrecursionlimit(100000) -input = sys.stdin.readline +# sys.setrecursionlimit(10**6) +# buff_readline = sys.stdin.buffer.readline +buff_readline = sys.stdin.readline +readline = sys.stdin.readline -    return int(input()) +    return int(buff_readline()) -    return list(map(int, input().split())) +    return list(map(int, buff_readline().split())) -    return float(input()) +    return float(buff_readline()) -    return list(map(float, input().split())) +    return list(map(float, buff_readline().split())) -    return input().strip() +    return readline().strip() -    return list(map(str, input().split())) +    return readline().strip().split() +class Mod: +    def __init__(self, m): +        self.m = m + +    def add(self, a, b): +        return (a + b) % self.m + +    def sub(self, a, b): +        return (a - b) % self.m + +    def mul(self, a, b): +        return ((a % self.m) * (b % self.m)) % self.m + +    def div(self, a, b): +        return self.mul(a, pow(b, self.m - 2, self.m)) + +    def pow(self, a, b): +        return pow(a, b, self.m) + + +class Bisect: +    def __init__(self, func): +        self.__func = func + +    def bisect_left(self, x, lo, hi): +        while lo < hi: +            mid = (lo + hi) // 2 +            if self.__func(mid) < x: +                lo = mid + 1 +            else: +                hi = mid +        return lo + +    def bisect_right(self, x, lo, hi): +        while lo < hi: +            mid = (lo + hi) // 2 +            if x < self.__func(mid): +                hi = mid +            else: +                lo = mid + 1 +        return lo + + -    AB.sort(key=lambda x: x[0]) -    dp = [[0] * (N + 1) for _ in range(T)] -    for t in range(T): -        for i in range(len(AB)): -            a, b = AB[i] -            if t >= a: -                dp[t][i] = max(dp[t - a][i - 1] + b, dp[t - 1][i], dp[t][i - 1]) -            else: -                dp[t][i] = max(dp[t - 1][i], dp[t][i - 1]) -    B = list(map(lambda x: x[1], AB)) -    B.append(0) -    dp = dp[-1] -    dp.pop() -    ans = 0 -    for i, v in enumerate(dp): -        ans = max(ans, v + max(B[i + 1 :])) -    return ans +    AB.sort() +    memo = [-1] * (T + max(a for a, b in AB)) +    memo[0] = 0 +    for a, b in AB: +        nm = memo[:] +        for t in range(T): +            if memo[t] == -1: +                continue +            nm[t + a] = max(nm[t + a], memo[t] + b) +        memo = nm +    # print(memo) +    return max(memo)