#include<bits/stdc++.h>
using namespace std;
#define gc getchar_unlocked
#define Fo(i,n) for(int i=0;i<n;i++)
#define fo(i,k,n) for(int i=k;k<n?i<n:i>n;k<n?i+=1:i-=1)
#define ll long long
#define si(x) scanf("%d",&x)
#define sl(x) scanf("%lld",&x)
#define ss(s) scanf("%s",s)
#define pi(x) printf("%d\n",x)
#define pl(x) printf("%lld\n",x)
#define ps(s) printf("%s\n",s)
#define deb(x) cout << #x << "=" << x << endl
#define deb2(x, y) cout << #x << "=" << x << "," << #y << "=" << y << endl
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define all(x) x.begin(), x.end()
#define clr(x) memset(x, 0, sizeof(x))
#define sortall(x) sort(all(x))
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
typedef pair<int, int>  pii;
typedef pair<ll, ll>  pl;
typedef vector<int>   vi;
typedef vector<ll>    vl;
typedef vector<pii>   vpii;
typedef vector<pl>    vpl;
typedef vector<vi>    vvi;
typedef vector<vl>    vvl;
mt19937_64 rang(chrono::high_resolution_clock::now().time_since_epoch().count());
// int rng(int lim) {
//   uniform_int_distribution<int> uid(0, lim - 1);
//   return uid(rang);
// }
ll mpow(ll base, ll exp);
ll power(ll a,ll b);


const ll mod = 1e9+7 ;
//const int N = 3e5, M = N;
  vi g[300001];
  //int cnt[100002];

  // map<pii,int> w;
   //int vis[300001];
  // ll res[300001];
  // ll sum[300001];

  // ll sz[300001];
 //int dist[300001];

//=====================================================================

// ll fact[200001];
// ll fact_inv[200001];

// void pre_calc()
// {
//   int maxN=10000;
//   fact[0]=1;
//   fact_inv[0]=mpow(1,mod-2);

//   for(ll i=1;i<=maxN;i++)
//   {
//     fact[i]=(fact[i-1]*i)%mod;
//     fact_inv[i]=mpow(fact[i],mod-2);
//   }
// }

// ll ncr(ll n,ll r)
// {

//   if(r>n)
//     return 0;
//   ll res=fact[n];
//   res=(res*fact_inv[r])%mod;
//   res=(res*fact_inv[n-r])%mod;
//   return res;
// }
struct node
{
  set<int> s;
};
// struct operatr
// {
//   int a,d;
// };
struct segTree
{
  ll arr[2001];
  ll res[8003];

  int operation_arr[4003];
  int NO_OPERATION=0;

  void init(int x,int lo,int hi)
  {
    //operation_arr[x]=NO_OPERATION;
    

    if(lo==hi){
      
      res[x]=arr[lo];
      return;
    }

    int mid=(lo+hi)/2;
    init(2*x,lo,mid);
    init(2*x+1,mid+1,hi);

    //update(x,lo,hi);
    
    update_point(x);
  }

  

  int merge_operation(int a,int b)//apply operation b to a
  {
    return (a^b);
  }

  // int operate(int a,int o,int lo,int hi)
  // {
  //   int len=hi-lo+1;
  //   return a+len*o;
  // }

  ll merge_results(int a,int b)
  {
    return a+b;
  }  


  void modify(int x,int lo, int hi, int l, int r,int op)
  {
    prop(x,lo,hi);

    if(lo>=l&&hi<=r){
      operation_arr[x]=merge_operation(operation_arr[x],op);
      return;
    }

    int mid=(lo+hi)/2;


    if(lo>r||hi<l)
      return;

    modify(2*x,lo,mid,l,r,op);
    modify(2*x+1,mid+1,hi,l,r,op);

    
    update(x,lo,hi);
  }
  int get_sum(int x,int lo,int hi,int l,int r)
  {
    if(lo>=l&&hi<=r)
      return res[x];

    if(lo>r||hi<l)
      return 0;

    int mid=(lo+hi)/2;
    return get_sum(2*x,lo,mid,l,r)+get_sum(2*x+1,mid+1,hi,l,r);
  }



  // void point_change(int x,int lo,int hi,int l,int r)
  // {
    

  //   if(lo>r||hi<l)
  //     return;

  //   if(res[x]<3)
  //     return;

  //   if(lo==hi)
  //   {
      
  //     res[x]=cnt[res[x]];
  //     res1[x]=cnt[res1[x]];
  //     return;
  //   }



  //   int mid=(lo+hi)/2;

  //   point_change(2*x,lo,mid,l,r);
  //   point_change(2*x+1,mid+1,hi,l,r);

  //   update_point1(x);
  //   update_point(x);
  // }

  void point_modify(int x,int lo,int hi,int pos,ll val)
  {
    if(lo==hi)
    {
      res[x]=val;
      return;
    }

    int mid=(lo+hi)/2;


    if(pos<=mid)
      point_modify(2*x,lo,mid,pos,val);
    else
      point_modify(2*x+1,mid+1,hi,pos,val);
    update_point(x);
  }

  // ll get_val(int x,int lo,int hi,int pos)
  // {
  //   if(lo==hi)
  //     return res[x];

  //   int mid=(lo+hi)/2;

  //   if(pos<=mid)
  //     return get_val(2*x,lo,mid,pos);
  //   else
  //     return get_val(2*x+1,mid+1,hi,pos);

  // }

  ll max_query(int x,int lo,int hi,int l,int r)
  {
    if(lo>=l&&hi<=r)
      return res[x];

    if(lo>r||hi<l)
      return LLONG_MIN;

    int mid=(lo+hi)/2;

    return max(max_query(2*x,lo,mid,l,r),max_query(2*x+1,mid+1,hi,l,r));
  }


  void update_point(int x)
  {
    res[x]=max(res[2*x],res[2*x+1]);
  }
  

  int query(int x,int lo,int hi,int l,int r)
  {
    prop(x,lo,hi);
    
    
    if(lo>=l&&hi<=r)
      return operate(res[x],operation_arr[x],lo,hi);

    if(lo>r||hi<l)
      return 0;

    int mid=(lo+hi)/2;
    return merge_results(query(2*x,lo,mid,l,r),query(2*x+1,mid+1,hi,l,r));

  }

  

  int kth_one(int x,int lo,int hi,int k)
  {
    if(lo==hi)
      return lo;

    int v1=res[2*x];
    int mid=(lo+hi)/2;

    if(k<=v1)
      return kth_one(2*x,lo,mid,k);
    else
      return kth_one(2*x+1,mid+1,hi,k-v1);
  }
  



  // ll point_query(int x,int lo, int hi, int val)
  // {
  //   //prop(x,lo,hi);

  //   if(lo==hi)
  //     return lo;

  //   int mid=(lo+hi)/2;

  //   int v1=res[2*x];

  //   if(v1==val)
  //     return point_query(2*x,lo,mid,val);
  //   else
  //     return point_query(2*x+1,mid+1,hi,val);
  // }
  

  void prop(int x,int lo, int hi)
  {
    if(lo==hi)
      return;

    int mid=(hi+lo)/2;
    ll len=mid-lo+1;

    operation_arr[2*x]=merge_operation(operation_arr[2*x],operation_arr[x]);
    operation_arr[2*x+1]=merge_operation(operation_arr[2*x+1],operation_arr[x]);


    operation_arr[x]=NO_OPERATION;
    

    update(x,lo,hi);
  }
  int operate(int val,int operatr,int l,int r)
  {
    if(operatr==NO_OPERATION)
      return val;
    int sz=r-l+1;

    return sz-val;
  }
  

  void update(int x,int lo,int hi)
  {
    if(lo==hi)
      return;
    int mid=(lo+hi)/2;
    ll len1=(mid-lo+1);
    ll len2=(hi-mid);
    res[x]=merge_results(operate(res[2*x],operation_arr[2*x],lo,mid),operate(res[2*x+1],operation_arr[2*x+1],mid+1,hi));
  }

  
};


struct  FenwickTree
{
  int arr[100];
  int n;

  void update(int i,int delta)
  {
    while(i<=n)
    {
      arr[i]+=delta;
      i=i+(i&(-i));
    }
  }

  int sum(int i)
  {
    if(i==0)
      return 0;
    int res=0;
    while(i>0)
    {
      res=res+arr[i];
      i-=(i&(-i));
    }

    return res;
  }

};



struct dsu
{
  int par[1001];
  int size_set[1001];
 
  int get_par(int u)
  {
    vi temp;
    while(par[u]!=u)
    {
      temp.pb(u);
      u=par[u];
    }
 
    for(int i:temp)
      par[i]=u;
 
    return u;
  }
 
  void union_set(int a,int b)
  {
    a=get_par(a);
    b=get_par(b);
 
    if(a==b)
      return;
    if(size_set[a]<size_set[b])
    {
      int temp=a;
      a=b;
      b=temp;
    }
 
    //assuming a to have a larger size
    par[b]=a;
    
    size_set[a]+=size_set[b];
    // transfer all elements in b to a
 
    
  }
  
  
};

int check(string s1,string s2)//p,s
{
  int n1=s1.size();
  int n2=s2.size();
  s1='$'+s1;
  s2='$'+s2;

  int dp[n1+1][n2+1];

  for(int j=0;j<=n2;j++)
    dp[0][j]=0;

  dp[0][0]=1;

  for(int i=1;i<=n1;i++)
  {
      dp[i][0]=0;
  }

  int i1=1;

  while(i1<=n1&&s1[i1]=='*')
  {
    dp[i1][0]=1;
    i1++;
  }

  int sum[n2+1];

  int s=0;
  for(int i=0;i<=n2;i++)
    s=s+dp[0][i],sum[i]=s;


  for(int i=1;i<=n1;i++)
  {
    for(int j=1;j<=n2;j++)
    {
      char c1=s1[i];
      char c2=s2[j];

      if(c1=='*')
      {
        if(sum[j]>0)
          dp[i][j]=1;
        else
          dp[i][j]=0;
      }
      else if(c1=='?')
      {
        dp[i][j]=dp[i-1][j-1];
      }
      else
      {
        if(c1!=c2)
          dp[i][j]=0;
        else
          dp[i][j]=dp[i-1][j-1];
      }
    }
    s=0;
    for(int j=0;j<=n2;j++)
    {
      s+=dp[i][j];
      sum[j]=s;
    }
  }

  return dp[n1][n2];
}



ll gcd(ll a, ll b)
{
  if(a==0)
    return b;

    if (b == 0)
        return a;
    return gcd(b, a % b); 
     
}


// int a[100002];
// int curr_ans=0;
// map<int,int> coded;
// int code2[100001];


// struct queries
// {
//   int l,r,lb,rb,idx;
// };

// bool cmp(queries a,queries b)
// {
//   if(a.lb!=b.lb)
//     return a.lb<b.lb;

//   if(a.lb%2==1)
//     return a.r<b.r;
//   else
//     return a.r>b.r;

// }

// void add_elememt(int x)
// {
//    if(cnt[code2[x]]==a[x])
//     curr_ans--;

//   cnt[coded[a[x]]]++;

//   if(cnt[code2[x]]==a[x])
//     curr_ans++;
// }

// void remove_element(int x)
// {
//   if(cnt[code2[x]]==a[x])
//     curr_ans--;

//   cnt[code2[x]]--;

//   if(cnt[code2[x]]==a[x])
//     curr_ans++;

// }

// bool contains_dup(string s)
// {
//   int cnt[26];
//   memset(cnt,0,sizeof(cnt));

//   for(int i=0;i<s.size();i++)
//   {
//     cnt[s[i]-'a']++;
//     if(cnt[s[i]-'a']>1)
//       return 1;
//   }
//   return 0;
// }

ll pw1[21];
ll pw2[21];

ll m1=1e9+7;
ll m2=1e9+9;

ll base=30;

// void pre_calc()
// {
//   pw1[0]=1;
//   pw2[0]=1;

//   for(int i=1;i<=20;i++)
//   {
//     pw1[i]=(pw1[i-1]*base)%m1;
//     pw2[i]=(pw2[i-1]*base)%m2;
//   }
// }

pl string_hash(string s)
{
  ll res1=0,res2=0;

  for(int i=0;i<s.size();i++)
  {
    int v=s[i]-'a';

    res1=(res1+v*pw1[i])%m1;
    res2=(res2+v*pw2[i])%m2;
  } 

  return mp(res1,res2);
}


bool isOverflow(long long a, long long b) 
{ 
    // Check if either of them is zero 
    if (a == 0 || b == 0)  
        return false; 
      
    //long long result = a * b; 
    if (a <= LLONG_MAX / b) 
        return false; 
    else
        return true; 
} 
bool isOverflow_add(ll a,ll b)
{
  ll res=a+b;

  if(res-a==b&&res-b==a)
    return 0;
  return 1;
}



ll fact(ll i)
{
  ll res=1;
  for(int j=1;j<=i;j++)
    res*=j;

  return res;
}


void solve()
{
  int n,m;
  cin>>n>>m;

  vpii blocks;

  for(int i=1;i<=m;i++)
  {
    int r,c;
    cin>>r>>c;


    blocks.pb({c,r});
  } 
  sortall(blocks);

  vpii b;

  int i=0;
  while(i<m)
  {
    int c=blocks[i].F;
    int r1=blocks[i].S;

    int cnt=0;
    while(i<m&&blocks[i].F==c)
      cnt++,i++;

    if(cnt==2)
      b.pb({c,3});
    else
    {
      if(r1==1)
        b.pb({c,1});
      else
        b.pb({c,2});
    }

  }

  int t1=0,t2=0;
  int pre_t1=-1;
  int pre_t2=-1;

  for(i=0;i<b.size();i++)
  {
    //deb(b[i].S);

    if(b[i].S==1)
    {
      //deb2(pre_t1,pre_t2);

      if(pre_t1!=-1&&(b[i].F-pre_t1)%2==0)
      {
        cout<<"NO"<<"\n";
        return;
      }

      if(pre_t2!=-1&&(b[i].F-pre_t2)%2==1)
      {
        cout<<"NO"<<"\n";
        return;
      }

      if(pre_t1!=-1&&(b[i].F-pre_t1)%2==1)
        pre_t1=-1;
      else if(pre_t2!=-1&&(b[i].F-pre_t2)%2==0)
        pre_t2=-1;
      else
        pre_t1=b[i].F;
      //deb(pre_t1);

    }
    if(b[i].S==2)
    {
      //deb2(pre_t1,pre_t2);

      if(pre_t2!=-1&&(b[i].F-pre_t2)%2==0)
      {
        cout<<"NO"<<"\n";
        return;
      }

      if(pre_t1!=-1&&(b[i].F-pre_t1)%2==1)
      {
        cout<<"NO"<<"\n";
        return;
      }

      if(pre_t1!=-1&&(b[i].F-pre_t1)%2==0)
        pre_t1=-1;
      else if(pre_t2!=-1&&(b[i].F-pre_t2)%2==1)
        pre_t2=-1;
      else
        pre_t2=b[i].F;
    }
    if(b[i].S==3)
    {
      if(pre_t1!=-1||pre_t2!=-1)
      {
        cout<<"NO"<<"\n";
        return;
      }
    }

  }


  if(pre_t2==-1&&pre_t1==-1)
    cout<<"YES"<<"\n";
  else
    cout<<"NO"<<"\n";

  
}
int main()
{



   #ifndef ONLINE_JUDGE
          freopen("input.txt","r",stdin);
          freopen("output.txt","w",stdout);
    #endif

    ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    srand(chrono::high_resolution_clock::now().time_since_epoch().count());
    //seive();
    
    //pre_calc();
    int t = 1;
    cin >> t;
    while(t--)
    {
        solve();
    }

    return 0;
}
//=======================================================================================
ll mpow(ll base, ll exp)
{
    base %= mod;
    ll result = 1;
    while (exp > 0)
    {
        if (exp & 1)
          result = ((ll)result * base) % mod;
        base = ((ll)base * base) % mod;
        exp >>= 1;
  }
  return result;
}



ll power(ll a,ll b)
{
  ll res=1;
  while(b>0)
  {
    if(b%2==0)
    {
      b/=2;

      if(isOverflow(a,a))
        return LLONG_MAX;
      a=a*a;
    }
    else
    {
      if(isOverflow(res,a))
        return LLONG_MAX;
      res=res*a;
      b--;
    }
  }
  return res;
}