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

const int MAX = 1001;

int N, K, V;
int asked = 0;
int A[MAX][MAX];
int mark_row[MAX];
int mark_col[MAX];

void over(int x, int y) {
  cout << "2 " << x << " " << y << "\n";
  exit(0);
}

void ask(int x, int y) {
  if (A[x][y]) {
    return;
  }
  asked += 1;
  if (asked > K) {
    over(-1, -1);
    // assert(false);
  }
  cout << "1 " << x << " " << y << "\n";
  fflush(stdout);
  cin >> A[x][y];
}

int main() {
  ios_base::sync_with_stdio(false);
  cin >> N >> K >> V;
  for(int x = 1; x <= N; ++x) {
    vector<pair<int, int>> vals;
    for(int y = 1; y <= N; ++y) {
      if (A[y][x]) {
        vals.push_back({A[y][x], y});
      }
    }
    if (vals.size() <= 1 || (rand() % 2)) {
      mark_row[x] = 1;
      ask(x, 1);
      if (A[x][1] == V) {
        over(x, 1);
      }
      ask(x, N);
      if (A[x][N] == V) {
        over(x, N);
      }
      if (V < min(A[x][1], A[x][N]) or V > max(A[x][1], A[x][N])) {
        continue;
      }
      bool inc = A[x][1] < A[x][N];
      int low = 2; int high = N-1;
      while(low <= high) {
        int mid = (low+high)/2;
        ask(x, mid);
        if (A[x][mid] == V) {
          over(x, mid);
        }
        if (inc) {
          if (A[x][mid] < V) {
            low = mid + 1;
          }
          else {
            high = mid - 1;
          }
        }
        else {
          if (A[x][mid] < V) {
            high = mid - 1;
          }
          else {
            low = mid + 1;
          }
        }
      }
    }
    else {
      mark_col[x] = 1;
      bool inc = vals[0].first < vals.back().first;
      int st = -1, en = -1;
      for(int i = 0; i+1 < vals.size(); ++i) {
        if (min(vals[i].first, vals[i+1].first) <= V and
            V <= max(vals[i].first, vals[i+1].first)) {
          st = vals[i].second+1;
          en = vals[i+1].second-1;
          break;
        }
      }
      if (vals[0].second != 1) {
        if (V < vals[0].first) {
          st = 1;
          en = vals[0].second - 1;
        }
      }
      if (vals.back().second != N) {
        if (V > vals.back().first) {
          st = vals.back().second + 1;
          en = N;
        }
      }
      if (st == -1 || en == -1) {
        continue;
      }
      int low = st, high = en;
      while(low <= high) {
        int mid = (low+high)/2;
        ask(mid, x);
        if (A[mid][x] == V) {
          over(mid, x);
        }
        if (inc) {
          if (A[mid][x] < V) {
            low = mid + 1;
          }
          else {
            high = mid - 1;
          }
        }
        else {
          if (A[mid][x] < V) {
            high = mid - 1;
          }
          else {
            low = mid + 1;
          }
        }
      }
    }
  }
  for(int x = 1; x <= N; ++x) {
    if (mark_row[x]) {
      continue;
    }
    mark_row[x] = 1;
    vector<pair<int,int>> vals;
    for(int y = 1; y <= N; ++y) {
      if (A[x][y]) {
        vals.push_back({A[x][y], y});
      }
    }
    int st = -1, en = -1;
    while (vals.size() <= 1) {
      for(int y = 1; y <= N; ++y) {
        int col = rand() % N + 1;
        if (!A[x][col]) {
          ask(x, col);
          vals.push_back({A[x][col], col});
          break;
        }
      }
      sort(vals.begin(), vals.end());
    }
    for(int i = 0; i+1 < vals.size(); ++i) {
      if (min(vals[i].first, vals[i+1].first) <= V and
          V <= max(vals[i].first, vals[i+1].first)) {
        st = vals[i].second+1;
        en = vals[i+1].second-1;
        break;
      }
    }
    if (vals[0].second != 1) {
      if (V < vals[0].first) {
        st = 1;
        en = vals[0].second - 1;
      }
    }
    if (vals.back().second != N) {
      if (V > vals.back().first) {
        st = vals.back().second + 1;
        en = N;
      }
    }
    if (st == -1 || en == -1) {
      continue;
    }
    bool inc = vals[0].first < vals.back().first;
    int low = st, high = en;
    while(low <= high) {
      int mid = (low+high)/2;
      ask(x, mid);
      if (A[x][mid] == V) {
        over(x, mid);
      }
      if (inc) {
        if (A[mid][x] < V) {
          low = mid + 1;
        }
        else {
          high = mid - 1;
        }
      }
      else {
        if (A[mid][x] < V) {
          high = mid - 1;
        }
        else {
          low = mid + 1;
        }
      }
    }
  }
  over(-1, -1);
  return 0;
}