#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <array>
#include <climits>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <bitset>
#include <array>
#include <climits>

#pragma GCC optimize("O3")
#pragma GCC optimize ("unroll-loops")
#pragma GCC target("avx,avx2,fma")

#define ll long long
#define ld  double
using namespace std;

const int N = 5e2 + 5, lg = 19, mod = 998244353;
const int M = 1e6 + 5;
const int b = 31;

int n, r_x, r_y, d_x, d_y;
set<pair<int, int>> pos;

int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
//        down up right left

vector<string> ans = {"up", "down", "right", "left"};
vector<int> result;

void zo2(int dir) {
    result.push_back(dir);
    r_x += dx[dir];
    r_y += dy[dir];
    int x = r_x;
    int y = r_y;
    if (pos.find({x, y}) != pos.end()) {
        while (pos.find({x, y}) != pos.end()) {
            x += dx[dir];
            y += dy[dir];
        }
        pos.erase({r_x, r_y});
        if(make_pair(d_x, d_y) != make_pair(x, y)) pos.insert({x, y});
    }
}

void zo2(int dir, int cnt) {
    for (int i = 0; i < cnt; ++i) {
        zo2(dir);
    }
}

pair<int, int> getFar() {
    pair<int, int> ret;
    int cur_dis = INT_MIN;
    for (auto &i : pos) {
        auto t = abs(r_x - i.first);
        if (t > cur_dis) {
            cur_dis = t;
            ret = i;
        }
    }
    return ret;
}

void run(int dir, int kam) {
    // run => down 0, 1
    int t1 = 0, t2 = 1;
    if(dir < 2) {
        t1 = 2;
        t2 = 3;
    }

    int revDir;
    if(dir == 0) revDir = 1;
    else if(dir == 1) revDir = 0;
    else if(dir == 2) revDir = 3;
    else revDir = 2;

    zo2(t1);
    zo2(dir, kam);
    zo2(t2);
    zo2(revDir, kam);
}

int main() {
    ios_base::sync_with_stdio(0);cin.tie(0);
    cin >> n;
    cin >> r_x >> r_y >> d_x >> d_y;
    for (int i = 0; i < n; ++i) {
        int x, y;
        cin >> x >> y;
        pos.emplace(x, y);
    }
    while (r_x != d_x || r_y != d_y) {
        if (r_x != d_x) {
            zo2(2 + (r_x > d_x));
        } else {
            zo2((r_y > d_y));
        }
    }

    if (!pos.empty()) {
        int min_x, max_x, min_y, max_y;
        min_x = min_y = INT_MAX;
        max_x = max_y = INT_MIN;
        for (auto &i : pos) {
            min_x = min(i.first, min_x) - 5;
            max_x = max(i.first, max_x) + 5;
            min_y = min(i.second, min_y) - 5;
            max_y = max(i.second, max_y) + 5;
        }
        if (min_x < r_x) {
            run(1, r_x - min_x + 1);
        }
        if (min_y < r_y) {
            run(3, r_y - min_y + 1);
        }
        if (max_x > r_x) {
            run(0, max_x - r_x + 1);
        }
        if (max_y > r_y) {
            run(2, max_y - r_y + 1);
        }
    }

    while (!pos.empty()) {
        auto cell = getFar();
        int diff = cell.first - r_x;
        if (diff >= 0) {
            zo2(2, diff + 1);
        } else {
            zo2(3, -diff + 1);
        }
        int diff_y = cell.second - r_y;
        if (diff_y >= 0) {
            zo2(0, diff_y);
        } else {
            zo2(1, -diff_y);
        }
        if (diff >= 0) {
            zo2(3, diff);
        } else {
            zo2(2, -diff);
        }
        if (diff_y >= 0) {
            zo2(0, 1);
        } else {
            zo2(1, 1);
        }
        if (diff >= 0) {
            zo2(3, 1);
        } else {
            zo2(2, 1);
        }
        if (diff_y >= 0) {
            zo2(1, diff_y + 1);
        } else {
            zo2(0, -diff_y + 1);
        }
    }
    for (auto &i: result) {
        cout << ans[i] << '\n';
    }
    return 0;
}