// Blossom implementation from Bjarki:
// https://github.com/SuprDewd/CompetitiveProgramming/blob/master/code/graph/blossom.cpp

#include <algorithm>
#include <array>
#include <cstring>
#include <iostream>
#include <random>
#include <vector>

using namespace std;

constexpr int MAXV      = 2 * 4000;
using M                 = array<array<long long, MAXV>, MAXV>;
constexpr long long MOD = 1'000'000'007;

long long raise(long long base, long long n) {
	if(n == 0) return 1;
	if(n == 1) return base;
	auto r = raise(base * base % MOD, n / 2);
	return (n % 2 ? base * r % MOD : r);
}

long long inv(long long x) {
	return raise(x, MOD - 2);
}

#define REP(i, n) for(auto i = decltype(n)(0); i < (n); i++)
long long det(M& m, int rows) { // return the determinant
	int r         = 0;
	long long det = 1; // MODIFIES the input
	for(int c = 0; c < rows && r < rows; c++) {
		int p = r;
		for(int i = r + 1; i < rows; i++)
			if(abs(m[i][c]) > abs(m[p][c])) p = i;
		if(abs(m[p][c]) == 0) {
			det = 0;
			continue;
		}
		swap(m[p], m[r]);
		det         = -det;
		long long s = inv(m[r][c]);
		long long t;
		det                  = det * m[r][c] % MOD;
		REP(j, rows) m[r][j] = m[r][j] * s % MOD; // make leading term in row 1
		REP(i, rows) if(i != r) {
			t                    = m[i][c];
			REP(j, rows) m[i][j] = (MOD + m[i][j] - t * m[r][j] % MOD) % MOD;
		}
		++r;
	}
	return det;
}

int main() {
	int n, r;
	cin >> n >> r;
	vector<vector<int>> scores(r, vector<int>(2 * n));
	for(auto& v : scores)
		for(auto& x : v) cin >> x;

	M m;

	for(int i = 0; i < 2 * n; ++i) {
		for(int j = 0; j < i; ++j) {
			long long x = rand() % MOD;
			for(int k = 0; k < r; ++k) {
				if((scores[k][i] > n) + (scores[k][j] > n) != 1) {
					goto end;
				}
			}

			m[i][j] = x;
			m[j][i] = MOD - x;
		end:;
		}
	}

	if(det(m, 2 * n) != 0) {
		cout << "possible" << endl;
	} else {
		cout << "impossible" << endl;
	}
}