stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/02/23  Problem: 068_arc_b / Link: https://arc068.contest.atcoder.jp/tasks/arc068_b?lang=en  ----- */

/* ------問題------



すぬけくんはカードゲームで遊ぶことにしました。 N 枚からなるカードの山があり、上から i 枚目のカードには整数 Ai が書かれています。

すぬけくんはこのカードの山に対し 0 回以上、以下の操作を行い、残ったカードに書かれた値が互いに異なるようにしたいです。最大で何枚のカードを残すことが可能か求めなさい。なお、N は奇数であり、少なくとも 1 枚のカードを残すことが可能であることが保証されます。

操作：カードの山から任意の 3 枚のカードを抜き出す。抜き出したカードのうち書かれた値が最大であるようなカード 1 枚と最小であるようなカード 1 枚の合計 2 枚を選んで食べる。その後残った 1 枚をカードの山に戻す。



-----問題ここまで----- */

/* -----解説等-----



数字をまとめて個数で考える。

3個以上のものは同じものだけを選択することで全部1か2になる。

2についてこれらは全て選択し他の2あるいは1も選択する。

2が偶数個あるときは数自体を減らさずに個数のみを減らせる。

奇数個のときは最後の1つだけが相手が見つからず誰かを消すことになる。

これを書けば良い。



----解説ここまで---- */



LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	cin >> N;

	VI a(N);

	VI cnt(100005);

	FOR(i, 0, N) {

		cin >> a[i];

		cnt[a[i]]++;

	}

	VI pq;

	FOR(i, 0, 100005) {

		if (cnt[i])pq.push_back(cnt[i]);



	}

	int even = 0;

	FOR(i, 0, SZ(pq)) {

		if (pq[i] % 2 == 0)even++;

	}

	ans = SZ(pq);

	if (even % 2 == 1)ans--;

	cout << ans << "\n";



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.5138360756865898x):
#include<bits/stdc++.h>

#define int long long

using namespace std;

 



int mm[100004];

signed main()

{

 

ios_base::sync_with_stdio(false);

cin.tie(NULL);  

cout.tie(0);   

 

 

#ifndef ONLINE_JUDGE

    if(fopen("INPUT.txt","r"))

    {

    freopen ("INPUT.txt" , "r" , stdin);

    freopen ("OUTPUT.txt" , "w" , stdout);

    }

#endif    



    int n;

    cin>>n;

    int a[n];

    int cnt=0;

    for(int i=0;i<n;i++)

    {

        cin>>a[i];

        mm[a[i]]++;

        if(mm[a[i]]==1)

        {

            cnt++;

        }

    }



    if((n-cnt)%2==0)

    {           

        cout<<cnt;

    }

    else

    {

        cout<<cnt-1;

    }

    

}
// Slower C++ solution:
#include<cstdio>

#include<iostream>

#include<map>

#include<cmath>

#include<algorithm>

#include<cstring>

#include<string>

using namespace std;

int a[100005],x,ans;

int main(){

	int n;

	cin >> n;

	for(int i = 1;i <= n;i++){

		cin >> x;

		a[x]++;

	}

	for(int i = 1;i <= 100003;i++){

		if(a[i]>1)ans+=(a[i]-1);

		}

	if(ans%2)ans+=1;

	cout << n - ans <<endl;

	return 0;

	}


// Faster C++ solution for the same problem (measured speedup: 1.364936460881093x):
#include<bits/stdc++.h>

#define int long long

using namespace std;

 



int mm[100004];

signed main()

{

 

ios_base::sync_with_stdio(false);

cin.tie(NULL);  

cout.tie(0);   

 

 

#ifndef ONLINE_JUDGE

    if(fopen("INPUT.txt","r"))

    {

    freopen ("INPUT.txt" , "r" , stdin);

    freopen ("OUTPUT.txt" , "w" , stdout);

    }

#endif    



    int n;

    cin>>n;

    int a[n];

    int cnt=0;

    for(int i=0;i<n;i++)

    {

        cin>>a[i];

        mm[a[i]]++;

        if(mm[a[i]]==1)

        {

            cnt++;

        }

    }



    if((n-cnt)%2==0)

    {           

        cout<<cnt;

    }

    else

    {

        cout<<cnt-1;

    }

    

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

const int M=1e5+10;

int a[M],cnt;

int main()

{

    int n;scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        int x;scanf("%d",&x);

        a[x]++;

    }

    int cost=0;

    for(int i=1;i<M;i++)if(a[i]>=2)

    {

        if(a[i]%2==0)

        {

            cost+=a[i]-2;

            cnt++;

        }

        else cost+=a[i]-1;



    }

    cost+=(cnt/2)*2;

    if(cnt%2==1)cost+=2;

    printf("%d\n",n-cost);

}


// Faster C++ solution for the same problem (measured speedup: 1.3610990597763584x):
#include<bits/stdc++.h>

#define int long long

using namespace std;

 



int mm[100004];

signed main()

{

 

ios_base::sync_with_stdio(false);

cin.tie(NULL);  

cout.tie(0);   

 

 

#ifndef ONLINE_JUDGE

    if(fopen("INPUT.txt","r"))

    {

    freopen ("INPUT.txt" , "r" , stdin);

    freopen ("OUTPUT.txt" , "w" , stdout);

    }

#endif    



    int n;

    cin>>n;

    int a[n];

    int cnt=0;

    for(int i=0;i<n;i++)

    {

        cin>>a[i];

        mm[a[i]]++;

        if(mm[a[i]]==1)

        {

            cnt++;

        }

    }



    if((n-cnt)%2==0)

    {           

        cout<<cnt;

    }

    else

    {

        cout<<cnt-1;

    }

    

}
// Slower C++ solution:
#include<iostream>

#include<algorithm>

#include<cmath>

#include<iomanip>

#include<map>

using namespace std;

int main() {

  int n,a[100000]={},cnt=0;

  cin >> n;

  map<int,int> m;

  for(int i=0; i<n; i++) {

    cin >> a[i];

    m[a[i]]++;

  }

  for(auto p:m) {

    if(p.second>1) {

      cnt+=p.second-1;

    }

  }

  if(cnt%2==0) {

    cout << n-cnt << endl;

  }

  else {

    cout << n-cnt-1 << endl;

  }

}

// Faster C++ solution for the same problem (measured speedup: 1.384612063016615x):
//   _/                _/                 _/_/_/   _/

//_/_/_/_/   _/_/   _/_/_/_/   _/_/    _/       _/_/

// _/     _/    _/   _/     _/    _/  _/_/_/     _/

//_/     _/    _/   _/     _/    _/  _/    _/   _/

// _/_/   _/_/       _/_/   _/_/      _/_/     _/

#include<iostream>

#include<algorithm>

#include<cmath>

#include<iomanip>

#include<set>

#include<map>

#include<queue>

#include<vector>

using namespace std;

typedef long long ll;

const int MOD=1e9+7;

const int inf=1e9;

const ll INF=1e18;

const double pi=3.1415926535897932384626433832;

int main() {

  cin.tie(0),cout.tie(0);

  ios::sync_with_stdio(false);

  // 初めに思ったこと：重複していない値は全て残したい

  ll n,a,cnt=0;

  cin >> n;

  map<int,int> m;

  for(int i=0; i<n; i++) {

    cin >> a;

    m[a]++;

  }

  // 重複していたら1つを残して食べる

  for(auto p:m) {

    if(p.second>1) {

      cnt+=p.second-1;

    }

  }

  // 1回の操作で2つずつ減っていくので食べた数=cntは2の倍数である必要がある

  if(cnt%2==0) {

    cout << n-cnt << endl;

  }

  // cntが奇数のとき、1つしか残っていない数を余計に1つだけ食べている

  else {

    cout << n-cnt-1 << endl;

  }

}
// Slower C++ solution:
#include <iostream>

using namespace std;



int main() {

    int N;

    cin >> N;



    static int counter[100000];

    for (int i = 0; i < N; i++) {

        int a;

        cin >> a;



        counter[a - 1]++;

    }



    // 基本的には重複しているカードが2枚ずつ消えていく

    int even = 0,

        odd  = 0;

    for (int a = 0; a < 100000; a++) {

        if (counter[a] == 0) continue;

        else if (counter[a] % 2) odd++;

        else even++;

    }

    cout << even + odd - (even % 2) << endl;



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3834638124686054x):
#include <bits/stdc++.h>

using namespace std;



#define repeat(i, x) for (int64_t i = 0; (i) < (int64_t)(x); (i)++)



int main() {

    cin.tie(nullptr);

    ios::sync_with_stdio(false);



    int n;

    cin >> n;



    map<int, int> counter;

    repeat (i, n) {

        int a;

        cin >> a;

        counter[a]++;

    }



    int numEven = 0;

    for (auto& mp : counter) {

        if (mp.second % 2 == 0) numEven++;

    }



    cout << counter.size() - numEven % 2 << endl;



    return 0;

}
// Slower C++ solution:
#import<iostream>

main(){int n,c,i,a[1<<17]={};for(std::cin>>n;n--;){std::cin>>i;if(!a[i]++){++c;a[i]++;}}for(i=1<<17;i--;)n^=a[i]&1;std::cout<<(n&1?c:c-1);}

// Faster C++ solution for the same problem (measured speedup: 1.571290625951671x):
#import<iostream>

int n,c,i,a[1<<17];

main(){for(std::cin>>n;std::cin>>i;)c+=!!a[i]++;std::cout<<n-c-c%2;}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int n;

int a[101010];

int b[101010];



int main()

{

  cin >> n;

  for (int i = 0; i < n; i++){

    cin >> a[i];

    b[a[i]]++;

  }



  int ans = 0;

  int po = 0;

  for (int i = 0; i < 101010; i++){

    if (b[i] & 1){

      ans++;

    } else if (b[i] == 0) {

     continue;

    }

    else {

      po++;

    }

  }



  cout << ans + po / 2 * 2 << endl;

}




// Faster C++ solution for the same problem (measured speedup: 1.3622785032072842x):
#include <bits/stdc++.h>

using namespace std;



// clang-format off

#define  range(i, l, r) for (int i = (int)(l); i < (int)(r); ++(i))

#define rrange(i, l, r) for (int i = (int)(r) - 1; i >= (int)(l); --(i))



#define  whole(f, x, ...) ([&](decltype((x)) container) { return (f)(  begin(container),  end(container), ## __VA_ARGS__); })(x)

#define rwhole(f, x, ...) ([&](decltype((x)) container) { return (f)( rbegin(container), rend(container), ## __VA_ARGS__); })(x)



#define endl '\n'

#define debug(x) cerr << "(" << __LINE__ << ")" << #x << ": " << (x) << endl



using i32 = int;

using u32 = unsigned int;

using i64 = long long;

using u64 = unsigned long long;



// constexpr i32 mod   = 998244353;

constexpr i32 mod   = 1e9 + 7;

constexpr i32 inf   = 1001001001;

constexpr i64 infll = 1001001001001001001ll;



constexpr int dx[] = {0, -1, 1, 0, -1, 1, -1, 1}; 

constexpr int dy[] = {-1, 0, 0, 1, -1, -1, 1, 1};



struct IoSetup { IoSetup(int x = 15){ cin.tie(0); ios::sync_with_stdio(0); cout << fixed << setprecision(x); cerr << fixed << setprecision(x); } } iosetup;



template <typename T = i64> T input() { T x; cin >> x; return x; }



template <typename T> ostream &operator<<(ostream &os, vector<T> &v) { range(i, 0, v.size()) { os << v[i] << (i + 1 != v.size() ? " " : ""); } return os; } 

template <typename T> istream &operator>>(istream &is, vector<T> &v) { for (T &in : v) is >> in; return is; }



template <typename T1, typename T2> ostream &operator<<(ostream &os, pair<T1, T2> p) { os << "(" << p.first << ", " << p.second << ")"; return os; }

template <typename T1, typename T2> istream &operator>>(istream &is, pair<T1, T2> &p) { is >> p.first >> p.second; return is; }



template <typename T> vector<T> make_vector(size_t a, T b) { return vector<T>(a, b); }

template <typename... Ts> auto make_vector(size_t a, Ts... ts) { return vector<decltype(make_vector(ts...))>(a, make_vector(ts...)); }



template <typename T1, typename T2> inline bool chmax(T1 &a, T2 b) { return a < b && (a = b, true); }

template <typename T1, typename T2> inline bool chmin(T1 &a, T2 b) { return a > b && (a = b, true); }

// clang-format on



void solver() {

    int N = input();

    map< int, int > cnt;

    range(i, 0, N) {

        cnt[input()]++;

    }

    

//    vector< int > A(N);

//    cin >> A;

    

    int ans = 0;

    int even_cnt = 0;

//    for (auto a: A) even_cnt += !(a & 1);

    for (auto p: cnt) {

        ans++;

        even_cnt += !(p.second & 1);

    }

    

    ans -= (even_cnt & 1);



    cout << ans << endl;

}



signed main(int argc, char *argv[]) {

    solver();

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

const int M=1e5+5;

int a[M],cnt;

int main()

{

    int n;scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        int x;scanf("%d",&x);

        a[x]++;

    }

    int cost=0;

    for(int i=1;i<M;i++)if(a[i]>=2)

    {

        if(a[i]%2==0)

        {

            cost+=a[i]-2;

            cnt++;

        }

        else cost+=a[i]-1;



    }

    cost+=(cnt/2)*2;

    if(cnt%2==1)cost+=2;

    printf("%d\n",n-cost);

}


// Faster C++ solution for the same problem (measured speedup: 1.3845605006499864x):
#include <iostream>

#include <algorithm>

#include <cstring>

#include <set>

using namespace std;



int main()

{

    int n,i,x,m=0;

    cin>>n;

    set<int> s;

    for(i=0;i<n;i++)

    {

        cin>>x;

        if(s.count(x))m++;

        s.insert(x);

    }

    cout<<s.size()-m%2;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <map>

using namespace std;

#define ll long long

#define rep(i, n) for (int i = 0; i < n; i++ )

#define dump(x) cerr << #x << " = " << (x) << endl;

int A[100010];

int cnt[100010];

int main(void){

    int N; cin >> N;

    rep(i, N) cin >> A[i];

    rep(i, N) cnt[A[i]]++;

    rep(i, 100010) {

      if (cnt[i] % 2 == 1) cnt[i] = 1;

      else if (cnt[i] % 2 == 0 && cnt[i] >= 2) cnt[i] = 2;

    }

    int cnt1 = 0;

    int cnt2 = 0;

    rep(i, 100010) if (cnt[i] == 1) cnt1++;

    rep(i, 100010) if (cnt[i] == 2) cnt2++;

    //rep(i, 20) cout << i << " " << cnt[i] << endl;

    cout << cnt1 + cnt2 - cnt2 % 2 << endl;





    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.1129611410399953x):
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000



int cnt[100010];

int main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int N; cin >> N;

    int A[100010];

    rep(i, N) cin >> A[i];

    rep(i, N) cnt[A[i]]++;

    vector<int> v;

    rep(i, 100010) if(cnt[i] > 0) v.push_back(cnt[i]);

    int ans = 0;

    sort(v.begin(), v.end());

    int cnt = 0;

    for(auto& e: v) {

        cnt += max(0, e - 1);

    }

    if(cnt % 2 == 0) {

        cout << v.size() << endl;

    } else {

        cout << v.size() - 1 << endl;

    }

    //cout << cnt << endl;



    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <algorithm>

#include <map>

using namespace std;

#define ll long long

#define rep(i, n) for (int i = 0; i < n; i++ )

#define dump(x) cerr << #x << " = " << (x) << endl;

int A[100010];

int cnt[100010];

int main(void){

    int N; cin >> N;

    rep(i, N) cin >> A[i];

    rep(i, N) cnt[A[i]]++;

    rep(i, 100010) {

      if (cnt[i] % 2 == 1) cnt[i] = 1;

      else if (cnt[i] % 2 == 0 && cnt[i] >= 2) cnt[i] = 2;

    }

    int cnt1 = 0;

    int cnt2 = 0;

    rep(i, 100010) if (cnt[i] == 1) cnt1++;

    rep(i, 100010) if (cnt[i] == 2) cnt2++;

    //rep(i, 20) cout << i << " " << cnt[i] << endl;

    cout << cnt1 + cnt2 - cnt2 % 2 << endl;





    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3672826797839945x):
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000



int cnt[100010];

int main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int N; cin >> N;

    int a[100010];

    rep(i, N) cin >> a[i];

    rep(i, N) cnt[a[i]]++;

    int ans = 0;

    rep(i, 100010) if(cnt[i] > 0) ans++;

    int k = 0;

    rep(i, 100010) if(cnt[i] > 1) k += cnt[i] - 1;

    cout << ans - k % 2 << endl;

    





    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000



int cnt[100010];

int main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int N; cin >> N;

    int A[100010];

    rep(i, N) cin >> A[i];

    rep(i, N) cnt[A[i]]++;

    vector<int> v;

    rep(i, 100010) if(cnt[i] > 0) v.push_back(cnt[i]);

    int ans = 0;

    sort(v.begin(), v.end());

    int cnt = 0;

    for(auto& e: v) {

        cnt += max(0, e - 1);

    }

    if(cnt % 2 == 0) {

        cout << v.size() << endl;

    } else {

        cout << v.size() - 1 << endl;

    }

    //cout << cnt << endl;



    return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.2285089113770413x):
#include <iostream>

#include <fstream>

#include <set>

#include <map>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <functional>

#include <algorithm>

#include <climits>

#include <cmath>

#include <iomanip>

using namespace std;

#define ll long long int

#define rep(i,n) for( int i = 0; i < n; i++ )

#define rrep(i,n) for( int i = n; i >= 0; i-- )

#define REP(i,s,t) for( int i = s; i <= t; i++ )

#define RREP(i,s,t) for( int i = s; i >= t; i-- )

#define dump(x)  cerr << #x << " = " << (x) << endl;

#define INF 2000000000

#define mod 1000000007

#define INF2 1000000000000000000



int cnt[100010];

int main(void)

{

    cin.tie(0);

    ios::sync_with_stdio(false);

    int N; cin >> N;

    int a[100010];

    rep(i, N) cin >> a[i];

    rep(i, N) cnt[a[i]]++;

    int ans = 0;

    rep(i, 100010) if(cnt[i] > 0) ans++;

    int k = 0;

    rep(i, 100010) if(cnt[i] > 1) k += cnt[i] - 1;

    cout << ans - k % 2 << endl;

    





    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int h, n;

vector<int> b;



int dp[101010][10];



int dfs(int i = 1, int bit = 0) {

  if (i == h) {

    return 0;

  }

  bit |= b[i];



  int &ret = dp[i][bit];

  if (~ret)

    return ret;



  ret = 0;

  if (bit == 0)

    ret = max(ret, dfs(i + 1, 0b111) + 2);

  if ((bit & (0b100)) == 0)

    ret = max(ret, dfs(i + 1, 0b110) + 1);

  if ((bit & (0b010)) == 0)

    ret = max(ret, dfs(i + 1, 0b111) + 1);

  if ((bit & (0b001)) == 0)

    ret = max(ret, dfs(i + 1, 0b011) + 1);

  ret = max(ret, dfs(i + 1, 0));



  return ret;

}



int main() {

  memset(dp, -1, sizeof(dp));

  cin >> h >> n;



  int ei[4] = {0b100, 0b110, 0b011, 0b001};

  b.assign(h + 1, 0);

  for (int i = 0; i < n; ++i) {

    int x, y;

    cin >> x >> y;

    b[y + 1] |= ei[x];

    b[y] |= ei[x];

  }



  cout << dfs() << endl;

}


// Faster C++ solution for the same problem (measured speedup: 3.8520393611848562x):
#include <bits/stdc++.h>  // g++ -std=c++14 -o a a.cpp



using namespace std;



typedef pair<int, int> P;

typedef long long ll;

#define rep(i, n) for(int i = 0; i < (n); i++)

#define repto(i, n) for(int i = 0; i <= (n); i++)

#define all(c) (c).begin(), (c).end()

#define uniq(c) c.erase(unique(all(c)), (c).end()) // ユニークなvectorにする。連続した値を除去して切り出す。

#define _1 first

#define _2 second

#define pb push_back

#define INF 1145141919

#define MOD 1000000007

#define DEBUG(x) cout << #x << ": " << x << endl;



__attribute__((constructor))

void initial() {

  cin.tie(0);

  ios::sync_with_stdio(false);

}



int h, n;

vector<int> b;



int dp[10000][8];



int dfs(int i = 1, int bit = 0) {

  if (i == h) { // 最後まで来た場合

    return 0;

  }

  bit |= b[i]; // 置ける状況を取得



  int &ret = dp[i][bit]; // おける最大数、配列の中身を変えたいので参照取得

  if (~ret)

    return ret;  // 計算済みなら返す  retが-1だと~retは0となり計算するために次へ



  ret = 0;

  if (bit == 0) // 2つ置く場合

    ret = max(ret, dfs(i + 1, 0b111) + 2);

  if ((bit & (0b100)) == 0) // 左に置く場合

    ret = max(ret, dfs(i + 1, 0b110) + 1);

  if ((bit & (0b010)) == 0) // 中に置く場合

    ret = max(ret, dfs(i + 1, 0b111) + 1);

  if ((bit & (0b001)) == 0) // 右に置く場合

    ret = max(ret, dfs(i + 1, 0b011) + 1);

  ret = max(ret, dfs(i + 1, 0)); // 置かない場合



  // 5パターンの最大値がretに

  return ret;

}



int main() {

  memset(dp, -1, sizeof(dp));

  cin >> h >> n;



  // eiはそれぞれ x の値に対応するおけない箇所

  int ei[4] = {0b100, 0b110, 0b011, 0b001};

  b.assign(h + 1, 0);

  for (int i = 0; i < n; ++i) {

    int x, y;

    cin >> x >> y;

    // 置けなくなる箇所をパターンとして用意

    b[y + 1] |= ei[x];

    b[y] |= ei[x];

  }



  cout << dfs() << endl;

}
// Slower C++ solution:
#include<iostream>

#include<string>

#include<cstdio>

#include<cstring>

#include<queue>

using namespace std;

int dx[]={-1,0,1,0};

int dy[]={0,1,0,-1};

char ma[888][888];

int n,m,k,dist[888][888],pis[888][888],mn;

queue<pair<int,int> > q;

bool In(int x,int y)

{

	return (x>=0 && x<n && y>=0 && y<m);

}

int main()

{

	mn=1e9;

	scanf("%d%d%d",&n,&m,&k);

	for (int i=0;i<n;i++)

	scanf("%s",ma[i]);

	for (int i=0;i<n;i++)

	{

		for (int j=0;j<m;j++)

		{

			pis[i][j]=min(min(i,j),min(n-i-1,m-j-1));

			pis[i][j]=(pis[i][j]+k-1)/k;

		}

	}

	memset(dist,-1,sizeof(dist));

	for (int i=0;i<n;i++)

	{

		for (int j=0;j<m;j++)

		{

			if (ma[i][j]=='S') 

			{

				q.push(make_pair(i,j));

				dist[i][j]=0;

				mn=min(mn,pis[i][j]+1);

			}

		}

	}

	while(!q.empty())

	{

		int x=q.front().first,y=q.front().second;

		q.pop();

		if (dist[x][y]==k) break;

		for (int i=0;i<4;i++)

		{

			int xx=x+dx[i],yy=y+dy[i];

			if (In(xx,yy) && ma[xx][yy]=='.' && dist[xx][yy]==-1)

			{

				mn=min(mn,pis[xx][yy]+1);

				dist[xx][yy]=dist[x][y]+1;

				q.push(make_pair(xx,yy));

			}

		}

	}

	printf("%d\n",mn);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.2112240354103765x):
#include<bits/stdc++.h>

using namespace std;

const int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

const int N = 810;

int h, w, k, ans, sx, sy;

int d[N][N], q[N * N * 2];

char Map[N][N];

int main()

{

	scanf("%d%d%d", &h, &w, &k);

	for(int i = 0; i <= h + 1; ++i)

		for(int j = 0; j <= w + 1; ++j) Map[i][j] = '#';

	for(int i = 1; i <= h; ++i)

	{

		char s[N];

		scanf("%s", s + 1);

		for(int j = 1; j <= strlen(s + 1); ++j) 

		{

			if(s[j] == 'S')

			{

				sx = i;

				sy = j;

			}

			Map[i][j] = s[j];

		}

	}

	ans = 1 << 29;

	int l = 1, r = 0;

	q[++r] = sx;

	q[++r] = sy;

	while(l <= r)

	{

		int x = q[l++], y = q[l++];

		ans = min(ans, min(min(x - 1, h - x), min(y - 1, w - y)));

		if(d[x][y] == k) continue;

		for(int i = 0; i < 4; ++i)

		{

			int xx = x + dx[i], yy = y + dy[i];

			if(!d[xx][yy] && Map[xx][yy] == '.') 

			{

				q[++r] = xx;

				q[++r] = yy;

				d[xx][yy] = d[x][y] + 1;

			}

		}

	}

	ans = (ans + k - 1) / k + 1;

	printf("%d\n", ans);		

	return 0;

}