#include<cstdio>

#include<cstring>

#include<algorithm>

#include<cctype>

#include<cstdlib>

#include<map>

#define maxn 2200010

#define maxd 100020

#define base r+c

using namespace std;

inline long long read(){

    long long num=,f=;

    char ch=getchar();

    while(!isdigit(ch)){

        if(ch=='-')    f=-;

        ch=getchar();

    }

    while(isdigit(ch)){

        num=num*+ch-'';

        ch=getchar();

    }

    return num*f;

}

int dfn[maxn],cnt;

int stack[maxn],top;

int col[maxn],ID;

bool vis[maxn];

int low[maxn];

int size[maxn],sum[maxn];

bool ext[maxn];

int n,r,c;

int ans;

struct Pic{

    struct Edge{

        int next,to;

    }edge[maxn*];

    int head[maxn],num;

    Pic(){memset(head,,sizeof(head));}

    inline void add(int from,int to){

        edge[++num]=(Edge){head[from],to};

        head[from]=num;

    }

    void tarjan(int x){

        //printf("%d\n",x);

        dfn[x]=low[x]=++cnt;

        vis[x]=;    stack[++top]=x;

        for(int i=head[x];i;i=edge[i].next){

            int to=edge[i].to;

            if(dfn[to]==){

                tarjan(to);

                low[x]=min(low[x],low[to]);

            }

            else if(vis[to])    low[x]=min(low[x],dfn[to]);

        }

        if(low[x]==dfn[x]){

            col[x]=++ID;    vis[x]=;

            if(x>base)    size[ID]++;

            while(stack[top]!=x){

                col[stack[top]]=ID;

                vis[stack[top]]=;

                if(stack[top]>base)    size[ID]++;

                top--;

            }

            top--;

        }

    }

    void dfs(int x){

        vis[x]=;

        for(int i=head[x];i;i=edge[i].next){

            int to=edge[i].to;

            if(vis[to]){

                sum[x]=max(sum[x],sum[to]);

                continue;

            }

            dfs(to);

            sum[x]=max(sum[x],sum[to]);

        }

        sum[x]+=size[x];

        ans=max(ans,sum[x]);

        return;

    }

}Old,New;

map<long long,int>d;

inline long long calc(long long i,long long j){    return (i-)*c+j+base;    }

struct Node{

    int x,y,id,opt;

}q[maxd];

int u[]={,-,-,,,,,,-};

int w[]={,,,,,,-,-,-};

int main(){

    n=read(),r=read(),c=read();

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

        int x=read(),y=read(),opt=read();

        long long now=calc(x,y);

        ext[x]=ext[y+r]=ext[i+base]=;

        Old.add(x,i+base);

        Old.add(y+r,i+base);

        q[i]=(Node){x,y,i+base,opt};

        d[now]=i+base;

    }

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

        int opt=q[i].opt;

        if(opt==)        Old.add(q[i].id,q[i].x);

        else if(opt==)    Old.add(q[i].id,q[i].y+r);

        else{

            for(int j=;j<;++j){

                int x=q[i].x+u[j],y=q[i].y+w[j];

                if(x<||x>r||y<||y>c)    continue;

                if(d.count(calc(x,y)))    Old.add(q[i].id,d[calc(x,y)]);

            }

        }

    }

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

        if(ext[i]&&dfn[i]==)    Old.tarjan(i);

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

        for(int j=Old.head[i];j;j=Old.edge[j].next){

            int to=Old.edge[j].to;

            if(col[i]==col[to])    continue;

            New.add(col[i],col[to]);

        }

    for(int i=;i<=ID;++i)

        if(vis[i]==)    New.dfs(i);

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

    return ;

}