#include <iostream>
#include <algorithm>
#include <cmath>

using namespace std;

#define MAXN 80005
#define INF 2147483647
#define mod 1000000

struct node
{
    int l, r;
    int key, val;
    int size;
} tr_cus[MAXN], tr_pet[MAXN];

int root_cus, root_pet;
int idx_cus, idx_pet;
int sum_cus, sum_pet;
int x, y, z, ans;
long long tot = 0;

int get_node(node tr[], int key, int &idx)
{
    tr[++ idx].key = key;
    tr[idx].val = rand() % INF;
    tr[idx].size = 1;
    return idx;
}

void pushup(node tr[], int p)
{
    tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + 1;
}

void split_key(node tr[], int p, int key, int &x, int &y)
{
    if(!p)
    {
        x = y = 0;
        return;
    }

    if(tr[p].key <= key)
    {
        x = p;
        split_key(tr, tr[p].r, key, tr[p].r, y);
    }
    else
    {
        y = p;
        split_key(tr, tr[p].l, key, x, tr[p].l);
    }

    pushup(tr, p);
} 

void split_size(node tr[], int p, int size, int &x, int &y)
{
    if(!p)
    {
        x = y = 0;
        return;
    }

    if(tr[tr[p].l].size < size)
    {
        x = p;
        split_size(tr, tr[p].r, size - tr[tr[p].l].size - 1, tr[p].r, y);
    }
    else
    {
        y = p;
        split_size(tr, tr[p].l, size, x, tr[p].l);
    }

    pushup(tr, p);
}

int merge(node tr[], int x, int y)
{
    if(!x || !y)  return x + y;

    if(tr[x].val < tr[y].val)
    {
        tr[x].r = merge(tr, tr[x].r, y);
        pushup(tr, x);
        return x;
    }
    else
    {
        tr[y].l = merge(tr, x, tr[y].l);
        pushup(tr, y);
        return y;
    }
}

void insert(node tr[], int &root, int key, int &idx)
{
    z = get_node(tr, key, idx);
    split_key(tr, root, key, x, y);
    root = merge(tr, merge(tr, x, z), y);
}

void remove(node tr[], int &root, int key)
{
    split_key(tr, root, key, x, y);
    split_key(tr, x, key - 1, x, z);
    z = merge(tr, tr[z].l, tr[z].r);
    root = merge(tr, merge(tr, x, z), y);
}

int get_prev(node tr[], int &root, int key)
{
    split_key(tr, root, key, x, y);
    split_size(tr, x, tr[x].size - 1, x, z);
    ans = tr[z].key;
    root = merge(tr, merge(tr, x, z), y);
    return ans;
}

int get_next(node tr[], int &root, int key)
{
    split_key(tr, root, key - 1, x, y);
    split_size(tr, y, 1, z, y);
    ans = tr[z].key;
    root = merge(tr, x, merge(tr, z, y));
    return ans;
} 

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

    for(int i = 1; i <= n; i ++)
    {
        int a, b;
        cin >> a >> b;

        if(a == 0) //pet
        {
            if(!sum_cus)  insert(tr_pet, root_pet, b, idx_pet), sum_pet ++;
            else
            {
                int p = get_prev(tr_cus, root_cus, b), q = get_next(tr_cus, root_cus, b);
                if(abs(b - p) <= abs(b - q))
                {
                    tot += abs(b - p);
                    remove(tr_cus, root_cus, p);
                    sum_cus --;
                }
                else
                {
                    tot += abs(b - q);
                    remove(tr_cus, root_cus, q);
                    sum_cus --;
                }
            }
        }
        else //customer
        {
            if(!sum_pet)  insert(tr_cus, root_cus, b, idx_cus), sum_cus ++;
            else
            {
                int p = get_prev(tr_pet, root_pet, b), q = get_next(tr_pet, root_pet, b);
                if(abs(b - p) <= abs(b - q))
                {
                    tot += abs(b - p);
                    remove(tr_pet, root_pet, p);
                    sum_pet --;
                }
                else
                {
                    tot += abs(b - q);
                    remove(tr_pet, root_pet, q);
                    sum_pet --;
                }   
            }
        }
        //cout << tot << " " << idx_cus << " " << idx_pet << endl;
        tot = tot % mod;
    }

    cout << tot << endl;
    return 0;
}