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

A. Exam

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

An exam for n students will take place in a long and narrow room, so the students will sit in a line in some order. The teacher suspects that students with adjacent numbers (i and i + 1) always studied side by side and became friends and if they take an exam sitting next to each other, they will help each other for sure.

Your task is to choose the maximum number of students and make such an arrangement of students in the room that no two students with adjacent numbers sit side by side.

Input

A single line contains integer n (1 ≤ n ≤ 5000) — the number of students at an exam.

Output

In the first line print integer k — the maximum number of students who can be seated so that no two students with adjacent numbers sit next to each other.

In the second line print k distinct integers a₁, a₂, ..., a_k (1 ≤ a_i ≤ n), where a_i is the number of the student on the i-th position. The students on adjacent positions mustn't have adjacent numbers. Formally, the following should be true: |a_i - a_i + 1| ≠ 1 for all i from 1 to k - 1.

If there are several possible answers, output any of them.

Examples

Input

6

Output

6
1 5 3 6 2 4

Input

3

Output

2
1 3

题意：给你n个数 1~n 问你最多选择多少个数 排列起来 使得相邻的两个数字是不连续的
题解：特判1~4 其余的插空排列

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #include<map>
 #include<queue>
 #include<stack>
 #include<vector>
 #include<set>
 #define ll __int64
 using namespace std;
 int n;
 int a[];
 int main()
 {
     scanf("%d",&n);
     if(n==||n==){
         printf("1\n1\n");
         return ;
         }
     if(n==){
         printf("2\n1 3\n");
         return ;
     }
     if(n==){
         printf("4\n3 1 4 2\n");
         return ;
     }
     int jishu=;
     if(n%==)
         jishu=n/+;
     else
         jishu=n/;
     int chu=;
     for(int i=;i<=jishu;i++){
          a[*i-]=chu;
          chu++;
     }
     for(int i=;i<=(n-jishu);i++){
          a[*i]=chu;
          chu++;
     }
     printf("%d\n",n);
     for(int i=;i<=n ;i++)
         printf("%d ",a[i]);
     return  ;
 }

B. Covered Path

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

The on-board computer on Polycarp's car measured that the car speed at the beginning of some section of the path equals v₁ meters per second, and in the end it is v₂ meters per second. We know that this section of the route took exactly t seconds to pass.

Assuming that at each of the seconds the speed is constant, and between seconds the speed can change at most by d meters per second in absolute value (i.e., the difference in the speed of any two adjacent seconds does not exceed d in absolute value), find the maximum possible length of the path section in meters.

Input

The first line contains two integers v₁ and v₂ (1 ≤ v₁, v₂ ≤ 100) — the speeds in meters per second at the beginning of the segment and at the end of the segment, respectively.

The second line contains two integers t (2 ≤ t ≤ 100) — the time when the car moves along the segment in seconds, d (0 ≤ d ≤ 10) — the maximum value of the speed change between adjacent seconds.

It is guaranteed that there is a way to complete the segment so that:

• the speed in the first second equals v₁,
• the speed in the last second equals v₂,
• the absolute value of difference of speeds between any two adjacent seconds doesn't exceed d.

Output

Print the maximum possible length of the path segment in meters.

Examples

Input

5 6
4 2

Output

26

Input

10 10
10 0

Output

100

Note

In the first sample the sequence of speeds of Polycarpus' car can look as follows: 5, 7, 8, 6. Thus, the total path is 5 + 7 + 8 + 6 = 26 meters.

In the second sample, as d = 0, the car covers the whole segment at constant speed v = 10. In t = 10 seconds it covers the distance of 100 meters.

 #include<bits/stdc++.h>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<queue>
 #include<stack>
 #include<vector>
 #include<map>
 #include<algorithm>
 #define ll __int64
 #define mod 1e9+7
 #define PI acos(-1.0)
 using namespace std;
 int v1,v2;
 int t,d;
 int ans=;
 int minx;
 int main()
 {
     scanf("%d %d",&v1,&v2);
     scanf("%d %d",&t,&d);
     int a=v1;
     //ans=0;
     int b=v2+d*(t-);
     for(int i=;i<=t;i++)
     {
         ans=ans+min(a,b);
         a+=d;
         b-=d;
     }
     cout<<ans<<endl;
     return ;
 }

C. Polycarpus' Dice

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Polycarp has n dice d₁, d₂, ..., d_n. The i-th dice shows numbers from 1 to d_i. Polycarp rolled all the dice and the sum of numbers they showed is A. Agrippina didn't see which dice showed what number, she knows only the sum A and the values d₁, d₂, ..., d_n. However, she finds it enough to make a series of statements of the following type: dice i couldn't show number r. For example, if Polycarp had two six-faced dice and the total sum is A = 11, then Agrippina can state that each of the two dice couldn't show a value less than five (otherwise, the remaining dice must have a value of at least seven, which is impossible).

For each dice find the number of values for which it can be guaranteed that the dice couldn't show these values if the sum of the shown values is A.

Input

The first line contains two integers n, A (1 ≤ n ≤ 2·10⁵, n ≤ A ≤ s) — the number of dice and the sum of shown values where s = d₁ + d₂ + ... + d_n.

The second line contains n integers d₁, d₂, ..., d_n (1 ≤ d_i ≤ 10⁶), where d_i is the maximum value that the i-th dice can show.

Output

Print n integers b₁, b₂, ..., b_n, where b_i is the number of values for which it is guaranteed that the i-th dice couldn't show them.

Examples

Input

2 8
4 4

Output

3 3 

Input

1 3
5

Output

4 

Input

2 3
2 3

Output

0 1 

Note

In the first sample from the statement A equal to 8 could be obtained in the only case when both the first and the second dice show 4. Correspondingly, both dice couldn't show values 1, 2 or 3.

In the second sample from the statement A equal to 3 could be obtained when the single dice shows 3. Correspondingly, it couldn't show 1, 2, 4 or 5.

In the third sample from the statement A equal to 3 could be obtained when one dice shows 1 and the other dice shows 2. That's why the first dice doesn't have any values it couldn't show and the second dice couldn't show 3.

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #include<map>
 #include<queue>
 #include<stack>
 #include<vector>
 #include<set>
 #define ll __int64
 using namespace std;
 ll A;
 int n;
 ll a[];
 ll l[];
 ll r[];
 ll ans[];
 int main()
 {
     scanf("%d %I64d",&n,&A);
     for(int i=;i<=n;i++)
         scanf("%I64d",&a[i]);
     l[]=;
     l[n+]=;
     for(int i=;i<=n;i++)
         l[i]=l[i-]+a[i];
     for(int i=n;i>=;i--)
         r[i]=r[i+]+a[i];
     ll low,high;
     for(int i=;i<=n;i++)
     {
         low=a[i];
         high=;
         low=min(low,min(a[i],A-(min(A-,l[i-]+r[i+]))));
         high=max(high,min(a[i],A-(n-)));
         ans[i]=a[i]-(high-low+);
     }
     for(int i=;i<=n;i++)
         printf("%I64d ",ans[i]);

     return ;
 }

D. Handshakes

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

On February, 30th n students came in the Center for Training Olympiad Programmers (CTOP) of the Berland State University. They came one by one, one after another. Each of them went in, and before sitting down at his desk, greeted with those who were present in the room by shaking hands. Each of the students who came in stayed in CTOP until the end of the day and never left.

At any time any three students could join together and start participating in a team contest, which lasted until the end of the day. The team did not distract from the contest for a minute, so when another student came in and greeted those who were present, he did not shake hands with the members of the contest writing team. Each team consisted of exactly three students, and each student could not become a member of more than one team. Different teams could start writing contest at different times.

Given how many present people shook the hands of each student, get a possible order in which the students could have come to CTOP. If such an order does not exist, then print that this is impossible.

Please note that some students could work independently until the end of the day, without participating in a team contest.

Input

The first line contains integer n (1 ≤ n ≤ 2·10⁵) — the number of students who came to CTOP. The next line contains n integers a₁, a₂, ..., a_n (0 ≤ a_i < n), where a_i is the number of students with who the i-th student shook hands.

Output

If the sought order of students exists, print in the first line "Possible" and in the second line print the permutation of the students' numbers defining the order in which the students entered the center. Number i that stands to the left of number j in this permutation means that the i-th student came earlier than the j-th student. If there are multiple answers, print any of them.

If the sought order of students doesn't exist, in a single line print "Impossible".

Examples

Input

5
2 1 3 0 1

Output

Possible
4 5 1 3 2 

Input

9
0 2 3 4 1 1 0 2 2

Output

Possible
7 5 2 1 6 8 3 4 9

Input

4
0 2 1 1

Output

Impossible

Note

In the first sample from the statement the order of events could be as follows:

• student 4 comes in (a₄ = 0), he has no one to greet;
• student 5 comes in (a₅ = 1), he shakes hands with student 4;
• student 1 comes in (a₁ = 2), he shakes hands with two students (students 4, 5);
• student 3 comes in (a₃ = 3), he shakes hands with three students (students 4, 5, 1);
• students 4, 5, 3 form a team and start writing a contest;
• student 2 comes in (a₂ = 1), he shakes hands with one student (number 1).

In the second sample from the statement the order of events could be as follows:

• student 7 comes in (a₇ = 0), he has nobody to greet;
• student 5 comes in (a₅ = 1), he shakes hands with student 7;
• student 2 comes in (a₂ = 2), he shakes hands with two students (students 7, 5);
• students 7, 5, 2 form a team and start writing a contest;
• student 1 comes in(a₁ = 0), he has no one to greet (everyone is busy with the contest);
• student 6 comes in (a₆ = 1), he shakes hands with student 1;
• student 8 comes in (a₈ = 2), he shakes hands with two students (students 1, 6);
• student 3 comes in (a₃ = 3), he shakes hands with three students (students 1, 6, 8);
• student 4 comes in (a₄ = 4), he shakes hands with four students (students 1, 6, 8, 3);
• students 8, 3, 4 form a team and start writing a contest;
• student 9 comes in (a₉ = 2), he shakes hands with two students (students 1, 6).

In the third sample from the statement the order of events is restored unambiguously:

• student 1 comes in (a₁ = 0), he has no one to greet;
• student 3 comes in (or student 4) (a₃ = a₄ = 1), he shakes hands with student 1;
• student 2 comes in (a₂ = 2), he shakes hands with two students (students 1, 3 (or 4));
• the remaining student 4 (or student 3), must shake one student's hand (a₃ = a₄ = 1) but it is impossible as there are only two scenarios: either a team formed and he doesn't greet anyone, or he greets all the three present people who work individually.

 #include<iostream>
 #include<cstdio>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 #include<map>
 #include<queue>
 #include<stack>
 #include<vector>
 #include<set>
 #define ll __int64
 using namespace std;
 int n;
 vector<int> ve[];
 int ans[];
 int main()
 {
     scanf("%d",&n);
     int exm;
     for(int i=;i<=n;i++){
      scanf("%d",&exm);
      ve[exm].push_back(i);
     }
     int top=;
     int now=;
     while(top<n)
     {
         while(ve[now].size()==)
         {
             now-=;
             if(now<){
                 printf("Impossible\n");
                 return ;
             }
         }
         ans[++top]=ve[now].back();
         ve[now].pop_back();
         now++;
     }
     printf("Possible\n");
     for(int i=;i<=n;i++){
         printf("%d ",ans[i]);
     }
     return ;
 }