Problem: Vasya has an array a_1, a_2, ..., a_n.

You don't know this array, but he told you m facts about this array. The i-th fact is a triple of numbers t_i, l_i and r_i (0 ≤ t_i ≤ 1, 1 ≤ l_i < r_i ≤ n) and it means:

  * if t_i=1 then subbarray a_{l_i}, a_{l_i + 1}, ..., a_{r_i} is sorted in non-decreasing order; 
  * if t_i=0 then subbarray a_{l_i}, a_{l_i + 1}, ..., a_{r_i} is not sorted in non-decreasing order. A subarray is not sorted if there is at least one pair of consecutive elements in this subarray such that the former is greater than the latter. 



For example if a = [2, 1, 1, 3, 2] then he could give you three facts: t_1=1, l_1=2, r_1=4 (the subarray [a_2, a_3, a_4] = [1, 1, 3] is sorted), t_2=0, l_2=4, r_2=5 (the subarray [a_4, a_5] = [3, 2] is not sorted), and t_3=0, l_3=3, r_3=5 (the subarray [a_3, a_5] = [1, 3, 2] is not sorted).

You don't know the array a. Find any array which satisfies all the given facts.

Input

The first line contains two integers n and m (2 ≤ n ≤ 1000, 1 ≤ m ≤ 1000).

Each of the next m lines contains three integers t_i, l_i and r_i (0 ≤ t_i ≤ 1, 1 ≤ l_i < r_i ≤ n).

If t_i = 1 then subbarray a_{l_i}, a_{l_i + 1}, ... , a_{r_i} is sorted. Otherwise (if t_i = 0) subbarray a_{l_i}, a_{l_i + 1}, ... , a_{r_i} is not sorted.

Output

If there is no array that satisfies these facts in only line print NO (in any letter case).

If there is a solution, print YES (in any letter case). In second line print n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^9) — the array a, satisfying all the given facts. If there are multiple satisfying arrays you can print any of them.

Examples

Input


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


Output


YES
1 2 2 3 5 4 4


Input


4 2
1 1 4
0 2 3


Output


NO

Solution (in JAVA):

Solution:
import java.util.*;
 
import javax.lang.model.util.ElementScanner6;
 
import java.io.*;
 
public class Main{
 
    public static void main(String[] args) {
 
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader inp = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Solver solver = new Solver();
        solver.solve(inp, out);
        out.close();
        
        }
 
        
 
 
 
    static class Solver {
        
        class Node implements Comparable<Node>{
            int i;
            int cnt;
        
            Node(int i,int cnt)
            {
                this.i=i;
                this.cnt=cnt;
            }
 
        public int compareTo(Node n)
            {
                if(this.cnt==n.cnt)
                {
                    return Integer.compare(this.i, n.i);
                }
                return Integer.compare(this.cnt, n.cnt);
            }
        }
 
        public boolean done(int[] sp,int[] par)
        {
            int root;
 
            root=findSet(sp[0],par);
            
        for(int i=1;i<sp.length;i++)
        {
                if(root!=findSet(sp[i], par))
                    return false;
        }
        return true;
        }
    public int findSet(int i,int[] par)
    {
        int x =i;
            boolean flag =false;
            while(par[i]>=0)
            {
                flag = true;
                i=par[i];
            }
            if(flag)
                par[x]=i;
            return i;
    }
 
    public void unionSet(int i,int j,int[] par)
    {
            int x = findSet(i, par);
            int y = findSet(j, par);
            if(x<y)
            {
                par[y]=x;
            }
            else
            {
                par[x]=y;
            }
    }
 
    public  long pow(long a, long b, long MOD) {
            if (b == 0) {
                return 1;
            }
            if (b == 1) {
                return a;
            }
            long val = pow(a, b / 2, MOD);
            if (b % 2 == 0) {
                return val * val % MOD;
            } else {
                return val * (val * a % MOD) % MOD;
 
            }
        
        }
 
 
        public void minPrimeFactor(int n,int[] s)
        {
            boolean prime[] = new boolean[n+1];
            Arrays.fill(prime, true);
            s[1]=1;
            s[2]=2;
            for(int i=4;i<=n;i+=2)
            {
                prime[i]=false;
                s[i]=2;
            }
 
            for(int i=3;i<=n;i+=2)
            {
                if(prime[i])
                {
                    s[i]=i;
                    for(int j=2*i;j<=n;j+=i)
                    {
                        prime[j]=false;
                        s[j]=i;
                    }
                }
            }
            
        }
 
        
        public void findAllPrime(int n,ArrayList<Node> al,int s[])
        {
            int curr = s[n];
            int cnt = 1;
            while(n>1)
            {
                n/=s[n];
                if(curr==s[n])
                {
                    cnt++;
                    continue;
 
                }
                Node n1 = new Node(curr,cnt);
                al.add(n1);
 
                curr=s[n];
                cnt=1;
            }
        }
 
        
 
        public int binarySearch(int n,int k)
        {
            int left=1;
            int right=100000000+5;
            int ans=0;
            while(left<=right)
            {
                int mid = (left+right)/2;
                if(n/mid>=k)
                {
                    left = mid+1;
                    ans=mid;
                }
                else
                {
                    right=mid-1;
                }
            }
 
            return ans;
        }
        public boolean checkPallindrom(String s)
        {
            char ch[] = s.toCharArray();
 
            for(int i=0;i<s.length()/2;i++)
            {
                if(ch[i]!=ch[s.length()-1-i])
                    return false;
            }
            return true;
        }
 
 
        public void dfs_util(ArrayList<Integer>[] al,boolean vis[],int x,int cnt[],int sts[],int fts[],long sv[])
        {
                
            vis[x] = true;
            long min=Long.MAX_VALUE;
                sts[cnt[0]]=x+1;
                for(int i=0;i<al[x].size();i++)
                {
                    
                    if(!vis[al[x].get(i)])
                    {
                        cnt[0]++;
                        dfs_util(al, vis, al[x].get(i),cnt,sts,fts,sv);
                        if(sv[al[x].get(i)]<min&&sv[al[x].get(i)]!=-1)
                        {
                            min=sv[al[x].get(i)];
                        }
                        
                        
                    }    
                    
                }
 
            
                if(sv[x]==-1)
                {
                    if(min==Long.MAX_VALUE)
                    {
                        min=-1;
                    }
                    sv[x]=min;
                }
            
            
            return ;
        }
 
        public void dfs(ArrayList[] al,int sts[],int fts[],long sv[])
        {
            
        boolean vis[] = new boolean[al.length];
        int cnt[]= new int[2*al.length+2];
        for(int i=0;i<al.length;i++)
        {
                if(!vis[i])
                {
                    
                    dfs_util(al,vis,i,cnt,sts,fts,sv);
                }
        }
        }
 
        public void remove(ArrayList<Integer>[] al,int x)
        {
            for(int i=0;i<al.length;i++)
            {
                for(int j=0;j<al[i].size();j++)
                {
 
                    if(al[i].get(j)==x)
                        al[i].remove(j);
 
                }
            }
        }
 
        public int gcd(int a, int b) 
        { 
            if (a == 0) 
                return b; 
            return gcd(b % a, a); 
        }
 
 
        public void printDivisors(int n,ArrayList<Integer> al) 
        { 
            // Note that this loop runs till square root 
            for (int i=1; i<=Math.sqrt(n); i++) 
            { 
                if (n%i==0) 
                { 
                    // If divisors are equal, print only one 
                    if (n/i == i) 
                    {
                        al.add(i);
                    }
                      
        
                    else // Otherwise print both 
                    {
                        al.add(i);
                        al.add(n/i);
                    }
                        
                } 
            } 
        } 
 
        public static long constructSegment(long seg[],long arr[], int low,int high,int pos)
        {
            if(low==high)
            {
                seg[pos] = arr[low]; 
                return seg[pos];
            }
            int mid = (low+high)/2;
            long t1=constructSegment(seg, arr,low , mid,(2*pos)+1);
            long t2=constructSegment(seg,arr,mid+1,high,(2*pos)+2);
            seg[pos] = t1+t2;
            return seg[pos];
 
        }
        public static long querySegment(long seg[],int low,int high,int qlow, int qhigh,int pos)
        {
            
             if(qlow<=low&&qhigh>=high)
             {
                return seg[pos];
             }
             else if(qlow>high||qhigh<low )
             {
                 return 0;
             }
             else{
                long ans=0;
                int mid=(low+high)/2;
                ans+=querySegment(seg,low , mid, qlow, qhigh,  (2*pos)+1);
                ans+=querySegment(seg, mid+1, high, qlow, qhigh, (2*pos)+2);
               return ans; 
             }
 
        }
        public static int lcs( char[] X, char[] Y, int m, int n ) 
        { 
            if (m == 0 || n == 0) 
            return 0; 
            if (X[m-1] == Y[n-1]) 
            return 1 + lcs(X, Y, m-1, n-1); 
            else
            return Integer.max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n)); 
        } 
 
        public static long recursion(long start,long end,long cnt[],int a, int b)
        {
 
            long min=0;
            long count=0;
            int ans1=-1;
            int ans2=-1;
            int l=0;
            int r=cnt.length-1;
            while(l<=r)
            {
                int mid=(l+r)/2;
                if(cnt[mid]>=start)
                {
                    ans1=mid;
                    r=mid-1;
                }
                else
                {
                    l=mid+1;
                }
            }
 
            l=0;
            r=cnt.length-1;
            while(l<=r)
            {
                int mid=(l+r)/2;
                if(cnt[mid]<=end)
                {
                    ans2=mid;
                    l=mid+1;
                }
                else
                {
                    r=mid-1;
                }
            }
            
            if(ans1==-1||ans2==-1||ans2<ans1)
            {
                // System.out.println("min1 "+min);
                min=a;
                return a;
 
            }
            else
            {
                min=b*(end-start+1)*(ans2-ans1+1);
            }
            if(start==end)
            {
                // System.out.println("min "+min);
                return min;
            }
            long mid = (end+start)/2;
            min = Long.min(min,recursion(start, mid, cnt, a, b)+recursion(mid+1, end, cnt, a, b));
            // System.out.println("min "+min);
            return min;
        }
 
        public void dfs(int x, ArrayList<Integer> al[], boolean[] vis)
        {
            vis[x]=true;
            System.out.print((x+1)+" ");
            for(int i=0;i<al[x].size();i++)
            {
                if(!vis[al[x].get(i)])
                {
                    dfs(al[x].get(i),al,vis);
                }
            }
        }
 
 
        
      
 
        private void solve(InputReader inp, PrintWriter out1) {
 
          int n = inp.nextInt();
          int m = inp.nextInt();
          
          ArrayList<ele> ans1 = new ArrayList<ele>();
          ArrayList<ele> ans = new ArrayList<ele>();
            int p=10000;
            int arr[] = new int[n];
          for(int i=0;i<m;i++)
          {
              int t = inp.nextInt();
              int x1 = inp.nextInt();
              int x2 = inp.nextInt();
              if(t==1)
              {
                ans.add(new ele(x1,x2));
              }
              else
              {
                ans1.add(new ele(x1, x2));
              }
          }
 
          
         Collections.sort(ans); 
          Collections.sort(ans1);

          for(int i=0;i<ans.size();i++)
          {
              int x1 = ans.get(i).value;
              int x2 =  ans.get(i).i;

              for(int j=x1;j<x2;j++)
              {
                  arr[j]=arr[j-1]+1;
              }
          }
         

        //   for(int i=0;i<arr.length;i++)
        //   {
        //       out1.print(arr[i]+" ");
        //   }


          for(int i=0;i<ans1.size();i++)
          {
              int x1 = ans1.get(i).value;
              int x2 = ans1.get(i).i;
              boolean f = false;
              for(int j=x1;j<x2;j++)
              {

                    
                    if(arr[j]<arr[j-1])
                    {
                        f=true;
                        break;
                    }
                  
                    if(arr[j]==0)
                    {
                        arr[j]=arr[j-1]-1;
                        f=true;
                        break;
                    }
                    
              }
            //   for(int k=0;k<arr.length;k++)
            //   {
            //       out1.print(arr[k]+" ");
            //   }
            //   out1.println();

              if(!f)
              {
                  out1.println("NO");
                  return;
              }
          }
         
         


          out1.println("YES");
          for(int i=0;i<arr.length;i++)
          {
              out1.print((arr[i]+n)+" ");
          }
          
 
        }
}
 
 
 
 
 
    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;
 
        InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
 
        String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
        public long nextLong() {
            return Long.parseLong(next());
        }
    }
}
class ele implements Comparable<ele>{
    int value;
    int i;
    boolean flag;
    public ele(int value,int i)
    {
        this.value = value;
        this.i=i;
        this.flag = false;
    }
    public int compareTo(ele e)
    {
        return Integer.compare(this.value,e.value);
    }
}