rt

#include <bits/stdc++.h>

using namespace std;
const int N = 2000010, MOD = 1000000;

int n;
int root1, idx1, root2, idx2;
struct Node
{
    int l, r;
    int key, val;
    int size;
} person[N], pet[N];
int x, y, z;

int get_node(Node tr[], int key, int& idx)
{
    tr[ ++ idx] = {0, 0, key, rand(), 1};
    return idx;
}

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

void split(Node tr[], int p, int key, int& left, int& right)
{
    if (!p) left = right = 0;
    else
    {
        if (tr[p].key <= key)
        {
            left = p;
            split(tr, tr[p].r, key, tr[p].r, right);
        }
        else
        {
            right = p;
            split(tr, tr[p].l, key, left, tr[p].l);
        }
        pushup(tr, p);
    }
}

int merge(Node tr[], int left, int right)
{
    if (!left || !right) return left | right;
    if (tr[left].val >= tr[right].val)
    {
        tr[left].r = merge(tr, tr[left].r, right);
        pushup(tr, left);
        return left;
    }
    else
    {
        tr[right].l = merge(tr, left, tr[right].l);
        pushup(tr, right);
        return right;
    }
}

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

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

int get_key(Node tr[], int p, int rank)
{
    if (!p) return -1;
    int k = tr[tr[p].l].size + 1;
    if (rank == k) return tr[p].key;
    if (rank < k) return get_key(tr, tr[p].l, rank);
    return get_key(tr, tr[p].r, rank - k);
}

int get_prev(Node tr[], int key, int& root)
{
    split(tr, root, key, x, y);
    int res = get_key(tr, x, tr[x].size);
    root = merge(tr, x, y);
    return res;
}

int get_next(Node tr[], int key, int& root)
{
    split(tr, root, key - 1, x, y);
    int res = get_key(tr, y, 1);
    root = merge(tr, x, y);
    return res;
}

int main() 
{
    srand(time(nullptr));

    cin >> n;

    long long ans = 0LL;
    while (n -- )
    {
        int type, v; cin >> type >> v;
        if (type)
        {
            insert(person, v, root2, idx2);
            int a = get_prev(pet, v, root1), b = get_next(pet, v, root1);
            // cout << a << ' ' << b << ' ' << v << endl;
            if (a > 0 && v - a <= b - v)
            {
                ans = (long long)(ans + v - a) % MOD;
                remove(pet, a, root1), remove(person, v, root2);
            }
            else if (b > 0)
            {
                ans = (long long)(ans + b - v) % MOD;
                remove(pet, b, root1), remove(person, v, root2);
            }
        }
        else
        {
            insert(pet, v, root1, idx1);
            int a = get_prev(person, v, root2), b = get_next(person, v, root2);
            // cout << a << ' ' << b << ' ' << v << endl;
            if (a > 0 && v - a <= b - v)
            {
                ans = (long long)(ans + v - a) % MOD;
                remove(person, a, root2), remove(pet, v, root1);
            }
            else if (b > 0)
            {
                ans = (long long)(ans + b - v) % MOD;
                remove(person, b, root2), remove(pet, v, root1);
            }
        }
    }

    cout << ans << endl;

    return 0;
}