using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;


namespace AtCoder
{

    struct mint : IEquatable<mint>
    {
        //static uint mod = 998244353;
        static uint mod = 1000000007;
        uint _v;

        public mint(long v) : this((uint)(v % mod + mod)){ }
        private mint(uint v)
        {
            _v = v < mod ? v : (v - mod);
        }

        public static void SetMod(uint p)
        {
            mod = p;
        }

        public static mint operator+(mint lhs, mint rhs)
        {
            return new mint(lhs._v + rhs._v);
        }
        public static mint operator-(mint lhs, mint rhs)
        {
            return new mint(lhs._v + mod - rhs._v);
        }
        public static mint operator*(mint lhs, mint rhs)
        {
            return new mint((uint)((ulong)lhs._v * rhs._v % mod));
        }
        public static mint operator/(mint lhs, mint rhs)
        {
            return lhs * rhs.Inv();
        }
        public static mint operator^(mint x, int n)
        {
            return Pow(x, n);
        }
        public static bool operator==(mint l, mint r)
        {
            return l._v == r._v;
        }
        public static bool operator!=(mint l, mint r)
        {
            return !(l == r);
        }
        public static bool operator<(mint l, mint r)
        {
            return l._v < r._v;
        }
        public static bool operator>(mint l, mint r)
        {
            return l._v > r._v;
        }

        public static mint Pow(mint x, int n)
        {
            var r = new mint(1);
            while (n > 0)
            {
                if ((n & 1) > 0) r *= x;
                x *= x;
                n >>= 1;
            }
            return r;
        }
        
        public mint Pow(int n)
        {
            return Pow(this, n);
        }
        public mint Inv()
        {
            return Pow((int)mod - 2);
        }
        
        public bool Equals(mint o)
        {
            return this == o;
        }

        public override bool Equals(object obj)
        {
            if (obj is mint) return this == (mint)obj;
            else return false;
        }
        public override int GetHashCode()
        {
            return _v.GetHashCode();
        }
        public override string ToString()
        {
            return _v.ToString();
        }

        public static implicit operator mint(int i)
        {
            return new mint(i);
        }
        public static implicit operator mint(long i)
        {
            return new mint(i);
        }


        private static mint[] _fact;
        public static void SetFact(int n)
        {
            _fact = new mint[n + 1];
            _fact[0] = 1;
            for (int i = 1; i < n + 1; i++)
            {
                _fact[i] = _fact[i - 1] * i;
            }
        }
        public static mint Fact(int n)
        {
            if (_fact == null || _fact.Length < n)
            {
                SetFact(n * 2);
            }
            return _fact[n];
        }

        public static mint Combination(int n, int r)
        {
            return Fact(n) / (Fact(n - r) * Fact(r));
        }
    }
    static class Extensions
    {
        public static int LowerBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c > 0) l = m + 1;
                else  r = m;
            }

            return l;
        }
        public static int UpperBound<T>(this IList<T> list, T value, IComparer<T> comp=null)
        {
            if (comp == null) comp = Comparer<T>.Default;

            var l = 0;
            var r = list.Count;

            while (l < r)
            {
                var m = (l + r) / 2;
                var c = comp.Compare(value, list[m]);
                if (c >= 0) l = m + 1;
                else r = m;
            }

            return r;
        }
    }
    class Program
    {
		static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
        static int[] ReadIntArray(int n)
        {
            var a = new int[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadInt();
            }
            return a;
        }
        static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
        static long[] ReadLongArray(int n)
        {
            var a = new long[n];
            for (int i = 0; i < n; i++)
            {
                a[i] = ReadLong();
            }
            return a;
        }
        static List<T> ReadObjects<T>(int n, Func<int[], T> creator)
        {
            var l = new List<T>(n);

            for (int i = 0; i < n; i++)
            {
                var a = ReadIntArray();
                l.Add(creator(a));
            }

            return l;
        }

        static int[,] ReadMatrix(int n, int m)
        {
            var r = new int[n, m];
            for (int i = 0; i < n; i++)
            {
                var a = ReadIntArray();
                for (int j = 0; j < m; j++)
                {
                    r[i, j] = a[j];
                }
            }
            return r;
        }
		
        public static int[] ZAlgotithm(string s)
        {
            var len = s.Length;

            var a = new int[len];
            a[0] = len;
            var i = 1;
            var j = 0;
            while (i < len)
            {
                while (i + j < len && s[j] == s[i + j]) j++;
                a[i] = j;

                if (j == 0)
                {
                    i++;
                    continue;
                }

                var k = 1;
                while (i + k < len && k + a[k] < j)
                {
                    a[i + k] = a[k];
                    k++;
                }
                i += k;
                j -= k;
            }

            return a;
        }
        public class MaxHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;
			
            public int Count
            {
                get
                {
                    return _list.Count;
                }
            }
            public MaxHeap() : this(0) { }
            public MaxHeap(int capacity, Comparison<T> comp=null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }
            
            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }

            
            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c > 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if(j+1 < _list.Count && _comp.Compare(_list[j], _list[j+1]) < 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) < 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }
            public MaxHeap<T> Copy(Comparison<T> comp=null)
            {
                var c = new MaxHeap<T>(0, comp);
                c._list = _list.ToList();

                return c;
            }
            public MaxHeap(List<T> list)
            {
                _list = list;

                _comp = Comparer<T>.Default;
            }

            public List<T> GetList()
            {
                return _list;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
		
        public class MinHeap<T> : IEnumerable<T>
        {
            private List<T> _list;
            private Comparer<T> _comp;

            public int Count
            {
                get
                {
                    return _list.Count;
                }
            }

            public MinHeap() : this(0) { }
            public MinHeap(int capacity, Comparison<T> comp = null)
            {
                _list = new List<T>(capacity);

                if (comp == null)
                {
                    _comp = Comparer<T>.Default;
                }
                else
                {
                    _comp = Comparer<T>.Create(comp);
                }
            }

            public void Push(T elem)
            {
                Upheap(elem);
            }

            public T Pop()
            {
                return Downheap();
            }

            public T Peek()
            {
                return _list[0];
            }


            private void Swap(int i, int j)
            {
                var a = _list[j];
                _list[j] = _list[i];
                _list[i] = a;
            }

            private void Upheap(T elem)
            {
                _list.Add(elem);
                var i = _list.Count - 1;

                while (true)
                {
                    if (i == 0) return;
                    var j = (i - 1) / 2;

                    var e = _list[i];
                    var p = _list[j];

                    var c = _comp.Compare(e, p);
                    if (c < 0)
                    {
                        Swap(i, j);
                        i = j;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            private T Downheap()
            {
                var result = _list[0];

                var last = _list.Count - 1;
                Swap(0, last);
                _list.RemoveAt(last);
                if (_list.Count == 0) return result;

                var i = 0;
                while (true)
                {
                    if (i == _list.Count - 1) return result;
                    var p = _list[i];

                    var j = i * 2 + 1;
                    if (j >= _list.Count) return result;

                    if (j + 1 < _list.Count && _comp.Compare(_list[j], _list[j + 1]) > 0)
                    {
                        j++;
                    }

                    if (_comp.Compare(_list[i], _list[j]) > 0)
                    {
                        Swap(i, j);
                        i = j;
                    }
                    else
                    {
                        return result;
                    }
                }
            }

            public MinHeap<T> Copy(Comparison<T> comp = null)
            {
                var c = new MinHeap<T>(0, comp);
                c._list = _list.ToList();

                return c;
            }
            public MinHeap(List<T> list)
            {
                _list = list;

                _comp = Comparer<T>.Default;
            }

            public List<T> GetList()
            {
                return _list;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _list.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
        class InputLine
        {
            private string[] _inputs;
            private int _index = 0;

            InputLine(string input)
            {
                _inputs = input.Split();
                _index = 0;
            }

            public static InputLine Read()
            {
                return new InputLine(Console.ReadLine());
            }

            public int NextInt()
            {
                return int.Parse(_inputs[_index++]);
            }
            public long NextLong()
            {
                return long.Parse(_inputs[_index++]);
            }
            public double NextDouble()
            {
                return double.Parse(_inputs[_index++]);
            }
        }
        public static int GCD(int x, int y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        public static long GCD(long x, long y)
        {
            var a = Math.Max(x, y);
            var b = x + y - a;

            while (b != 0)
            {
                var c = b;
                b = a % b;
                a = c;
            }

            return a;
        }
        static long ModPower(long x, long y, long mod)
        {
            var bytes = BitConverter.GetBytes(y);
            var bits = new System.Collections.BitArray(bytes);

            var max2 = 0;
            for (int i = bits.Length - 1; i >= 0; i--)
            {
                if (bits[i])
                {
                    max2 = i;
                    break;
                }
            }

            long result = 1;
            for (int i = max2; i >= 0; i--)
            {
                result = (result * result) % mod;
                if (bits[i])
                {
                    result = (result * x) % mod;
                }
            }

            return result;
        }
        
        static long ModFact(long n, long mod)
        {
            long result = 1;

            for (int i = 1; i <= n; i++)
            {
                result = result * i % mod;
            }
            return result;
        }
		
        static long ModAdd(long x, long y, long mod)
        {
            return ((x % mod) + (y % mod)) % mod;
        }
        static long ModMul(long x, long y, long mod)
        {
            return ((x % mod) * (y % mod)) % mod;
        }

        static long ModDiv(long x, long y, long mod)
        {
            //フェルマーの小定理より、a^(-1) = a^(p-2)
            return ModMul(x, ModPower(y, mod - 2, mod), mod);
        }
        static long ModComb(long n, long r, long mod)
        {
            long numerator = 1;
            for (int i = 0; i < r; i++)
            {
                numerator = ModMul(numerator, n - i, mod);
            }

            long denominator = ModFact(r, mod);

            return ModDiv(numerator, denominator, mod);
        }
        class Graph
        {
            private int _size;
            private List<int>[] _map;

            public IEnumerable<int> this[int i]
            {
                get
                {
                    if (_map[i] == null) return Enumerable.Empty<int>();
                    return _map[i];
                }
            }

            public Graph(int size)
            {
                _size = size;
                _map = new List<int>[size];
            }

            public void Add(int from, int to)
            {
                if (_map[from] == null)
                {
                    _map[from] = new List<int>();
                }
                _map[from].Add(to);
            }
        }
        class Graph<T>
        {
            private int _size;
            private List<T>[] _edges;

            public Graph(int size)
            {
                _size = size;
                _edges = new List<T>[size];
            }

            public List<T> this[int i]
            {
                get
                {
                    if (_edges[i] == null) _edges[i] = new List<T>();
                    return _edges[i];
                }
            }
        }
        static Graph<T> NewGraph<T>(int size, T template)
        {
            return new Graph<T>(size);
        }
        static List<T> NewList<T>(T template)
        {
            return new List<T>();
        }
        static T[] NewArray<T>(int size, T template)
        {
            return new T[size];
        }
        static long p1097 = 1000000007;
        static void Main(string[] args)
        {
			//↓

            var nt = ReadIntArray();
            var n = nt[0];
            var t = nt[1];

            var abs = ReadObjects(n, ab => new { a = ab[0], b = ab[1] });
            abs.Sort((x, y) => x.a.CompareTo(y.a));
            
            var dp = new int[t];
            var max = 0;
            for (int i = 0; i < n; i++)
            {
                var ab = abs[i];
                for (int j = t - 1; j >= 0; j--)
                {
                    var newt = j + ab.a;
                    var newm = dp[j] + ab.b;

                    max = Math.Max(max, newm);
                    if (newt >= t) continue;
                    dp[newt] = Math.Max(dp[newt], newm);
                }
            }

            Console.WriteLine(max);


			//↑
        }

	}
}

Measured memory_bytes: 13396