#include <cstdio>
#include <algorithm>
#include <vector>
#include <utility>
#define MAX 100100

using namespace std;
typedef long long ll;
typedef vector < int > vi;
typedef vector < pair < int, int > > vpii;
typedef vi::iterator viit;
typedef vpii::iterator vpiiit;

struct detektor {
	int p, c;
	friend inline bool operator<(const detektor &a, const detektor &b) {
		return a.p < b.p;
	}
};

struct Node {
	int a, b;
	int prop;
	int min;
	vpii v;
};

detektor det[MAX];
Node node[270000];
int n, m;
	
	
void construct( int x, int a, int b ) {
	Node *p = node + x;
	p->a = a;
	p->b = b;
	p->prop = 0;
	if ( a == b ) {
		p->min = det[a].c;
		p->v.push_back( make_pair( det[a].c, a ) );
	} else {
		construct( x * 2, a, (a + b) / 2);
		construct( x * 2 + 1, ( a + b ) / 2 + 1, b );
		p->min = min( node[x*2].min, node[x*2+1].min );
		p->v.reserve( node[x*2].v.size() + node[x*2+1].v.size() );
		p->v.insert( p->v.end(), node[x*2  ].v.begin(), node[x*2  ].v.end() );
		p->v.insert( p->v.end(), node[x*2+1].v.begin(), node[x*2+1].v.end() );
		sort( p->v.begin(), p->v.end() );
	}
}

int qa, qb, qv;
vi *qvec;

int _query( int x ) {
	Node *p = node + x;
//	printf("x=%d [%d %d] [%d %d] min=%d prop=%d\n", x, p->a, p->b, qa, qb, p->min, p->prop);
	if ( p->a >= qa && p->b <= qb ) return p->min - p->prop;
	if ( p->a > qb || p->b < qa ) return 2000000000;
	return min( _query( x * 2 ), _query( x * 2 + 1 ) ) - p->prop;
}

inline int query_min( int a, int b ) {
	qa = a;
	qb = b;
	return _query( 1 );
}

void _dec_all( int x ) {
	Node *p = node + x;
	if ( p->a >= qa && p->b <= qb ) { p->prop += qv; return; }
	if ( p->a > qb || p->b < qa ) return;
	_dec_all( x * 2 );
	_dec_all( x * 2 + 1 );
}

inline void dec_all( int a, int b, int value ) {
	qa = a;
	qb = b;
	qv = value;
	_dec_all( 1 );
}


void _find_zeroes( int x, int prop ) {
	Node *p = node + x;
	if ( p->a >= qa && p->b <= qb ) {
		vpiiit A = lower_bound( p->v.begin(), p->v.end(), make_pair( prop + p->prop, 0 ) );
		vpiiit B = lower_bound( p->v.begin(), p->v.end(), make_pair( prop + p->prop, 2000000000 ) );
//		printf("x=%d [%d %d] [%d %d]\n", x, p->a, p->b, qa, qb);
//		for ( vpiiit it = p->v.begin(); it != p->v.end(); ++it )
//			printf("[%d %d] ", it->first, it->second);
//		printf("\n");
		for ( vpiiit it = A; it != B; ++it )
			qvec->push_back( it->second );
		return;
	}
	if ( p->a > qb || p->b < qa ) return;
	_find_zeroes( x * 2, prop + p->prop );
	_find_zeroes( x * 2 + 1, prop + p->prop );
}

void find_zeroes( int a, int b, vi *output ) {
	qa = a;
	qb = b;
	qvec = output;
	qvec->clear();
	_find_zeroes( 1, 0 );
	sort( output->begin(), output->end() );
}

ll solve( int a, int b ) {
//	printf("A=%d B=%d\n", a, b);
	if ( a > b ) return 0;
	
	int del = query_min( a, b );
	dec_all( a, b, del );
//	printf("del=%d\n", del);
	
	vi zeroes;
	find_zeroes( a, b, &zeroes );
//	for ( int i = 0; i < zeroes.size(); ++i )
//		printf("zero = %d\n", zeroes[i]);
//	printf("\n");
	
	ll result = del;
	
	int i, last = a;
	for ( i = 0; i < zeroes.size(); ++i ) {
		result += solve( last, zeroes[i] - 1 );
		last = zeroes[i] + 1;
	}
	result += solve( last, b );
	
	return result;
}

int main(void) {
	int i;
	scanf("%d%d", &n, &m);
	for ( i = 0; i < n; ++i )
		scanf("%d%d", &det[i].p, &det[i].c);
	
	
	sort( det, det + n );
	construct( 1, 0, n-1 );
	
	printf("%lld\n", solve( 0, n-1 ));
	return 0;
}