Problem: cf1201_e1
Difficulty: medium
Categories: graph, game
Time limit: 3000 ms, memory limit: 256 MB

This problem only differs from the next problem in constraints.

This is an interactive problem.

Alice and Bob are playing a game on the chessboard of size $n \times m$ where $n$ and $m$ are even. The rows are numbered from $1$ to $n$ and the columns are numbered from $1$ to $m$. There are two knights on the chessboard. A white one initially is on the position $(x_1, y_1)$, while the black one is on the position $(x_2, y_2)$. Alice will choose one of the knights to play with, and Bob will use the other one.

The Alice and Bob will play in turns and whoever controls the white knight starts the game. During a turn, the player must move their knight adhering the chess rules. That is, if the knight is currently on the position $(x, y)$, it can be moved to any of those positions (as long as they are inside the chessboard):

 $(x+1, y+2)$, $(x+1, y-2)$, $(x-1, y+2)$, $(x-1, y-2)$,

$(x+2, y+1)$, $(x+2, y-1)$, $(x-2, y+1)$, $(x-2, y-1)$.

We all know that knights are strongest in the middle of the board. Both knight have a single position they want to reach:

* the owner of the white knight wins if it captures the black knight or if the white knight is at $(n/2, m/2)$ and this position is not under attack of the black knight at this moment;
* The owner of the black knight wins if it captures the white knight or if the black knight is at $(n/2+1, m/2)$ and this position is not under attack of the white knight at this moment.

Formally, the player who captures the other knight wins. The player who is at its target square ($(n/2, m/2)$ for white, $(n/2+1, m/2)$ for black) and this position is not under opponent's attack, also wins.

A position is under attack of a knight if it can move into this position. Capturing a knight means that a player moves their knight to the cell where the opponent's knight is.

If Alice made $350$ moves and nobody won, the game is a draw.

Alice is unsure in her chess skills, so she asks you for a help. Choose a knight and win the game for her. It can be shown, that Alice always has a winning strategy.

Interaction

The interaction starts with two integers $n$ and $m$ ($6 \le n,m \le 40$, $n$ and $m$ are even) — the dimensions of the chessboard.

The second line contains four integers $x_1, y_1, x_2, y_2$ ($1 \le x_1, x_2 \le n$, $1 \le y_1, y_2 \le m$) — the positions of the white and the black knight. It is guaranteed that the two knights have different starting positions. It is also guaranteed that none of the knights are in their own target square in the beginning of the game (however, they can be on the opponent's target position).

Your program should reply with either "WHITE" or "BLACK", depending on the knight you want to play with. In case you select the white knight, you start the game.

During every your turn, you need to print two integers: $x$ and $y$, the position to move the knight. If you won the game by this turn, you must terminate your program immediately.

After every turn of the opponent, you will receive two integers: $x$ and $y$, the position where Bob moved his knight.

If your last move was illegal or you lost the game after jury's turn, or you made $350$ moves, and haven't won, you will receive "-1 -1". In such cases, you should terminate your program and then you will get a Wrong Answer verdict.

After printing anything, do not forget to output the end of line and flush the output. Otherwise, you might get Idleness limit exceeded. To do this, use:

* fflush(stdout) or cout.flush() in C++;
* System.out.flush() in Java;
* flush(output) in Pascal;
* stdout.flush() in Python;
* see documentation for other languages.

Jury's program is adaptive: the moves of jury may depend on the moves made by your program.

Examples

Input

```
8 8
2 3 1 8
```

Output

```
WHITE
4 4
```

Input

```
6 6
4 4 2 2
6 3
```

Output

```
BLACK
4 3
```

Note

In the first example, the white knight can reach it's target square in one move.

In the second example black knight wins, no matter what white knight moves.

Non-adaptive interactor (C++):
#include "testlib.h"
#include <bits/stdc++.h>
#include <csignal>
using namespace std;


static int queries = 0;
static int query_limit = 350;


static void log_metrics() {
    try {
        tout << "queries=" << queries << endl;
        tout << "query_limit=" << query_limit << endl;
    } catch (...) {}
}


static void finish(TResult verdict, const string& msg) {
    log_metrics();
    quitf(verdict, "%s", msg.c_str());
}


int N, M;

int dr[] = {1, 1, 2, 2, -1, -1, -2, -2};
int dc[] = {2, -2, 1, -1, 2, -2, 1, -1};

bool is_valid(int r, int c) {
    return r >= 1 && r <= N && c >= 1 && c <= M;
}



bool attacks(int r1, int c1, int r2, int c2) {
    for(int i=0; i<8; ++i) {
        if (r1 + dr[i] == r2 && c1 + dc[i] == c2) return true;
    }
    return false;
}


int get_dist(int sr, int sc, int tr, int tc) {
    if (sr == tr && sc == tc) return 0;
    static int d[42][42];
    for(int i=0; i<=41; ++i) for(int j=0; j<=41; ++j) d[i][j] = -1;
    
    queue<pair<int,int>> q;
    q.push({sr, sc});
    d[sr][sc] = 0;
    
    while(!q.empty()){
        auto [r, c] = q.front(); q.pop();
        if(r == tr && c == tc) return d[r][c];
        
        for(int k=0; k<8; ++k){
            int nr = r + dr[k];
            int nc = c + dc[k];
            if(is_valid(nr, nc) && d[nr][nc] == -1){
                d[nr][nc] = d[r][c] + 1;
                q.push({nr, nc});
            }
        }
    }
    
    return 1000000;
}

struct Knight {
    int r, c;
    int tr, tc;
};

Knight knights[2]; 
int user_side = -1;

int main(int argc, char** argv) {
    
    
    std::signal(SIGPIPE, SIG_IGN);
    registerInteraction(argc, argv);
    atexit(log_metrics);

    
    N = inf.readInt(6, 40, "N");
    M = inf.readInt(6, 40, "M");
    int x1 = inf.readInt(1, N, "x1");
    int y1 = inf.readInt(1, M, "y1");
    int x2 = inf.readInt(1, N, "x2");
    int y2 = inf.readInt(1, M, "y2");

    
    knights[0] = {x1, y1, N/2, M/2};       
    knights[1] = {x2, y2, N/2 + 1, M/2};   

    
    cout << N << " " << M << endl;
    cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
    cout.flush(); 

    
    string s;
    if (!(cin >> s)) finish(_wa, "No side selection provided");
    if (s == "WHITE") user_side = 0;
    else if (s == "BLACK") user_side = 1;
    else finish(_wa, "Invalid side selection (expected WHITE or BLACK)");

    int turn = 0; 
    int hard_cap = 2000; 

    while (true) {
        if (hard_cap-- <= 0) finish(_pe, "Hard loop limit reached");

        if (turn == user_side) {
            
            
            
            if (queries >= query_limit) {
                cout << "-1 -1" << endl;
                finish(_wa, "Query limit (350 moves) reached without winning");
            }

            
            string t1;
            if (!(cin >> t1)) finish(_wa, "Unexpected EOF waiting for move");
            
            
            if (t1 == "?") {
                if (!(cin >> t1)) finish(_wa, "Unexpected EOF after '?'");
            }

            int ur, uc;
            try {
                size_t idx;
                ur = stoi(t1, &idx);
                string t2;
                if (!(cin >> t2)) finish(_wa, "Expected y coordinate");
                uc = stoi(t2);
            } catch (...) {
                finish(_wa, "Invalid integer format in move");
            }

            queries++; 

            
            if (!is_valid(ur, uc)) {
                cout << "-1 -1" << endl;
                finish(_wa, "Move out of bounds");
            }
            if (!attacks(knights[user_side].r, knights[user_side].c, ur, uc)) {
                cout << "-1 -1" << endl;
                finish(_wa, "Invalid knight move (not reachable from current position)");
            }

            
            knights[user_side].r = ur;
            knights[user_side].c = uc;

            
            
            if (knights[user_side].r == knights[1-user_side].r && knights[user_side].c == knights[1-user_side].c) {
                finish(_ok, "Contestant captured judge");
            }
            
            if (knights[user_side].r == knights[user_side].tr && knights[user_side].c == knights[user_side].tc) {
                
                if (!attacks(knights[1-user_side].r, knights[1-user_side].c, knights[user_side].r, knights[user_side].c)) {
                    finish(_ok, "Contestant reached target safely");
                }
            }

        } else {
            
            int me = turn;
            int opp = 1 - turn;

            
            vector<pair<int,int>> moves;
            for(int k=0; k<8; ++k) {
                int nr = knights[me].r + dr[k];
                int nc = knights[me].c + dc[k];
                if(is_valid(nr, nc)) moves.push_back({nr, nc});
            }

            
            
            
            
            
            int best_r = -1, best_c = -1;
            double best_score = -1e18;

            for(auto& mv : moves) {
                double score = 0;
                int nr = mv.first;
                int nc = mv.second;

                
                if (nr == knights[opp].r && nc == knights[opp].c) {
                    score = 1e9;
                }
                
                else if (nr == knights[me].tr && nc == knights[me].tc) {
                    if (!attacks(knights[opp].r, knights[opp].c, nr, nc)) score = 1e9;
                    else score = -1e9; 
                }
                else {
                    
                    int d = get_dist(nr, nc, knights[me].tr, knights[me].tc);
                    score -= d;

                    
                    if (attacks(knights[opp].r, knights[opp].c, nr, nc)) {
                        score -= 5000; 
                    }
                }

                if (score > best_score) {
                    best_score = score;
                    best_r = nr;
                    best_c = nc;
                }
            }

            
            knights[me].r = best_r;
            knights[me].c = best_c;
            cout << best_r << " " << best_c << endl; 
            
            
            bool judge_wins = false;
            
            if (knights[me].r == knights[opp].r && knights[me].c == knights[opp].c) judge_wins = true;
            
            if (knights[me].r == knights[me].tr && knights[me].c == knights[me].tc) {
                 if (!attacks(knights[opp].r, knights[opp].c, knights[me].r, knights[me].c)) judge_wins = true;
            }

            if (judge_wins) {
                
                cout << "-1 -1" << endl;
                finish(_wa, "Judge won the game");
            }
        }
        
        turn = 1 - turn;
    }

    return 0;
}


Adaptive interactor (C++):
#include "testlib.h"
#include <bits/stdc++.h>
#include <csignal>

using namespace std;






static long long queries = 0;
static long long query_limit = 350; 


static int N, M;
static int WT_R, WT_C; 
static int BT_R, BT_C; 





static const int MAX_STATES = 5200000;
static int8_t win_status[MAX_STATES];   
static int8_t degree[MAX_STATES];       
static int16_t dist_to_end[MAX_STATES]; 


static int dx[] = {-1, -2, -2, -1, 1, 2, 2, 1};
static int dy[] = {-2, -1, 1, 2, 2, 1, -1, -2};





static void log_metrics() {
    try {
        tout << "queries=" << queries << endl;
        tout << "query_limit=" << query_limit << endl;
    } catch (...) {
        
    }
}

static void finish(TResult verdict, const string& msg) {
    log_metrics();
    quitf(verdict, "%s", msg.c_str());
}

inline bool valid(int r, int c) {
    return r >= 0 && r < N && c >= 0 && c < M;
}

inline int get_idx(int wx, int wy, int bx, int by, int turn) {
    return turn + 2 * (by + M * (bx + N * (wy + M * wx)));
}

inline void unpack_idx(int idx, int &wx, int &wy, int &bx, int &by, int &turn) {
    turn = idx % 2; idx /= 2;
    by = idx % M; idx /= M;
    bx = idx % N; idx /= N;
    wy = idx % M; idx /= M;
    wx = idx;
}


bool is_attacked(int r, int c, int tr, int tc) {
    for (int k = 0; k < 8; k++) {
        if (r + dx[k] == tr && c + dy[k] == tc) return true;
    }
    return false;
}





int main(int argc, char* argv[]) {
    
    std::signal(SIGPIPE, SIG_IGN);
    registerInteraction(argc, argv);
    atexit(log_metrics);

    
    N = inf.readInt();
    M = inf.readInt();
    int start_wx = inf.readInt() - 1;
    int start_wy = inf.readInt() - 1;
    int start_bx = inf.readInt() - 1;
    int start_by = inf.readInt() - 1;

    
    WT_R = N / 2 - 1; WT_C = M / 2 - 1; 
    BT_R = N / 2;     BT_C = M / 2 - 1;

    
    int total_states = N * M * N * M * 2;
    vector<int> q;
    q.reserve(total_states);

    
    for (int idx = 0; idx < total_states; idx++) {
        int wx, wy, bx, by, turn;
        unpack_idx(idx, wx, wy, bx, by, turn);

        bool can_win_now = false;
        int d = 0;

        if (turn == 0) { 
            for (int k = 0; k < 8; k++) {
                int nx = wx + dx[k];
                int ny = wy + dy[k];
                if (valid(nx, ny)) {
                    d++;
                    
                    if (nx == bx && ny == by) can_win_now = true;
                    if (nx == WT_R && ny == WT_C && !is_attacked(bx, by, WT_R, WT_C)) can_win_now = true;
                }
            }
        } else { 
            for (int k = 0; k < 8; k++) {
                int nx = bx + dx[k];
                int ny = by + dy[k];
                if (valid(nx, ny)) {
                    d++;
                    
                    if (nx == wx && ny == wy) can_win_now = true;
                    if (nx == BT_R && ny == BT_C && !is_attacked(wx, wy, BT_R, BT_C)) can_win_now = true;
                }
            }
        }

        degree[idx] = d;
        if (can_win_now) {
            win_status[idx] = 1; 
            dist_to_end[idx] = 1;
            q.push_back(idx);
        }
    }

    
    int head = 0;
    while(head < (int)q.size()){
        int u = q[head++];
        int u_win = win_status[u]; 
        int u_dist = dist_to_end[u];
        
        int wx, wy, bx, by, turn;
        unpack_idx(u, wx, wy, bx, by, turn);

        
        if (turn == 0) {
            
            for (int k = 0; k < 8; k++) {
                int pbx = bx - dx[k];
                int pby = by - dy[k];
                if (valid(pbx, pby)) {
                    int p_idx = get_idx(wx, wy, pbx, pby, 1);
                    if (win_status[p_idx] != 0) continue;

                    if (u_win == -1) {
                        
                        win_status[p_idx] = 1;
                        dist_to_end[p_idx] = u_dist + 1;
                        q.push_back(p_idx);
                    } else {
                        
                        degree[p_idx]--;
                        if (degree[p_idx] == 0) {
                            win_status[p_idx] = -1; 
                            dist_to_end[p_idx] = u_dist + 1;
                            q.push_back(p_idx);
                        }
                    }
                }
            }
        } else {
            
            for (int k = 0; k < 8; k++) {
                int pwx = wx - dx[k];
                int pwy = wy - dy[k];
                if (valid(pwx, pwy)) {
                    int p_idx = get_idx(pwx, pwy, bx, by, 0);
                    if (win_status[p_idx] != 0) continue;

                    if (u_win == -1) {
                        win_status[p_idx] = 1;
                        dist_to_end[p_idx] = u_dist + 1;
                        q.push_back(p_idx);
                    } else {
                        degree[p_idx]--;
                        if (degree[p_idx] == 0) {
                            win_status[p_idx] = -1;
                            dist_to_end[p_idx] = u_dist + 1;
                            q.push_back(p_idx);
                        }
                    }
                }
            }
        }
    }

    
    cout << N << " " << M << endl;
    cout << (start_wx + 1) << " " << (start_wy + 1) << " " << (start_bx + 1) << " " << (start_by + 1) << endl;
    
    string side;
    if (!(cin >> side)) finish(_wa, "Unexpected EOF reading side");
    
    bool i_am_white = false; 
    if (side == "WHITE") i_am_white = false;      
    else if (side == "BLACK") i_am_white = true;  
    else finish(_pe, "Expected 'WHITE' or 'BLACK'");

    int cur_wx = start_wx, cur_wy = start_wy;
    int cur_bx = start_bx, cur_by = start_by;

    
    while (queries < 400) { 
        if (i_am_white) {
            
            
            
            
            
            int best_nx = -1, best_ny = -1;
            int best_val = -2; 
            int best_dist = -1;

            
            for (int k = 0; k < 8; k++) {
                int nx = cur_wx + dx[k];
                int ny = cur_wy + dy[k];
                if (!valid(nx, ny)) continue;

                
                bool immediate = false;
                if (nx == cur_bx && ny == cur_by) immediate = true;
                if (nx == WT_R && ny == WT_C && !is_attacked(cur_bx, cur_by, WT_R, WT_C)) immediate = true;

                if (immediate) {
                    best_nx = nx; best_ny = ny;
                    best_val = 2; 
                    break; 
                }

                
                
                int next_idx = get_idx(nx, ny, cur_bx, cur_by, 1);
                int res = win_status[next_idx]; 
                int dist = dist_to_end[next_idx];
                
                
                int val_for_me = (res == 1) ? -1 : (res == -1 ? 1 : 0);

                if (best_nx == -1 || val_for_me > best_val) {
                    best_nx = nx; best_ny = ny;
                    best_val = val_for_me;
                    best_dist = dist;
                } else if (val_for_me == best_val) {
                    if (val_for_me == 1) {
                        if (dist < best_dist) { 
                            best_nx = nx; best_ny = ny;
                            best_dist = dist;
                        }
                    } else if (val_for_me == -1) {
                        if (dist > best_dist) { 
                            best_nx = nx; best_ny = ny;
                            best_dist = dist;
                        }
                    }
                }
            }

            if (best_nx == -1) finish(_wa, "No moves available for Interactor");

            
            bool i_won = false;
            if (best_nx == cur_bx && best_ny == cur_by) i_won = true;
            if (best_nx == WT_R && best_ny == WT_C && !is_attacked(cur_bx, cur_by, WT_R, WT_C)) i_won = true;

            if (i_won) {
                cout << "-1 -1" << endl;
                finish(_wa, "Interactor won (Contestant lost)");
            }

            
            cout << (best_nx + 1) << " " << (best_ny + 1) << endl;
            cur_wx = best_nx; cur_wy = best_ny;

            
            int tx, ty;
            if (!(cin >> tx >> ty)) finish(_wa, "Unexpected EOF reading move");
            if (!valid(tx-1, ty-1)) finish(_wa, "Invalid coordinates");
            tx--; ty--;

            
            bool ok_move = false;
            for(int k=0; k<8; ++k) if(cur_bx+dx[k] == tx && cur_by+dy[k] == ty) ok_move = true;
            if (!ok_move) finish(_wa, "Illegal move by Contestant");
            
            cur_bx = tx; cur_by = ty;
            queries++;
            log_metrics();

            
            if (cur_bx == cur_wx && cur_by == cur_wy) finish(_ok, "Contestant captured Interactor");
            if (cur_bx == BT_R && cur_by == BT_C && !is_attacked(cur_wx, cur_wy, BT_R, BT_C)) finish(_ok, "Contestant reached target");

        } else {
            
            
            

            
            int tx, ty;
            if (!(cin >> tx >> ty)) finish(_wa, "Unexpected EOF reading move");
            if (!valid(tx-1, ty-1)) finish(_wa, "Invalid coordinates");
            tx--; ty--;

            bool ok_move = false;
            for(int k=0; k<8; ++k) if(cur_wx+dx[k] == tx && cur_wy+dy[k] == ty) ok_move = true;
            if (!ok_move) finish(_wa, "Illegal move by Contestant");

            cur_wx = tx; cur_wy = ty;
            queries++;
            log_metrics();

            
            if (cur_wx == cur_bx && cur_wy == cur_by) finish(_ok, "Contestant captured Interactor");
            if (cur_wx == WT_R && cur_wy == WT_C && !is_attacked(cur_bx, cur_by, WT_R, WT_C)) finish(_ok, "Contestant reached target");

            
            int best_nx = -1, best_ny = -1;
            int best_val = -2;
            int best_dist = -1;

            for (int k = 0; k < 8; k++) {
                int nx = cur_bx + dx[k];
                int ny = cur_by + dy[k];
                if (!valid(nx, ny)) continue;

                bool immediate = false;
                if (nx == cur_wx && ny == cur_wy) immediate = true;
                if (nx == BT_R && ny == BT_C && !is_attacked(cur_wx, cur_wy, BT_R, BT_C)) immediate = true;

                if (immediate) {
                    best_nx = nx; best_ny = ny;
                    best_val = 2; 
                    break;
                }

                
                int next_idx = get_idx(cur_wx, cur_wy, nx, ny, 0);
                int res = win_status[next_idx]; 
                int dist = dist_to_end[next_idx];

                int val_for_me = (res == 1) ? -1 : (res == -1 ? 1 : 0);

                if (best_nx == -1 || val_for_me > best_val) {
                    best_nx = nx; best_ny = ny;
                    best_val = val_for_me;
                    best_dist = dist;
                } else if (val_for_me == best_val) {
                    if (val_for_me == 1) {
                        if (dist < best_dist) {
                            best_nx = nx; best_ny = ny;
                            best_dist = dist;
                        }
                    } else if (val_for_me == -1) {
                        if (dist > best_dist) {
                            best_nx = nx; best_ny = ny;
                            best_dist = dist;
                        }
                    }
                }
            }

            if (best_nx == -1) finish(_wa, "No moves available for Interactor");

            
            bool i_won = false;
            if (best_nx == cur_wx && best_ny == cur_wy) i_won = true;
            if (best_nx == BT_R && best_ny == BT_C && !is_attacked(cur_wx, cur_wy, BT_R, BT_C)) i_won = true;

            if (i_won) {
                cout << "-1 -1" << endl;
                finish(_wa, "Interactor won (Contestant lost)");
            }

            cout << (best_nx + 1) << " " << (best_ny + 1) << endl;
            cur_bx = best_nx; cur_by = best_ny;
        }
    }

    finish(_wa, "Game drawn (move limit exceeded)");
    return 0;
}


Test generator (C++):
#include "testlib.h"
#include <bits/stdc++.h>

using namespace std;

int main(int argc, char* argv[]) {
    registerGen(argc, argv, 1);

    
    
    
    string mode = opt<string>("mode", "non");

    
    
    long long seed_val = 0;
    if (argc > 1) {
        seed_val = atoll(argv[1]);
    }

    int n, m;
    int x1, y1, x2, y2;

    auto get_white_target = [&](int r, int c) { return make_pair(r/2, c/2); };
    auto get_black_target = [&](int r, int c) { return make_pair(r/2 + 1, c/2); };

    
    
    if (seed_val >= 1 && seed_val <= 5) {
        if (seed_val == 1) {
            
            n = 6; m = 6;
            x1 = 1; y1 = 1; 
            x2 = 6; y2 = 6;
        } else if (seed_val == 2) {
            
            n = 40; m = 40;
            x1 = 1; y1 = 1;
            x2 = 40; y2 = 40;
        } else if (seed_val == 3) {
            
            n = 6; m = 40;
            
            x1 = 3; y1 = 19;
            x2 = 4; y2 = 21;
        } else if (seed_val == 4) {
            
            n = 8; m = 8;
            
            x1 = 4; y1 = 5;
            x2 = 5; y2 = 6;
        } else {
            
            n = 10; m = 10;
            pair<int,int> wt = get_white_target(n, m);
            pair<int,int> bt = get_black_target(n, m);
            x1 = bt.first; y1 = bt.second; 
            x2 = wt.first; y2 = wt.second; 
        }
    } else {
        
        
        int type = rnd.next(1, 100);
        if (type <= 10) {
            n = 6; m = 6;
        } else if (type <= 30) {
            n = 40; m = 40;
        } else if (type <= 40) {
            
            if (rnd.next(2)) { n = 6; m = 40; } else { n = 40; m = 6; }
        } else {
            
            n = rnd.next(3, 20) * 2;
            m = rnd.next(3, 20) * 2;
        }

        pair<int,int> wt = get_white_target(n, m);
        pair<int,int> bt = get_black_target(n, m);

        int attempts = 0;
        while (true) {
            
            if (attempts < 50 && rnd.next(2)) {
                int cx = n / 2;
                int cy = m / 2;
                int rx = max(2, n / 4);
                int ry = max(2, m / 4);
                
                x1 = rnd.next(max(1, cx - rx), min(n, cx + rx));
                y1 = rnd.next(max(1, cy - ry), min(m, cy + ry));
                
                x2 = rnd.next(max(1, cx - rx), min(n, cx + rx));
                y2 = rnd.next(max(1, cy - ry), min(m, cy + ry));
            } else {
                
                x1 = rnd.next(1, n);
                y1 = rnd.next(1, m);
                x2 = rnd.next(1, n);
                y2 = rnd.next(1, m);
            }
            attempts++;

            
            
            if (x1 == x2 && y1 == y2) continue;
            
            if (x1 == wt.first && y1 == wt.second) continue;
            if (x2 == bt.first && y2 == bt.second) continue;
            
            break;
        }
    }

    
    cout << n << " " << m << endl;
    cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;

    return 0;
}