As an experiment the Educational Codeforces Round 33 will be rated for Div. 2.
×

Virtual contest is a way to take part in past contest, as close as possible to participation on time. It is supported only ACM-ICPC mode for virtual contests.
If you've seen these problems, a virtual contest is not for you - solve these problems in the archive.
If you just want to solve some problem from a contest, a virtual contest is not for you - solve this problem in the archive.
Never use someone else's code, read the tutorials or communicate with other person during a virtual contest.

No tag edit access

F. Sequence Recovery

time limit per test

2 secondsmemory limit per test

256 megabytesinput

standard inputoutput

standard outputZane once had a good sequence *a* consisting of *n* integers *a*_{1}, *a*_{2}, ..., *a*_{n} — but he has lost it.

A sequence is said to be good if and only if all of its integers are non-negative and do not exceed 10^{9} in value.

However, Zane remembers having played around with his sequence by applying *m* operations to it.

There are two types of operations:

1. Find the maximum value of integers with indices *i* such that *l* ≤ *i* ≤ *r*, given *l* and *r*.

2. Assign *d* as the value of the integer with index *k*, given *k* and *d*.

After he finished playing, he restored his sequence to the state it was before any operations were applied. That is, sequence *a* was no longer affected by the applied type 2 operations. Then, he lost his sequence at some time between now and then.

Fortunately, Zane remembers all the operations and the order he applied them to his sequence, along with the distinct results of all type 1 operations. Moreover, among all good sequences that would produce the same results when the same operations are applied in the same order, he knows that his sequence *a* has the greatest cuteness.

We define cuteness of a sequence as the bitwise OR result of all integers in such sequence. For example, the cuteness of Zane's sequence *a* is *a*_{1} OR *a*_{2} OR ... OR *a*_{n}.

Zane understands that it might not be possible to recover exactly the lost sequence given his information, so he would be happy to get any good sequence *b* consisting of *n* integers *b*_{1}, *b*_{2}, ..., *b*_{n} that:

1. would give the same results when the same operations are applied in the same order, and

2. has the same cuteness as that of Zane's original sequence *a*.

If there is such a sequence, find it. Otherwise, it means that Zane must have remembered something incorrectly, which is possible.

Input

The first line contains two integers *n* and *m* (1 ≤ *n*, *m* ≤ 3·10^{5}) — the number of integers in Zane's original sequence and the number of operations that have been applied to the sequence, respectively.

The *i*-th of the following *m* lines starts with one integer *t*_{i} () — the type of the *i*-th operation.

If the operation is type 1 (*t*_{i} = 1), then three integers *l*_{i}, *r*_{i}, and *x*_{i} follow (1 ≤ *l*_{i} ≤ *r*_{i} ≤ *n*, 0 ≤ *x*_{i} ≤ 10^{9}) — the leftmost index to be considered, the rightmost index to be considered, and the maximum value of all integers with indices between *l*_{i} and *r*_{i}, inclusive, respectively.

If the operation is type 2 (*t*_{i} = 2), then two integers *k*_{i} and *d*_{i} follow (1 ≤ *k*_{i} ≤ *n*, 0 ≤ *d*_{i} ≤ 10^{9}) — meaning that the integer with index *k*_{i} should become *d*_{i} after this operation.

It is guaranteed that *x*_{i} ≠ *x*_{j} for all pairs (*i*, *j*) where 1 ≤ *i* < *j* ≤ *m* and *t*_{i} = *t*_{j} = 1.

The operations are given in the same order they were applied. That is, the operation that is given first was applied first, the operation that is given second was applied second, and so on.

Output

If there does not exist a valid good sequence, print "NO" (without quotation marks) in the first line.

Otherwise, print "YES" (without quotation marks) in the first line, and print *n* space-separated integers *b*_{1}, *b*_{2}, ..., *b*_{n} (0 ≤ *b*_{i} ≤ 10^{9}) in the second line.

If there are multiple answers, print any of them.

Examples

Input

5 4

1 1 5 19

1 2 5 1

2 5 100

1 1 5 100

Output

YES

19 0 0 0 1

Input

5 2

1 1 5 0

1 1 5 100

Output

NO

Note

In the first sample, it is easy to verify that this good sequence is valid. In particular, its cuteness is 19 OR 0 OR 0 OR 0 OR 1 = 19.

In the second sample, the two operations clearly contradict, so there is no such good sequence.

Codeforces (c) Copyright 2010-2017 Mike Mirzayanov

The only programming contests Web 2.0 platform

Server time: Nov/23/2017 03:07:43 (c6).

Desktop version, switch to mobile version.

User lists

Name |
---|