#include <iostream>
#include <vector>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    int pred = 1, sum = 0; sum+= a[1] * p[1];
    for (int i = 2; i <= n; i++) {
        if (pred > p[i]) {
            pred = p[i];
        }
        s+= p[i] * a[i];
    }
    cout << sum;
}


#include <iostream>
#include <vector>
using namespace std;
int main () {
    int n, s = 0, min = 1000000, mn = 0, fl = 0;
    cin >> n;
    vector <int> a(n); vector <int> p(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
        if (p[i] < min) {
            min = p[i]; mn = i;
        }
    }
    for (int i = 1; i <= n; i++) {
        if (fl == 0)
        if (i != mn) {
            s+= a[i] * p[i];
    } else { for (int j = i; j <= n; j++) { s+= a[j] * min; } fl++; }
    }
    cout << s;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <int> pf(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    for (int i = 1; i <= n; i++) {
        pf[i] = p[i];
    }
    sort (pf);
    int min = 0;
    for (int i = 1; i <= n; i++) {
        if (p[i] == pf[1]) {
            min = i;
            break;
        }
    }
    int sum = 0, fl = 0;
    for (int i = 1; i <= n; i++) {
        if (i != min && fl == 0) {
            sum+= a[i] * p[i];
        } else { for (int j = i; j <= n; j++) { sum+= a[j] * min; } fl++; }
    }
    cout << sum;
}


#include <iostream>
#include <vector>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    int pred = 1, sum = 0; sum+= a[1] * p[1];
    for (int i = 2; i <= n; i++) {
        if (pred > p[i]) {
            pred = p[i];
        }
        sum+= p[i] * a[i];
    }
    cout << sum;
}


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n; cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    int price, sum = 0; price = p[1];
    for (int i = 1; i <= n; i++) {
        price = min(price, p[i]);
        sum+= price * a[i];
    }
    cout << sum;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, sum = 0;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n + 1);
    vector <bool> used (n, false);
    for (int i = 0; i < n; i++) {
        cin >> a[i];
        cin >> p[i];
    }
    for (int i = 0; i < n; i++) {
        if (p[i] < p[i + 1]) {
            if (used[i] == false) {
            sum+= ((a[i] + a[i + 1]) * p[i]);
            used[i + 1] = true;
           } else { sum+= (a[i] * p[i]); }
        }
        else {
            if (used[i] == false) {
        sum+= (a[i] * p[i]);
            }
       }
    } sum++; sum--;
      cout << sum;
    return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, sum = 0;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <bool> used (n, false);
    for (int i = 0; i < n; i++) {
        cin >> a[i]; cin >> p[i];
    }
    for (int i = 0; i < n; i++) {
        if (p[i] < p[i + 1]) {
            if (used[i] == false) {
            sum+= ((a[i] + a[i + 1]) * p[i]);
            used[i + 1] = true;
           } else { sum+= (a[i] * p[i]); }
        }
        else {
            if (used[i] == false)
        sum+= (a[i] * p[i]);
       }
    }
      cout << sum;
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n; cin >> n;
    vector <int> a(n+1);
    vector <int> p(n+1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    int price, sum = 0; price = p[1];
    for (int i = 1; i <= n; i++) {
        price = min(price, p[i]);
        sum+= price * a[i];
    }
    cout << sum;
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <int> pf(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    for (int i = 1; i <= n; i++) {
        pf[i] = p[i];
    }
    sort (pf.begin(), pf.end());
    int min = 0;
    for (int i = 1; i <= n; i++) {
        if (p[i] == pf[1]) {
            min = i;
            break;
        }
    }
    int sum = 0, fl = 0;
    for (int i = 1; i <= n; i++) {
        if (i != min && fl == 0) {
            sum+= a[i] * p[i];
        } else { for (int j = i; j <= n; j++) { sum+= a[j] * min; } fl++; }
    }
    cout << sum;
}


#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n, sum = 0;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <bool> used (n, false);
    for (int i = 0; i < n; i++) {
        cin >> a[i]; cin >> p[i];
    }
    for (int i = 0; i < n; i++) {
        if (p[i] < p[i + 1]) {
            if (used[i] == false) {
            sum+= ((a[i] + a[i + 1]) * p[i]);
            used[i + 1] = true;
           } else { sum+= (a[i] * p[i]); }
        }
        else {
            if (used[i] == false) {
        sum+= (a[i] * p[i]);
            }
       }
    }
      cout << sum;
    return 0;
}


#include <iostream>
#include <vector>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <int> pf(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    for (int i = 1; i <= n; i++) {
        pf[i] = p[i];
    }
    sort (pf);
    int min = 0;
    for (int i = 1; i <= n; i++) {
        if (p[i] == pf[1]) {
            min = i;
            break;
        }
    }
    for (int i = 1; i <= n; i++) {
        if (i != max && fl == 0) {
            sum+= a[i] * p[i];
        } else { for (int j = i; j <= n; j++) { sum+= a[j] * min; } fl++; }
    }
    sum++; sum--;
    cout << sum;
}


#include <iostream>
#include <vector>
using namespace std;
int main () {
    int n;
    cin >> n;
    vector <int> a(n);
    vector <int> p(n);
    vector <int> pf(n);
    for (int i = 1; i <= n; i++) {
        cin >> a[i] >> p[i];
    }
    for (int i = 1; i <= n; i++) {
        pf[i] = p[i];
    }
    sort (pf);
    int min = 0;
    for (int i = 1; i <= n; i++) {
        if (p[i] == pf[1]) {
            min = i;
            break;
        }
    }
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        if (i != min && fl == 0) {
            sum+= a[i] * p[i];
        } else { for (int j = i; j <= n; j++) { sum+= a[j] * min; } fl++; }
    }
    cout << sum;
}


#include <bits/stdc++.h>

using namespace std;

const int NN=1000000;
int n,a[NN],p[NN];
int main () {
#ifndef ONLINE_JUDGE
  freopen("in.in","r",stdin);
  freopen("out.out","w",stdout);
#endif
  cin>>n;
  for(int i=0; i<n; i++) {
    scanf("%d%d",a+i,p+i);
  }
  int ans=0,j;
  for(int i=0; i<n; i=j) {
    j=i;
    while(p[i]<=p[j]) ans+=p[i]*a[j], j++;
  }
  cout<<ans<<endl;
	return 0;
}


#include <bits/stdc++.h>

using namespace std;
int a[100100];
int b[100100];

int main() {
#ifndef ONLINE_JUDGE
	freopen("in.in", "r", stdin);
	freopen("out.out", "w", stdout);
#endif
	int n;
	int sum=0;
	int sn=0;
	cin>>n;
    int cnt=111;
	for(int i=1;i<=n;i++){
		cin>>a[i]>>b[i];
	}
	for(int i=1;i<=n;i++){
		if(b[i]<b[i+1])
		b[i+1]=b[i];
	}
	for(int i=1;i<=n;i++){
			sum+=(a[i]*b[i]);

	}
	cout<<sum<<endl;

	return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define NN 100100
int a[NN],b[NN];
int main() {
    int n,ans=0;scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d%d",&a[i],&b[i]);
    for(int i=2;i<=n;i++){
        b[i]=min(b[i],b[i-1]);
    }
    for(int i=1;i<=n;i++){
        ans+=a[i]*b[i];
    }
    printf("%d",ans);
    return 0;
}


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100]; // amount of meat needed in that day
    int p[100]; // cost of meal in that day
    int b[100];

    cin >> n;

    int sum = 0;
    int c = 100000000;

    for(int i = 0 ;i < n ;i++)
    {
        cin >> a[i] >> p[i];
        if(i == 0)
        {
            sum += (a[i] * p[i]);
            c = p[0];
        }
        else
        {
         if(c <= p[i])
         {
             sum += a[i] * c;
         }
         else
         {
             c = p[i];
             sum += a[i] * c;
         }

        }

    }

    cout << sum;

    return 0;

    }


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100]; // amount of meat needed in that day
    int p[100]; // cost of meal in that day

    cin >> n;

    int sum = 0;
    int c = 100000000;

    for(int i = 0 ;i < n ;i++)
    {
        scanf("%d %d" ,&a[i] ,&p[i]);

        if(i == 0)
        {
            sum += (a[i] * p[i]);
            c = p[0];
        }
        else
        {
         if(c <= p[i])
         {
             sum += a[i] * c;
         }
         else
         {
             c = p[i];
             sum += a[i] * c;
         }

        }

    }

    printf("%d" ,sum);

    return 0;

    }


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100000]; // amount of meat needed in that day
    int p[100000]; // cost of meal in that day

    cin >> n;

    int sum = 0;
    int c = 100000000;

    for(int i = 0 ;i < n ;i++)
    {
        scanf("%d %d" ,&a[i] ,&p[i]);

        if(i == 0)
        {
            sum += (a[i] * p[i]);
            c = p[0];
        }
        else
        {
         if(c <= p[i])
         {
             sum += a[i] * c;
         }
         else
         {
             c = p[i];
             sum += a[i] * c;
         }

        }

    }

    printf("%d" ,sum);

    return 0;

    }


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100]; // amount of meat needed in that day
    int p[100]; // cost of meal in that day

    cin >> n;

    int sum = 0;
    int c = 100000000;

    for(int i = 0 ;i < n ;i++)
    {
        cin >> a[i] >> p[i];
        if(i == 0)
        {
            sum += (a[i] * p[i]);
            c = p[0];
        }
        else
        {
         if(c <= p[i])
         {
             sum += a[i] * c;
         }
         else
         {
             c = p[i];
             sum += a[i] * c;
         }

        }

    }

    printf("%d" ,sum);

    return 0;

    }


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100]; // amount of meat needed in that day
    int p[100]; // cost of meal in that day
    int b[100];

    memset(b ,1 ,sizeof(b));

    cin >> n;

    for(int i = 0 ;i < n ;i++)
    {
        cin >> a[i] >> p[i];
    }

    int sum = 0;

     for(int i = 0 ;i < n ;i++)
    {
        if(b[i] != false)
        {
        sum += (a[i] * p[i]);

        for(int j = i + 1 ;j < n ;j++)
        {
                if(p[i] >= p[j])
                    break;

                if(p[i] < p[j])
                {
                    b[j] = false;
                    sum += (p[i] * a[j]);

                }
        }

        }

    }

    cout << sum;

    return 0;

    }


/* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    struct Entry
    {

        string name,phone;
        Entry *next;

    };

    Entry *GetNewEntry()
    {
        Entry *newEntry = new Entry;
        cout << "please Enter Name \n";
        cin >> newEntry->name;
        cout << "please Enter phone Number \n";
        cin >> newEntry->phone;
        newEntry->next =NULL;
        return newEntry;

    }

    void printEntry(Entry *p)
    {

        cout <<"Name: "<< p->name << "\n" << "Phone Number: " <<p->phone << endl;

    }

    int fractinol(int n , int exp)
    {

        if(exp == 0)
            return 1;

        return n * fractinol(n ,exp - 1);

    }

    Entry *buildList(int a)
    {
        Entry *list = NULL;

        while(a > 0)
        {
            Entry *newOne = GetNewEntry();
            newOne->next = list;
            list = newOne;
            a--;
        }
        return list;
    }

    void print(Entry *n)
    {

        if(n != NULL)
        {
            printEntry(n);
            print(n->next);

        }
    }

    void deallocate(Entry *n)
    {
        deallocate(n->next);
        delete n;
    }

    int count(Entry *n)
    {

       if(n == NULL)
        return 0;

       return 1 + count(n->next);

    }

    void swap(int &x ,int  &y)
    {
        int temp;

        temp = x;
        x = y;
        y = temp;

    }

    int c;
    int rc;

   int cache[1000][1000];

   int ks(int W ,int w[1000] ,int v[1000] ,int n)
   {
            if(cache[W][n] != -1)
      {
     c++;
     return cache[W][n];
     }

       if(n == 0)
       {
           return 0 ;
       }

       if(w[n - 1] > W || W == 0)
       {
           return ks(W , w , v ,n -1);
       }

       return cache[W][n] = max( v[n - 1] + ks(W - w[n -1] ,w ,v ,n - 1) ,ks(W , w , v ,n -1) );

   }

    /* A Naive recursive implementation of 0-1 Knapsack problem */
#include<stdio.h>
#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include<set>
#include<map>
#include <cmath>
#include<stack>
#include<queue>
#include <utility>
#include<vector>
#include<cmath>
#include<list>
#include<iomanip>
#include<cstdlib>
using namespace std;

//    int vertices;
//    int edges;
//    int v1 ,v2;
//    int z;
//    vector<list<int>> adjancenyList(vertices + 1);
//
//    cin >> vertices >> edges;
//
//    for(int i = 1 ;i <  edges ;i++)
//    {
//        cin >> v1  >> v2;
//        adjancenyList[v1].push_back(v2);
//        adjancenyList[v2].push_back(v1);
//
//    }
//

//
//       vector<int> a[100];
//       bool visited[100];
//       int lvl[100];
//
//      void dfs(int i)
//      {
//           visited[i] true;
//
//              for(int j = 0 ;j < ;j++)
//              {
//                  if(visited[a[i][j]]== false)
//                  {
//                      dfs(a[i][j]);
//                  }
//
//              }
//
//          }
//
//      }
//
//
//
//
//      void bfs(int s)
//      {
//
//          queue<int> q;
//
//          q.push(s);
//          lvl[s] = 0;
//          visited[s] = true;
//
//          while(!q.empty(s))
//          {
//              int p = q.front();
//              q.pop();
//              for(int i = 0 ;i < a[p].size() ;i++)
//              {
//                  if(visited[a[p][i] == false)
//                  {
//                      q.push(a[p][i]);
//                      visited[[a[p][i]] = true;
//                      lvl[a[p][i]] = lvl[p] + 1;
//                  }
//
//              }
//
//
//          }
//
//
//
//
//      }

//       int main()
//      {

//       int nodes;
//       int edges;
//       int x , y;
//
//       memset(visited , 0 ,sizeof(visited));
//
//       cin >> nodes >> edges;
//
//
//       for(int i = 0 ;i < edges ;i++)
//       {
//           cin >> x >> y;
//           a[x].push_back(y);
//
//       }
//

    int main(){

//    int n;
//    int sum = 0;
//    int l = 0;
//
//    cin >> n;
//
//
//    for(int i = 1 ;i <= n ;i++)
//    {
//        sum += i;
//        if(sum <= n)
//        {
//            l++;
//        }
//        else
//            break;
//    }
//
//    cout << l;
//

//    int s[4]; // colors of horseshoes valera has
//
//
//     for(int i = 0 ;i < 4 ;i++)
//    {
//        cin >> s[i];
//    }
//
//
//    int c = 0;
//    int ma = 0;
//
//
//
//
//    for(int i = 0 ;i < 4 ;i++)
//    {
//        for(int j = 0 ;j < 4 ;j++)
//        {
//            if(s[i] == s[j] && i != j)
//            {
//                c++;
//            }
//        }
//        if(c > ma)
//            ma = c;
//        c = 0;
//    }
//
//    cout << ma;
//

    int n; // number of days
    int a[100]; // amount of meat needed in that day
    int p[100]; // cost of meal in that day
    int b[100];

    memset(b ,1 ,sizeof(b));

    cin >> n;

    int sum = 0;
    int c = 100000000;

    for(int i = 0 ;i < n ;i++)
    {
        cin >> a[i] >> p[i];
        if(i == 0)
        {
            sum += (a[i] * p[i]);
            c = p[0];
        }
        else
        {
         if(c <= p[i])
         {
             sum += a[i] * c;
         }
         else
         {
             c = p[i];
             sum += a[i] * c;
         }

        }

    }

    cout << sum;

    return 0;

    }


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }
              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;

                  i=j+1;
                  j=n+1;
                  u=0;
              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0,k;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<=p[i+1])
        {
           u=u+a[i];
k=i;
          for(j=i+1;j<=n;j++)
          {
              if(p[k]<=p[j])
              {
                  u=u+a[j];
              }
              if(j>=n)
              {
                 val=u*p[k];
                  add+=val;
                  i=n+1;

              }
              if(p[k]>p[j])
              {
                  val=u*p[k];
                  add+=val;

                  i=j-1;
                  j=n+1;
                  u=0;
              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }

              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;
                  if(j==(n-1))
                  {
                      val=a[i]*p[i];
                      add+=val;
                  }

                  i=j-1;
                  j=n+1;
                  u=0;
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }

              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;
                  if(j==(n-1))
                  {
                      val=a[i]*p[i];
                      add+=val;
                  }

                  i=j-1;
                  j=n+1;
                  u=0;
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }
              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;

                  i=j-1;
                  j=n+1;
                  u=0;
              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }
    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<p[i+1])
        {
          val=(a[i]+a[i+1])*p[i];
          add+=val;
          i++;

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<=p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<=p[j])
              {
                  u=u+a[j];
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }
              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;

                  i=j+1;
                  j=n+1;
                  u=0;
              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<=p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<=p[j])
              {
                  u=u+a[j];
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }
              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;

                  i=j-1;
                  j=n+1;
                  u=0;
              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<=p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }

              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;
                  if(j==(n-1))
                  {
                      val=a[i]*p[i];
                      add+=val;
                  }

                  i=j-1;
                  j=n+1;
                  u=0;
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<p[j])
              {
                  u=u+a[j];
              }

              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;

                  i=j-1;
                  j=n+1;
                  u=0;
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,val,i,add=0,j,u=0;
    int a[100005];
    int p[100005];
    cin>>n;
    for(i=1;i<=n;i++)
    {
        cin>>a[i]>>p[i];
    }

    for(i=1;i<=n;i++)
    {
        if(p[i]>p[i+1])
        {
            val=p[i]*a[i];
            add+=val;
        }
        else if(p[i]<=p[i+1])
        {
           u=u+a[i];
          for(j=i+1;j<=n;j++)
          {
              if(p[i]<=p[j])
              {
                  u=u+a[j];
              }

              if(p[i]>p[j])
              {
                  val=u*p[i];
                  add+=val;
                  if(j==(n-1))
                  {
                      val=a[i]*p[i];
                      add+=val;
                  }

                  i=j-1;
                  j=n+1;
                  u=0;
              }
              if(j>=n)
              {
                 val=u*p[i];
                  add+=val;
                  i=n+1;

              }

          }

        }
    }
    cout<<add<<endl;
    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class data
{
public:
        int a;
    int p;
};

class defineSort
{
public:
    bool operator()(data const &x1, data const &x2)
    {
        if(x1.a < x2.a)return true;

        else if(x1.a == x2.a)
        {
            if(x1.p < x2.p)return true;

            else return false;
        }

        else return false;
    }

};

int main()
{
   int n;
   cin >> n;

    int Min = 9999999;
    int MinII;
    long long Tot = 0;
    data d1;
    vector <data> vec;
   for(int i=0;i<n;i++)
   {
        int ii;
        cin >> ii;

        int x;
        cin >> x;

        d1.a = ii;
        d1.p = x;
        vec.push_back(d1);

//        arr[ii] = x;
//
        if(x < Min)
        {
            Min = x;
            MinII = ii;
        }
//        Tot+=ii;

   }
//   sort(vec.begin(),vec.end(),defineSort());

    long long ansTot = 0;
//    long long ansTot2 = 0;
    int Cnt = 0;
    data d2;
    Min = 9999999;
   for(int i=0;i<vec.size();i++)
   {
        d2 = vec[i];
        Min = min(Min,d2.p);
        ansTot += d2.a * Min;
//        cout << d2.a << endl;
//        if(d2.a < MinII)
//        {
//            ansTot += d2.a * d2.p;
////            ansTot2 += d2.a * d2.p;
//        }
//        else
//        {
//            ansTot += d2.a * Min;
////            ansTot2 += d2.a * d2.p;
//        }
   }
   cout << ansTot << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class data
{
public:
        int a;
    int p;
};

class defineSort
{
public:
    bool operator()(data const &x1, data const &x2)
    {
        if(x1.a < x2.a)return true;

        else if(x1.a == x2.a)
        {
            if(x1.p < x2.p)return true;

            else return false;
        }

        else return false;
    }

};

int main()
{
   int n;
   cin >> n;

    int Min = 9999999;
    int MinII;
    long long Tot = 0;
    data d1;
    vector <data> vec;
   for(int i=0;i<n;i++)
   {
        int ii;
        cin >> ii;

        int x;
        cin >> x;

        d1.a = ii;
        d1.p = x;
        vec.push_back(d1);

//        arr[ii] = x;
//
        if(x < Min)
        {
            Min = x;
            MinII = ii;
        }
//        Tot+=ii;

   }
   sort(vec.begin(),vec.end(),defineSort());

    long long ansTot = 0;
//    long long ansTot2 = 0;
    int Cnt = 0;
    data d2;
    Min = 9999999;
   for(int i=0;i<vec.size();i++)
   {
        d2 = vec[i];
        Min = min(Min,d2.p);
        ansTot += d2.a * Min;
//        cout << d2.a << endl;
//        if(d2.a < MinII)
//        {
//            ansTot += d2.a * d2.p;
////            ansTot2 += d2.a * d2.p;
//        }
//        else
//        {
//            ansTot += d2.a * Min;
////            ansTot2 += d2.a * d2.p;
//        }
   }
   cout << ansTot << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class data
{
public:
        int a;
    int p;
};

class defineSort
{
public:
    bool operator()(data const &x1, data const &x2)
    {
        if(x1.a < x2.a)return true;

        else if(x1.a == x2.a)
        {
            if(x1.p < x2.p)return true;

            else return false;
        }

        else return false;
    }

};

int main()
{
   int n;
   cin >> n;

    int Min = 9999999;
    int MinII;
    long long Tot = 0;
    data d1;
    vector <data> vec;
   for(int i=0;i<n;i++)
   {
        int ii;
        cin >> ii;

        int x;
        cin >> x;

        d1.a = ii;
        d1.p = x;
        vec.push_back(d1);

//        arr[ii] = x;
//
        if(x < Min)
        {
            Min = x;
            MinII = ii;
        }
//        Tot+=ii;

   }
   sort(vec.begin(),vec.end(),defineSort());

    long long ansTot = 0;
    long long ansTot2 = 0;
    int Cnt = 0;
    data d2;
   for(int i=0;i<vec.size();i++)
   {
        d2 = vec[i];
//        cout << d2.a << endl;
        if(d2.a < MinII)
        {
            ansTot += d2.a * d2.p;
            ansTot2 += d2.a * d2.p;
        }
        else
        {
            ansTot += d2.a * Min;
            ansTot2 += d2.a * d2.p;
        }
   }
   cout << min(ansTot,ansTot2) << endl;

    return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

class data
{
public:
        int a;
    int p;
};

class defineSort
{
public:
    bool operator()(data const &x1, data const &x2)
    {
        if(x1.a < x2.a)return true;

        else if(x1.a == x2.a)
        {
            if(x1.p < x2.p)return true;

            else return false;
        }

        else return false;
    }

};

int main()
{
   int n;
   cin >> n;

    int Min = 9999999;
    int MinII;
    long long Tot = 0;
    data d1;
    vector <data> vec;
   for(int i=0;i<n;i++)
   {
        int ii;
        cin >> ii;

        int x;
        cin >> x;

        d1.a = ii;
        d1.p = x;
        vec.push_back(d1);

//        arr[ii] = x;
//
        if(x < Min)
        {
            Min = x;
            MinII = ii;
        }
//        Tot+=ii;

   }
   sort(vec.begin(),vec.end(),defineSort());

    long long ansTot = 0;
    int Cnt = 0;
    data d2;
   for(int i=0;i<vec.size();i++)
   {
        d2 = vec[i];
//        cout << d2.a << endl;
        if(d2.a < MinII)
        {
            ansTot += d2.a * d2.p;
        }
        else
        {
            ansTot += d2.a * Min;
        }
   }
   cout << ansTot << endl;

    return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include <clocale>
#include <bitset>
#include <cstring>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <stack>
#include <list>
#include <functional>
#include <unordered_set>

using namespace std;

#pragma comment (linker, "/STACK:667177216")
#define ll long long
#define LL long long
#define ull unsigned long long
#define ld long double
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pb push_back
const ll mod = 1000000007;
#define INF (int)(2e9)
#define LINF (ll)(4e18)
#define forit(mas) for(auto(it)=(mas).begin();(it)!=(mas).end();(it)++)
#define pii pair<int,int>

ll n, m, k;
ll t[8000000];
ll a[1000000];

void build(int v, int tl, int tr) {
	if (tl == tr) {
		t[v] = a[tl];
	}
	else {
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

void update(int v, int tl, int tr, int pos, ll val) {
	if (tl == tr) {
		a[tl] = val;
		t[v] = val;
	}
	else {
		int tm = (tl + tr) / 2;
		if (pos <= tm) update(2 * v, tl, tm, pos, val);
		else update(2 * v + 1, tm + 1, tr, pos, val);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

int traverse(int v, int tl, int tr, ll val) {
	if (tl == tr) return tl;
	int tm = (tl + tr) / 2;
	if (t[2 * v] >= val) return traverse(2 * v, tl, tm, val);
	else return traverse(2 * v + 1, tm + 1, tr, val);
}

int main() {

#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) a[i] = k;
	build(1, 0, n - 1);
	ll ans = 0;
	set<pair<int, int>>st;
	ll mx = -4e18;
	ll cur = 0;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		int f = 1;
		if (t[1] < x) {
			mx = max(mx, cur);
			while (st.size() && t[1] < x) {
				auto v = *st.begin();
				auto it = st.end();
				update(1, 0, n - 1, v.second, k);
				it--;
				st.erase(it);
			}
			if (st.empty() && t[1] < x) f = 1;
		}
		if (f) break;
		cur++;
		int pos = traverse(1, 0, n - 1, x);
		st.insert({ i, pos });
		a[pos] -= x;
		update(1, 0, n - 1, pos, a[pos] - x);
	}
	cout << mx;
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include <clocale>
#include <bitset>
#include <cstring>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <stack>
#include <list>
#include <functional>
#include <unordered_set>

using namespace std;

#pragma comment (linker, "/STACK:667177216")
#define ll long long
#define LL long long
#define ull unsigned long long
#define ld long double
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pb push_back
const ll mod = 1000000007;
#define INF (int)(2e9)
#define LINF (ll)(4e18)
#define forit(mas) for(auto(it)=(mas).begin();(it)!=(mas).end();(it)++)
#define pii pair<int,int>

ll n, m, k;
ll t[8000000];
ll a[1000000];

void build(int v, int tl, int tr) {
	if (tl == tr) {
		t[v] = a[tl];
	}
	else {
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

void update(int v, int tl, int tr, int pos, ll val) {
	if (tl == tr) {
		a[tl] = val;
		t[v] = val;
	}
	else {
		int tm = (tl + tr) / 2;
		if (pos <= tm) update(2 * v, tl, tm, pos, val);
		else update(2 * v + 1, tm + 1, tr, pos, val);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

int traverse(int v, int tl, int tr, ll val) {
	if (tl == tr) return tl;
	int tm = (tl + tr) / 2;
	if (t[2 * v] >= val) return traverse(2 * v, tl, tm, val);
	else return traverse(2 * v + 1, tm + 1, tr, val);
}

int main() {

#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) a[i] = k;
	build(1, 0, n - 1);
	ll ans = 0;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		if (t[1] < x) {
			break;
		}
		ans++;
		int pos = traverse(1, 0, n - 1, x);
		update(1, 0, n - 1, pos, a[pos] - x);
	}
	cout << ans;
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include <clocale>
#include <bitset>
#include <cstring>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <stack>
#include <list>
#include <functional>
#include <unordered_set>

using namespace std;

#pragma comment (linker, "/STACK:667177216")
#define ll long long
#define LL long long
#define ull unsigned long long
#define ld long double
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pb push_back
const ll mod = 1000000007;
#define INF (int)(2e9)
#define LINF (ll)(4e18)
#define forit(mas) for(auto(it)=(mas).begin();(it)!=(mas).end();(it)++)
#define pii pair<int,int>

ll n, m, k;
ll t[8000000];
ll a[1000000];

void build(int v, int tl, int tr) {
	if (tl == tr) {
		t[v] = a[tl];
	}
	else {
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

void update(int v, int tl, int tr, int pos, ll val) {
	if (tl == tr) {
		a[tl] = val;
		t[v] = val;
	}
	else {
		int tm = (tl + tr) / 2;
		if (pos <= tm) update(2 * v, tl, tm, pos, val);
		else update(2 * v + 1, tm + 1, tr, pos, val);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

int traverse(int v, int tl, int tr, ll val) {
	if (tl == tr) return tl;
	int tm = (tl + tr) / 2;
	if (t[2 * v] >= val) return traverse(2 * v, tl, tm, val);
	else return traverse(2 * v + 1, tm + 1, tr, val);
}

int main() {

#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) a[i] = k;
	build(1, 0, n - 1);
	ll ans = 0;
	set<pair<int, int>>st;
	ll mx = -4e18;
	ll cur = 0;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		int f = 0;
		if (t[1] < x) {
			mx = max(mx, cur);
			while (st.size() && t[1] < x) {
				auto v = *st.begin();
				st.erase(st.begin());
				cur--;
				update(1, 0, n - 1, v.second, k);
			}
			if (st.empty() && t[1] < x) f = 1;
		}
		if (f) break;
		cur++;
		int pos = traverse(1, 0, n - 1, x);
		st.insert({ i, pos });
		update(1, 0, n - 1, pos, a[pos] - x);
	}
	mx = max(mx, cur);
	cout << mx;
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include <clocale>
#include <bitset>
#include <cstring>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <stack>
#include <list>
#include <functional>
#include <unordered_set>

using namespace std;

#pragma comment (linker, "/STACK:667177216")
#define ll long long
#define LL long long
#define ull unsigned long long
#define ld long double
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pb push_back
const ll mod = 1000000007;
#define INF (int)(2e9)
#define LINF (ll)(4e18)
#define forit(mas) for(auto(it)=(mas).begin();(it)!=(mas).end();(it)++)
#define pii pair<int,int>

ll n, m, k;
ll t[8000000];
ll a[1000000];

void build(int v, int tl, int tr) {
	if (tl == tr) {
		t[v] = a[tl];
	}
	else {
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

void update(int v, int tl, int tr, int pos, ll val) {
	if (tl == tr) {
		a[tl] = val;
		t[v] = val;
	}
	else {
		int tm = (tl + tr) / 2;
		if (pos <= tm) update(2 * v, tl, tm, pos, val);
		else update(2 * v + 1, tm + 1, tr, pos, val);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

int traverse(int v, int tl, int tr, ll val) {
	if (tl == tr) return tl;
	int tm = (tl + tr) / 2;
	if (t[2 * v] >= val) return traverse(2 * v, tl, tm, val);
	else return traverse(2 * v + 1, tm + 1, tr, val);
}

int main() {

#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) a[i] = k;
	build(1, 0, m - 1);
	ll ans = 0;
	set<pair<int, int>>st;
	ll mx = -4e18;
	ll cur = 0;
	for (int i = 0; i < n; i++) {
		int x;
		cin >> x;
		int f = 0;
		if (t[1] < x) {
			mx = max(mx, cur);
			while (st.size() && t[1] < x) {
				auto v = *st.begin();
				st.erase(st.begin());
				cur--;
				update(1, 0, m - 1, v.second, k);
			}
			if (st.empty() && t[1] < x) f = 1;
		}
		if (f) break;
		cur++;
		int pos = traverse(1, 0, m - 1, x);
		st.insert({ i, pos });
		update(1, 0, m - 1, pos, a[pos] - x);
	}
	mx = max(mx, cur);
	cout << mx;
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <set>
#include <algorithm>
#include <map>
#include <queue>
#include <clocale>
#include <bitset>
#include <cstring>
#include <memory.h>
#include <numeric>
#include <iomanip>
#include <stack>
#include <list>
#include <functional>
#include <unordered_set>

using namespace std;

#pragma comment (linker, "/STACK:667177216")
#define ll long long
#define LL long long
#define ull unsigned long long
#define ld long double
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pb push_back
const ll mod = 1000000007;
#define INF (int)(2e9)
#define LINF (ll)(4e18)
#define forit(mas) for(auto(it)=(mas).begin();(it)!=(mas).end();(it)++)
#define pii pair<int,int>

ll n, m, k;
ll t[8000000];
ll a[1000000];

void build(int v, int tl, int tr) {
	if (tl == tr) {
		t[v] = a[tl];
	}
	else {
		int tm = (tl + tr) / 2;
		build(2 * v, tl, tm);
		build(2 * v + 1, tm + 1, tr);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

void update(int v, int tl, int tr, int pos, ll val) {
	if (tl == tr) {
		a[tl] = val;
		t[v] = val;
	}
	else {
		int tm = (tl + tr) / 2;
		if (pos <= tm) update(2 * v, tl, tm, pos, val);
		else update(2 * v + 1, tm + 1, tr, pos, val);
		t[v] = max(t[2 * v], t[2 * v + 1]);
	}
}

int traverse(int v, int tl, int tr, ll val) {
	if (tl == tr) return tl;
	int tm = (tl + tr) / 2;
	if (t[2 * v] >= val) return traverse(2 * v, tl, tm, val);
	else return traverse(2 * v + 1, tm + 1, tr, val);
}

int main() {

#ifdef _DEBUG
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ios::sync_with_stdio(false);
	cin.tie(0);
	cin >> n >> m >> k;
	for (int i = 0; i < m; i++) a[i] = k;
	build(1, 0, m - 1);
	ll ans = 0;
	set<pair<int, int>>st;
	ll mx = -4e18;
	ll cur = 0;
	for (int i = 0; i < n; i++) {
		ll x;
		cin >> x;
		int f = 0;
		if (t[1] < x) {
			mx = max(mx, cur);
			while (st.size() && t[1] < x) {
				auto v = *st.begin();
				st.erase(st.begin());
				cur--;
				update(1, 0, m - 1, v.second, k);
			}
			if (st.empty() && t[1] < x) f = 1;
		}
		if (f) break;
		cur++;
		int pos = traverse(1, 0, m - 1, x);
		st.insert({ i, pos });
		update(1, 0, m - 1, pos, a[pos] - x);
	}
	mx = max(mx, cur);
	cout << mx;
	return 0;
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,last=0,ans=0;
ll a[maxn];

bool check(int sta)
{
	int cnt=1,cur=k;
	per(i,sta,n){
		if(cur>=a[i]){
			cur-=a[i];
		}else cur=k-a[i],cnt++;
	}
	return cnt<=m;
}

int main()
{
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n) scanf("%d",&a[i]);

	int l=1,r=n+1,mid;
	while(l<r){
		int mid=(l+r)>>1;
		if(check(mid)) r=mid;
		else l=mid+1;
	}
	printf("%d\n",n-l+1);
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,last=0,ans=0;
ll a[maxn],sum[maxn];

int main()
{
	sum[0]=(ll)0;
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n){
		scanf("%lld",&a[i]);
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i+ans-1<=n;i++){
		int j,cnt=0;
		for(j=i;cnt<m;){
			j=upper_bound(sum+j,sum+1+n,sum[j-1]+k)-sum;
			cnt++;
		}
		ans=max(ans,j-i);
		last++;
	}
	printf("%d\n",ans);
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,last=0,ans=0;
ll a[maxn];

bool check(int k)
{
	int cnt=0,cur=k;
	per(i,k,n){
		if(cur>=a[i]){
			cur-=a[i];
		}else cur=k,cnt++;
	}
	if(cur) cnt++;
	return cnt<=m;
}

int main()
{
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n) scanf("%d",&a[i]);

	int l=1,r=n+1,mid;
	while(l<r){
		int mid=(l+r)>>1;
		if(check(mid)) r=mid;
		else l=mid+1;
	}
	printf("%d\n",n-l+1);
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,a[maxn],ans=0;

int main()
{
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n) scanf("%d",&a[i]);

	int cnt=0,cur=0;
	rep(i,n,1){
		if(cur>=a[i]){
			ans++;
			cur-=a[i];
		}else cnt++,ans++,cur=k-a[i];

		if(cnt==m+1){
			ans--;
			break;
		}
	}

	printf("%d\n",ans);
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,last=0,ans=0;
ll a[maxn],sum[maxn];

int main()
{
	sum[0]=(ll)0;
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n){
		scanf("%lld",&a[i]);
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i+ans-1<=n;i++){
		int j,cnt=0;
		for(j=i;cnt<m&&j<n+1;){
			j=upper_bound(sum+j,sum+1+n,sum[j-1]+k)-sum;
			cnt++;
		}
		ans=max(ans,j-i);
		last++;
	}
	printf("%d\n",ans);
}


#include<bits/stdc++.h>

using namespace std;

#define pii pair<int, int>
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))
#define per(i,a,b) for(int i=a;i<=b;i++)
#define rep(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin(),x.end()
#define PER(i,x) for(auto i=x.begin();i!=x.end();i++)
#define PI acos(-1.0)
#define inf 0x3f3f3f3f
typedef long long ll;
const double eps=1.0e-5;
const int maxn=200000+10;

int n,m,k,last=0,ans=0;
ll a[maxn],sum[maxn];

int main()
{
	sum[0]=(ll)0;
	scanf("%d%d%d",&n,&m,&k);
	per(i,1,n){
		scanf("%lld",&a[i]);
		sum[i]=sum[i-1]+a[i];
	}
	for(int i=1;i<=n;i++){
		int j,cnt=0;
		for(j=i;cnt<m;){
			j=upper_bound(sum+j,sum+1+n,sum[j-1]+k)-sum;
			cnt++;
		}
		ans=max(ans,j-i);
		last++;
	}
	printf("%d\n",ans);
}


/*......................*/
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double   ld;
#define    f(i,j,n)                 for(int i = j; i <= n; i++)
#define    r(i,n,j)                 for(int i = n; i >= j; i--)
#define    mod                      1000000007
#define    speed                    ios_base::sync_with_stdio(false);
#define    up                       cin.tie(NULL);
#define    pb                       push_back
#define    mp                       make_pair
#define    T                        int t; cin >> t; while(t--)
#define    ff                       first
#define    ss                       second
#define    all(container)           container.begin() , container.end()
#define    sz(container)            (int)container.size()
#define    pii                      pair <int , int>
#define    pll                      pair <long long int , long long int>

map <int , int> id;

int main(){
    speed up
    int n, m , k; cin >> n >> m >> k;
    ll arr[n+5];
    ll cap[m+5] = {0};
    int ans = 0;
    queue <pii> qu;
    f(i,1,n){
        cin >> arr[i];
    }
    int j = 1;
    f(i,1,n){
        if(cap[j] + arr[i] <= k){
            cap[j]+=arr[i];
            qu.push({arr[i],j});
            ans++;
        }
        else{
            j++;
            if(j <= m){
                cap[j]+=arr[i];
                qu.push({arr[i],j});
                ans++;
            }
            else{
                j = 1;
                int x = (qu.front()).ss;
                cap[x]-=(qu.front().ff);
                qu.pop();
                ans--;
                i--;
            }
        }
    }
    cout << ans << '\n';
}


/*......................*/
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double   ld;
#define    f(i,j,n)                 for(int i = j; i <= n; i++)
#define    r(i,n,j)                 for(int i = n; i >= j; i--)
#define    mod                      1000000007
#define    speed                    ios_base::sync_with_stdio(false);
#define    up                       cin.tie(NULL);
#define    pb                       push_back
#define    mp                       make_pair
#define    T                        int t; cin >> t; while(t--)
#define    ff                       first
#define    ss                       second
#define    all(container)           container.begin() , container.end()
#define    sz(container)            (int)container.size()
#define    pii                      pair <int , int>
#define    pll                      pair <long long int , long long int>

map <int , int> id;

int main(){
    speed up
    int n, m , k; cin >> n >> m >> k;
    ll arr[n+5];
    ll cap[m+5] = {0};
    int ans = 0;
    queue <pii> qu;
    f(i,1,n){
        cin >> arr[i];
    }
    int j = 1;
    f(i,1,n){
        if(cap[j] + arr[i] <= k){
            cap[j]+=arr[i];
            qu.push({arr[i],j});
            ans++;
        }
        else{
            j++;
            if(j <= m && cap[j] + arr[i] <= k){
                cap[j]+=arr[i];
                qu.push({arr[i],j});
                ans++;
            }
            else if(j > m){
                j = 1;
                int x = (qu.front()).ss;
                cap[x]-=(qu.front().ff);
                qu.pop();
                i--;
                ans--;
            }
        }
    }
    //ans = sz(qu);
    cout << ans << '\n';
}


/*......................*/
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double   ld;
#define    f(i,j,n)                 for(int i = j; i <= n; i++)
#define    r(i,n,j)                 for(int i = n; i >= j; i--)
#define    mod                      1000000007
#define    speed                    ios_base::sync_with_stdio(false);
#define    up                       cin.tie(NULL);
#define    pb                       push_back
#define    mp                       make_pair
#define    T                        int t; cin >> t; while(t--)
#define    ff                       first
#define    ss                       second
#define    all(container)           container.begin() , container.end()
#define    sz(container)            (int)container.size()
#define    pii                      pair <int , int>
#define    pll                      pair <long long int , long long int>

map <int , int> id;

int main(){
    speed up
    int n, m , k; cin >> n >> m >> k;
    ll arr[n+5];
    ll cap[m+5] = {0};
    int ans = 0;
    queue <pii> qu;
    f(i,1,n){
        cin >> arr[i];
    }
    int j = 1;
    f(i,1,n){
        if(cap[j] + arr[i] <= k){
            cap[j]+=arr[i];
            qu.push({arr[i],j});
        }
        else{
            j++;
            if(j <= m && cap[j] + arr[i] <= k){
                cap[j]+=arr[i];
                qu.push({arr[i],j});
            }
            else if(j > m){
                j = 1;
                int x = (qu.front()).ss;
                cap[x]-=(qu.front().ff);
                qu.pop();
                i--;
            }
        }
    }
    ans = sz(qu);
    cout << ans << '\n';
}


/*......................*/
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double   ld;
#define    f(i,j,n)                 for(int i = j; i <= n; i++)
#define    r(i,n,j)                 for(int i = n; i >= j; i--)
#define    mod                      1000000007
#define    speed                    ios_base::sync_with_stdio(false);
#define    up                       cin.tie(NULL);
#define    pb                       push_back
#define    mp                       make_pair
#define    T                        int t; cin >> t; while(t--)
#define    ff                       first
#define    ss                       second
#define    all(container)           container.begin() , container.end()
#define    sz(container)            (int)container.size()
#define    pii                      pair <int , int>
#define    pll                      pair <long long int , long long int>

map <int , int> id;

int main(){
    speed up
    int n, m , k; cin >> n >> m >> k;
    ll arr[n+5];
    ll cap[m+5] = {0};
    int ans = 0;
    queue <pii> qu;
    f(i,1,n){
        cin >> arr[i];
    }
    int j = 1;
    f(i,1,n){
        if(cap[j] + arr[i] <= k){
            cap[j]+=arr[i];
            qu.push({arr[i],j});
        }
        else{
            j++;
            if(j <= m && cap[j] + arr[i] <= k){
                cap[j]+=arr[i];
                qu.push({arr[i],j});
            }
            else{
                j = 1;
                int x = (qu.front()).ss;
                cap[x]-=(qu.front().ff);
                qu.pop();
                i--;
            }
        }
    }
    ans = sz(qu);
    cout << ans << '\n';
}


/*......................*/
#include <bits/stdc++.h>
using namespace std;

typedef long long int ll;
typedef long double   ld;
#define    f(i,j,n)                 for(int i = j; i <= n; i++)
#define    r(i,n,j)                 for(int i = n; i >= j; i--)
#define    mod                      1000000007
#define    speed                    ios_base::sync_with_stdio(false);
#define    up                       cin.tie(NULL);
#define    pb                       push_back
#define    mp                       make_pair
#define    T                        int t; cin >> t; while(t--)
#define    ff                       first
#define    ss                       second
#define    all(container)           container.begin() , container.end()
#define    sz(container)            (int)container.size()
#define    pii                      pair <int , int>
#define    pll                      pair <long long int , long long int>

int main(){
     speed up
     int n , m , k;
     cin >> n >> m >> k;
     int cap[m+5] = {0};
     vector <int> v(n);
     f(i,0,n-1)cin>>v[i];
     reverse(all(v));
     int ans = 0;
     int j = 1;
     f(i,0,n-1){
         if(cap[j]+v[i] <= k){
             ans++;
             cap[j]+=v[i];
         }
         else{
             j++;
             if(j > m){
                 break;
             }
             cap[j]+=v[i];
             ans++;
         }
     }
     cout << ans << '\n';
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#define Endl endl
#define masuk cout<<"masuk\n";

#define REPP(i,l,r,a) for(int i=l;i<=r;i+=a)
#define REP(i,l,r) REPP(i,l,r,1)
#define REVV(i,l,r,a) for(int i=l;i>=r;i-=a)
#define REV(i,l,r) REVV(i,l,r,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1);
const ll MOD = (ll)1e9+7;

void fast_io()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
}

int total[100050];
int arr[100050];

int main()
{
	//cek pas n nya 1
	//fast_io();
	//D

	int n,m,tot=0,temp,now=0,k,most=0,head,tail;

	cin>>n>>m>>k;
	FOR(i,n) arr[i]=0,total[i]=0;
	FOR(i,n)
	{
		cin>>temp;
		if(arr[now]+temp>k)
		{
			now++;
			total[now]++;
			arr[now]+=temp;
		}
		else
		{
			arr[now]+=temp;
			total[now]++;
		}
	}
	FOR(i,m)
	{
		tot += total[i];
	}
	head = m-1;
	tail = 0;
	most = max(most,tot);
	//cout<<tot<<" ";
	REP(i,head+1,now)
	{
		tot -= total[tail];
		tail++;
		tot += total[head];
		head++;
		most = max(most,tot);
		//cout<<tot<<" ";
	}
	cout<<most<<Endl;

	return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#define Endl endl
#define masuk cout<<"masuk\n";

#define REPP(i,l,r,a) for(int i=l;i<=r;i+=a)
#define REP(i,l,r) REPP(i,l,r,1)
#define REVV(i,l,r,a) for(int i=l;i>=r;i-=a)
#define REV(i,l,r) REVV(i,l,r,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1);
const ll MOD = (ll)1e9+7;

void fast_io()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
}

int arr[200050];

int main()
{
	//cek pas n nya 1
	//fast_io();
	//D

	int n,m,tot=0,now=0,k,most=0;

	cin>>n>>m>>k;
	FOR(i,n) cin>>arr[i];
	REV(i,n-1,0)
	{
		if(tot+arr[i]<=k)
		{
			most++;
			tot += arr[i];
		}
		else
		{
			m--;
			if(!m)break;
			most++;
			tot = arr[i];
		}
	}
	cout<<most<<Endl;

	return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#define Endl endl
#define masuk cout<<"masuk\n";

#define REPP(i,l,r,a) for(int i=l;i<=r;i+=a)
#define REP(i,l,r) REPP(i,l,r,1)
#define REVV(i,l,r,a) for(int i=l;i>=r;i-=a)
#define REV(i,l,r) REVV(i,l,r,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1);
const ll MOD = (ll)1e9+7;

void fast_io()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
}

int total[200050];
int arr[200050];

int main()
{
	//cek pas n nya 1
	//fast_io();
	//D

	int n,m,tot=0,temp,now=0,k,most=0,head,tail;

	cin>>n>>m>>k;
	FOR(i,n) arr[i]=0,total[i]=0;
	FOR(i,n)
	{
		cin>>temp;
		if(arr[now]+temp>k)
		{
			now++;
			total[now]++;
			arr[now]+=temp;
		}
		else
		{
			arr[now]+=temp;
			total[now]++;
		}
	}
	FOR(i,m)
	{
		tot += total[i];
	}
	head = m-1;
	tail = 0;
	most = max(most,tot);
	//cout<<tot<<" ";
	REP(i,head+1,now)
	{
		tot -= total[tail];
		tail++;
		tot += total[head];
		head++;
		most = max(most,tot);
		//cout<<tot<<" ";
	}
	cout<<most<<Endl;

	return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#define Endl endl
#define masuk cout<<"masuk\n";

#define REPP(i,l,r,a) for(int i=l;i<=r;i+=a)
#define REP(i,l,r) REPP(i,l,r,1)
#define REVV(i,l,r,a) for(int i=l;i>=r;i-=a)
#define REV(i,l,r) REVV(i,l,r,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1);
const ll MOD = (ll)1e9+7;

void fast_io()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
}

int total[200050];
int arr[200050];

int main()
{
	//cek pas n nya 1
	//fast_io();
	//D

	int n,m,tot=0,temp,now=0,k,most=0,head,tail;

	cin>>n>>m>>k;
	FOR(i,n) arr[i]=0,total[i]=0;
	FOR(i,n)
	{
		cin>>temp;
		if(arr[now]+temp>k)
		{
			now++;
			total[now]++;
			arr[now]+=temp;
		}
		else
		{
			arr[now]+=temp;
			total[now]++;
		}
	}
	FOR(i,m)
	{
		tot += total[i];
	}
	head = m-1;
	tail = 0;
	most = max(most,tot);
	REP(i,m,now)
	{
		tot -= total[tail];
		tail++;
		head++;
		tot += total[head];
		most = max(most,tot);
	}
	cout<<most<<Endl;

	return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<map>
#include<queue>

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>

#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define endl "\n"
#define Endl endl
#define masuk cout<<"masuk\n";

#define REPP(i,l,r,a) for(int i=l;i<=r;i+=a)
#define REP(i,l,r) REPP(i,l,r,1)
#define REVV(i,l,r,a) for(int i=l;i>=r;i-=a)
#define REV(i,l,r) REVV(i,l,r,1)

#define FOR(i,a) for(int i=0; i<a; i++)
#define FORD(i,a) for(int i=(int)a-1; i>=0; i--)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;

const int INF = (int)2e9;
const double EPS = (double)1e-9;
const double PI = (double)acos(-1);
const ll MOD = (ll)1e9+7;

void fast_io()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
}

int total[200050];
int arr[200050];

int main()
{
	//cek pas n nya 1
	//fast_io();
	//D

	int n,m,tot=0,temp,now=0,k,most=0,head,tail;

	cin>>n>>m>>k;
	FOR(i,n) arr[i]=0,total[i]=0;
	FOR(i,n)
	{
		cin>>temp;
		if(arr[now]+temp>k)
		{
			now++;
			total[now]++;
			arr[now]+=temp;
		}
		else
		{
			arr[now]+=temp;
			total[now]++;
		}
	}
	FOR(i,m)
	{
		tot += total[i];
	}
	head = m-1;
	tail = 0;
	most = max(most,tot);
	//cout<<tot<<" ";
	REP(i,head+1,now)
	{
		tot -= total[tail];
		tail++;
		head++;
		tot += total[head];
		most = max(most,tot);
		//cout<<tot<<" ";
	}
	cout<<most<<Endl;

	return 0;
}


#include <iostream>
int main()
{
    int n, m, k, b = 0;
    std::cin >> n >> m >> k;
    int a[n], *s = a;
    while (a > s - n)
        std::cin >> *s++;
    while (b -= *--s, s >= a && m || b >= 0)
        if (b < 0)
            (b = k - *s, m--);
    std::cout << a + n - s - 1;
}


#include <iostream>
int main()
{
    int n, m, k, i, b = 0;
    std::cin >> n >> m >> k;
    int a[n];
    for (i = 0; i < n; ++i)
        std::cin >> a[i];
    for (i = 0; i < n; ++i)
    {
        if (b < a[n - i - 1])
        {
            if (!m--)
                break;
            b = k;
        }
        b -= a[n - i - 1];
    }
    std::cout << i;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
      long long n,m,k;
      cin>>n>>m>>k;
      vector<int>v;
      for(int i=0;i<n;i++)
      {int a;
      cin>>a;
      v.push_back(a);
      }
      vector<int> v1;
      for(int i=n-1;i>=0;)
      { int sum=k;
      int c=0;
        while(sum>=v[i]&&i>=0)
        {
          sum-=v[i];
          c++;
          i--;
        }
        if(v1.size()==m)
        {
              break;
        }
        v1.push_back(c);
      }
      int sum=0;
      for(int i=0;i<v1.size();i++)
      {
            sum+=v1[i];
      }
      cout<<sum<<endl;
      return 0;
}