Codeforces Round #275 (Div. 2) A,B,C,D

A. Counterexample

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.

Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.

You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.

More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair(a, c) is not coprime.

Input

The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).

Output

Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.

If the counterexample does not exist, print the single number -1.

Examples

input

2 4

output

2 3 4

input

10 11

output

-1

input

900000000000000009 900000000000000029

output

900000000000000009 900000000000000010 900000000000000021

Note

In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.

In the second sample you cannot form a group of three distinct integers, so the answer is -1.

In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.

暴力；

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pi (4*atan(1.0))
#define eps 1e-14
#define bug(x,y) cout<<"bug"<<x<<" "<<y<<endl;
#define bug(x) cout<<"xxx "<<x<<endl;
const int N=1e5+,M=1e6+,inf=2e9+,mod=;
const ll INF=1e18+;
int main()
{
    ll l,r;
    scanf("%lld%lld",&l,&r);
    for(ll i=l;i<=r;i++)
    {
        for(ll j=i+;j<=r;j++)
        {
            for(ll k=j+;k<=r;k++)
            {
                if(i==j||i==k||j==k)continue;
                if(__gcd(i,j)==&&__gcd(j,k)==&&__gcd(i,k)!=)
                    return *printf("%lld %lld %lld\n",i,j,k);
            }
        }
    }
    printf("-1\n");
    return ;
}

B. Friends and Presents

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

You have two friends. You want to present each of them several positive integers. You want to present cnt1 numbers to the first friend and cnt2 numbers to the second friend. Moreover, you want all presented numbers to be distinct, that also means that no number should be presented to both friends.

In addition, the first friend does not like the numbers that are divisible without remainder by prime number x. The second one does not like the numbers that are divisible without remainder by prime number y. Of course, you're not going to present your friends numbers they don't like.

Your task is to find such minimum number v, that you can form presents using numbers from a set 1, 2, ..., v. Of course you may choose not to present some numbers at all.

A positive integer number greater than 1 is called prime if it has no positive divisors other than 1 and itself.

Input

The only line contains four positive integers cnt1, cnt2, x, y (1 ≤ cnt1, cnt2 < 109; cnt1 + cnt2 ≤ 109; 2 ≤ x < y ≤ 3·104) — the numbers that are described in the statement. It is guaranteed that numbers x, y are prime.

Output

Print a single integer — the answer to the problem.

Examples

input

3 1 2 3

output

5

input

1 3 2 3

output

4

Note

In the first sample you give the set of numbers {1, 3, 5} to the first friend and the set of numbers {2} to the second friend. Note that if you give set {1, 3, 5} to the first friend, then we cannot give any of the numbers 1, 3, 5 to the second friend.

In the second sample you give the set of numbers {3} to the first friend, and the set of numbers {1, 2, 4} to the second friend. Thus, the answer to the problem is 4.

题意：第一个人需要cnt1个数，并且每个数都不被x整除，第二个人需要cnt2个数，并且每个数都不被y整除；

　　  求最小的v，使得1-v，v个数可以使得两个都能拿到各自数目的数；

思路：二分v即可，主要在于check怎么写；

　　  有点类似容斥的原理，先把两个都不能放的去掉，然后将不能放2的尽量放1 ，不能放1 的尽量放2；

　　　然后把v剩余与cnt1，cnt2剩余比较；

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pi (4*atan(1.0))
#define eps 1e-14
#define bug(x,y) cout<<"bug"<<x<<" "<<y<<endl;
#define bug(x) cout<<"xxx "<<x<<endl;
const int N=1e5+,M=1e6+,inf=2e9+,mod=;
const ll INF=1e18+;
ll check(ll x,ll a,ll b,ll cnt1,ll cnt2)
{
    ll p=x/a;
    ll q=x/b;
    ll c=x/(a*b/__gcd(a,b));
    p-=c;
    q-=c;
    cnt1-=min(cnt1,q);
    cnt2-=min(cnt2,p);
    return x-c-p-q>=cnt2+cnt1;
}
int main()
{
    ll cnt1,cnt2,x,y;
    scanf("%lld%lld%lld%lld",&cnt1,&cnt2,&x,&y);
    ll l=;
    ll r=1e10,ans;
    while(l<=r)
    {
        ll mid=(l+r)>>;
        if(check(mid,x,y,cnt1,cnt2))
        {
            r=mid-;
            ans=mid;
        }
        else l=mid+;
    }
    printf("%lld\n",ans);
    return ;
}

C. Diverse Permutation

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Permutation p is an ordered set of integers p1,   p2,   ...,   pn, consisting of n distinct positive integers not larger than n. We'll denote as nthe length of permutation p1,   p2,   ...,   pn.

Your task is to find such permutation p of length n, that the group of numbers |p1 - p2|, |p2 - p3|, ..., |pn - 1 - pn| has exactly k distinct elements.

Input

The single line of the input contains two space-separated positive integers n, k (1 ≤ k < n ≤ 105).

Output

Print n integers forming the permutation. If there are multiple answers, print any of them.

Examples

input

3 2

output

1 3 2

input

3 1

output

1 2 3

input

5 2

output

1 3 2 4 5

Note

By |x| we denote the absolute value of number x.

题意：n个数1-n，随意排放，两两相差为x，使得x的不同的数目为K；

思路:构造思路题，1 n  2  n-1 构造k-1个，后面递增，递减差值都为1 即可；

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pi (4*atan(1.0))
#define eps 1e-14
#define bug(x,y) cout<<"bug"<<x<<" "<<y<<endl;
#define bug(x) cout<<"xxx "<<x<<endl;
const int N=1e5+,M=1e6+,inf=2e9+,mod=;
const ll INF=1e18+;
int main()
{
    int n,k;
    scanf("%d%d",&n,&k);
    int l=,r=n,last=;
    for(int i=;i<=k;i++)
    {
        if(i&)printf("%d ",l++),last=;
        else printf("%d ",r--),last=;
    }
    if(last)for(int i=l;i<=r;i++)printf("%d ",i);
    else for(int i=r;i>=l;i--)printf("%d ",i);
    return ;
}

D. Interesting Array

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

We'll call an array of n non-negative integers a[1], a[2], ..., a[n] interesting, if it meets m constraints. The i-th of the m constraints consists of three integers li, ri, qi (1 ≤ li ≤ ri ≤ n) meaning that value  should be equal to qi.

Your task is to find any interesting array of n elements or state that such array doesn't exist.

Expression x&y means the bitwise AND of numbers x and y. In programming languages C++, Java and Python this operation is represented as "&", in Pascal — as "and".

Input

The first line contains two integers n, m (1 ≤ n ≤ 105, 1 ≤ m ≤ 105) — the number of elements in the array and the number of limits.

Each of the next m lines contains three integers li, ri, qi (1 ≤ li ≤ ri ≤ n, 0 ≤ qi < 230) describing the i-th limit.

Output

If the interesting array exists, in the first line print "YES" (without the quotes) and in the second line print n integers a[1], a[2], ..., a[n](0 ≤ a[i] < 230) decribing the interesting array. If there are multiple answers, print any of them.

If the interesting array doesn't exist, print "NO" (without the quotes) in the single line.

Examples

input

3 1
1 3 3

output

YES
3 3 3

input

3 2
1 3 3
1 3 2

output

NO

思路：线段数区间并；

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pi (4*atan(1.0))
#define eps 1e-14
#define bug(x,y) cout<<"bug"<<x<<" "<<y<<endl;
#define bug(x) cout<<"xxx "<<x<<endl;
const int N=1e5+,M=1e6+,inf=2e9+,mod=;
const ll INF=1e18+;
struct linetree
{
    int sum[N<<],lazy[N<<];
    void pushup(int pos)
    {
        sum[pos]=sum[pos<<]&sum[pos<<|];
    }
    void pushdown(int pos)
    {
        if(lazy[pos])
        {
            sum[pos<<]|=lazy[pos];
            sum[pos<<|]|=lazy[pos];
            lazy[pos<<]|=lazy[pos];
            lazy[pos<<|]|=lazy[pos];
            lazy[pos]=;
        }
    }
    void build(int l,int r,int pos)
    {
        lazy[pos]=;
        if(l==r)
        {
            sum[pos]=;
            return;
        }
        int mid=(l+r)>>;
        build(l,mid,pos<<);
        build(mid+,r,pos<<|);
        pushup(pos);
    }
    void update(int L,int R,int c,int l,int r,int pos)
    {
        if(L<=l&&r<=R)
        {
            sum[pos]|=c;
            lazy[pos]|=c;
            return;
        }
        pushdown(pos);
        int mid=(l+r)>>;
        if(L<=mid)
            update(L,R,c,l,mid,pos<<);
        if(R>mid)
            update(L,R,c,mid+,r,pos<<|);
        pushup(pos);
    }
    int query(int L,int R,int l,int r,int pos)
    {
        if(L<=l&&r<=R)
            return sum[pos];
        pushdown(pos);
        int mid=(l+r)>>;
        int ans=((<<)-);
        if(L<=mid)
            ans&=query(L,R,l,mid,pos<<);
        if(R>mid)
            ans&=query(L,R,mid+,r,pos<<|);
        return ans;
    }
};
linetree tree;
int l[N],r[N],x[N];
int main()
{
    int n,q,ans=;
    scanf("%d%d",&n,&q);
    for(int i=;i<=q;i++)
    {
        scanf("%d%d%d",&l[i],&r[i],&x[i]);
        tree.update(l[i],r[i],x[i],,n,);
        if(tree.query(l[i],r[i],,n,)!=x[i])
                ans=;
    }
    for(int i=;i<=q;i++)
        if(tree.query(l[i],r[i],,n,)!=x[i])
        ans=;
    if(!ans)
        printf("NO\n");
    else
    {
        printf("YES\n");
        for(int i=;i<=n;i++)
        {
            int out=tree.query(i,i,,n,);
            printf("%d ",out);
        }
    }
    return ;
}

A. Counterexample

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Your friend has recently learned about coprime numbers. A pair of numbers {a, b} is called coprime if the maximum number that divides both a and b is equal to one.

Your friend often comes up with different statements. He has recently supposed that if the pair (a, b) is coprime and the pair (b, c) is coprime, then the pair (a, c) is coprime.

You want to find a counterexample for your friend's statement. Therefore, your task is to find three distinct numbers (a, b, c), for which the statement is false, and the numbers meet the condition l ≤ a < b < c ≤ r.

More specifically, you need to find three numbers (a, b, c), such that l ≤ a < b < c ≤ r, pairs (a, b) and (b, c) are coprime, and pair(a, c) is not coprime.

Input

The single line contains two positive space-separated integers l, r (1 ≤ l ≤ r ≤ 1018; r - l ≤ 50).

Output

Print three positive space-separated integers a, b, c — three distinct numbers (a, b, c) that form the counterexample. If there are several solutions, you are allowed to print any of them. The numbers must be printed in ascending order.

If the counterexample does not exist, print the single number -1.

Examples

input

2 4

output

2 3 4

input

10 11

output

-1

input

900000000000000009 900000000000000029

output

900000000000000009 900000000000000010 900000000000000021

Note

In the first sample pair (2, 4) is not coprime and pairs (2, 3) and (3, 4) are.

In the second sample you cannot form a group of three distinct integers, so the answer is -1.

In the third sample it is easy to see that numbers 900000000000000009 and 900000000000000021 are divisible by three.