Problem: The university of A stages a programming contest this year as has been the case in the past. As a member of the team in charge of devising the problems, you have worked out a set of input data for a problem, which is an arrangement of points on a 2D plane in the coordinate system. The problem requires that any combination of these points greater than or equal to $K$ in number must not align on a line. You want to confirm that your data satisfies this requirement.

Given the number of points $K$ and their respective 2D coordinates, make a program to check if any combination of points greater or equal to $K$ align on a line.



Input

The input is given in the following format.


$N$ $K$
$x_1$ $y_1$
$x_2$ $y_2$
$...$
$x_N$ $y_N$


The first line provides the number of points $N$ ($3 \leq N \leq 3000$) on the 2D coordinate system and an integer $K$ ($3 \leq K \leq N$). Each of the subsequent lines provides the $i$-th coordinate $x_i,y_i$ ($0 \leq x_i,y_i \leq 10000$) as integers. None of these coordinates coincide, i.e., if $i \ne j$, then $x_i \ne x_j$ or $y_i \ne y_j$.

Output

Output 1 if any combination of points greater or equal to $K$ aligns on a line, or 0 otherwise.

Examples

Input

5 4
0 0
1 0
1 1
0 1
2 2


Output

0


Input

7 5
0 0
1 0
1 1
0 1
2 0
3 0
4 0


Output

1

Solution (in CPP):

Solution:
/*#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>
#include <array>
#include <vector>
#include <deque>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <unordered_map>
#include <unordered_set>
*/

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

// #define int long long
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define FOR(i,a,b) for(int (i)=(a);(i)<(b);(i)++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define SORT(c) sort((c).begin(),(c).end())

typedef long long ll;
const ll INF = LLONG_MAX - 100;
const ll mod = 1e9 + 7;
const int MAX_N = 5e5 + 5;
int dx[] = { -1LL,0,1LL,0 }, dy[] = { 0,1LL,0,-1LL };
vector<ll> prime;

ll inv[MAX_N], fac[MAX_N];

template <class T = ll> T in() { T x; cin >> x; return (x); }
inline ll GCD(ll a, ll b) { ll c; while (b != 0) { c = a % b; a = b; b = c; }return a; }
inline ll LCM(ll a, ll b) { return a * b / GCD(a, b); }
inline ll POW(ll a, ll b) { ll c = 1LL; while (b > 0) { if (b & 1LL) { c = a * c%mod; }a = a * a%mod; b >>= 1LL; }return c; }
inline void _nCr() { fac[0] = 1LL; for (int i = 1LL; i < MAX_N; i++) { fac[i] = fac[i - 1LL] * i%mod; }for (int i = 0; i < MAX_N; i++) { inv[i] = POW(fac[i], mod - 2); } }
inline ll nCr(ll n, ll r) { return (fac[n] * inv[r] % mod)*inv[n - r] % mod; }
inline void PRI(ll n) { bool a[n + 1LL]; for (int i = 0; i < n + 1LL; i++) { a[i] = 1LL; }for (int i = 2; i < n + 1LL; i++) { if (a[i]) { prime.pb(i); ll b = i; while (b <= n) { a[b] = 0; b += i; } } } }

// typedef pair<int, pair<int, int>> edge;

// class UnionFind {
// private:
// 	vector<int> par;
// public:
// 	UnionFind(int N) { par = vector<int>(N, -1LL); }
// 	int find(int x);
// 	ll size(int x);
// 	void unite(int x, int y);
// 	bool same(int x, int y);
// };



// class Kruskal {
// private:
// 	UnionFind *uf;
// 	vector<edge> e;
// public:
// 	vector<edge> mst;
// 	Kruskal(int N) { uf = new UnionFind(N); }
// 	void add(int x, int y, ll z);
// 	void run();
// };



// //----UnionFind-------------------------------
// int UnionFind::find(int x) {
// 	if (par[x] < 0) return x;
// 	else return par[x] = find(par[x]);
// }

// ll UnionFind::size(int x) {
// 	return -par[find(x)];
// }

// void UnionFind::unite(int x, int y) {
// 	x = find(x);
// 	y = find(y);

// 	//大きい方に小さい方をくっ付ける
// 	if (size(x) < size(y)) swap(x, y);
// 	par[x] += par[y];
// 	par[y] = x;
// }

// bool UnionFind::same(int x, int y) {
// 	x = find(x);
// 	y = find(y);
// 	return x == y;
// }



// //----Kruskal-------------------------------
// void Kruskal::add(int x, int y, ll z) {
// 	//x < y
// 	if (x > y) swap(x, y);
// 	e.push_back({ z,{x,y} });
// }

// void Kruskal::run() {
// 	sort(e.begin(), e.end());
// 	e.erase(unique(e.begin(), e.end()), e.end());
// 	for (auto x : e) {
// 		if (uf->same(x.second.first, x.second.second)) {
// 			continue;
// 		}
// 		else {
// 			mst.push_back(x);
// 			uf->unite(x.second.first, x.second.second);
// 		}
// 	}
// }

// class lazy {
// private:
// 	int n;
// 	vector<ll> node,lazy;
// public:
// 	lazy(vector<ll> v) {
// 		int sz = (int)v.size();
// 		n = 1;while(n < sz) n *= 2;
// 		node.resize(n);
// 		lazy.resize(2*n-1,0);
// 		for (int i=0; i<sz; i++) node[i] = v[i];
// 	}

// 	void eval(int k,int l,int r) {
// 		if (lazy[k] != 0) {

// 		}
// 	}
// }

signed main() {
	int n,k; cin >> n >> k;
	pair<double,double> v[n];
	REP (i,n) cin >> v[i].first >> v[i].second;

	bool ok = false;
	REP (i,n) {
		unordered_map<double,int> ma;
		REP (j,n) {
			if (i == j) continue;
			if (v[i].first == v[j].first) {
				ma[30000]++;
				continue;
			}
			pair<double,double> A,B;
			A = v[i]; B = v[j];
			if (B.first < A.first) swap(A,B);
			double tilt = (B.second - A.second) / (B.first - A.first);
			ma[tilt]++;
		}
		for (auto x = ma.begin();x != ma.end();x++) {
			if (x -> second > k - 2) {
				ok = true;
			}
		}
	}

	if (ok) cout << 1 << endl;
	else cout << 0 << endl;
}