Lesha plays the recently published new version of the legendary game hacknet. In this version character skill mechanism was introduced. Now, each player character has exactly *n* skills. Each skill is represented by a non-negative integer *a*<sub class="lower-index">*i*</sub> — the current skill level. All skills have the same maximum level *A*.

Along with the skills, global ranking of all players was added. Players are ranked according to the so-called Force. The Force of a player is the sum of the following values:
 -  The number of skills that a character has perfected (i.e., such that *a*<sub class="lower-index">*i*</sub> = *A*), multiplied by coefficient *c*<sub class="lower-index">*f*</sub>.-  The minimum skill level among all skills (*min* *a*<sub class="lower-index">*i*</sub>), multiplied by coefficient *c*<sub class="lower-index">*m*</sub>. 
Now Lesha has *m* hacknetian currency units, which he is willing to spend. Each currency unit can increase the current level of any skill by 1 (if it's not equal to *A* yet). Help him spend his money in order to achieve the maximum possible value of the Force.
The first line of the input contains five space-separated integers *n*, *A*, *c*<sub class="lower-index">*f*</sub>, *c*<sub class="lower-index">*m*</sub> and *m* (1 ≤ *n* ≤ 100 000, 1 ≤ *A* ≤ 10<sup class="upper-index">9</sup>, 0 ≤ *c*<sub class="lower-index">*f*</sub>, *c*<sub class="lower-index">*m*</sub> ≤ 1000, 0 ≤ *m* ≤ 10<sup class="upper-index">15</sup>).

The second line contains exactly *n* integers *a*<sub class="lower-index">*i*</sub> (0 ≤ *a*<sub class="lower-index">*i*</sub> ≤ *A*), separated by spaces, — the current levels of skills.
In the first test the optimal strategy is to increase the second skill to its maximum, and increase the two others by 1.

In the second test one should increase all skills to maximum.
3 5 10 1 5
1 3 1
12
2 5 2 
3 5 10 1 339
1 3 1
35
5 5 5 
2 6 0 1 4
5 1
5
5 5 
1 1000000000 1000 1000 1000000000000000
0
1000000001000
1000000000 
1 100 1 2 30
1
62
31 
1 100 1 2 30
71
201
100 
1 1000000000 1000 1000 1000000000000000
1000000000
1000000001000
1000000000 
5 5 10 20 50
0 0 0 0 0
150
5 5 5 5 5 
5 5 10 20 50
3 3 3 3 3
150
5 5 5 5 5 
4 5 3 7 15
4 3 3 1
47
5 5 5 5 
3 6 4 6 8
6 4 5
48
6 6 6 
def main():
    from bisect import bisect
    n, A, cf, cm, m = map(int, input().split())
    skills = list(map(int, input().split()))
    idxes = sorted(range(n), key=skills.__getitem__)
    sorted_skills = [skills[_] for _ in idxes]
    bottom_lift, a = [0] * n, 0
    for i, b in enumerate(sorted_skills):
        bottom_lift[i], a = (i * (b - a)), b
    root_lift, a = [0], 0
    for b in reversed(sorted_skills):
        a += A - b
        root_lift.append(a)
    max_level = -1
    for i, a in enumerate(root_lift):
        if m < a:
            break
        money_left = m - a
        k = min(bisect(bottom_lift, money_left), n - i)
        money_left -= bottom_lift[k - 1]
        min_level = sorted_skills[k - 1] + money_left // k if k > 0 else A
        if min_level > A:
            min_level = A
        level = cf * i + cm * min_level
        if max_level < level:
            max_level, sav = level, (i, min_level, k)
    i, min_level, k = sav
    for a, b in enumerate(idxes):
        if a < k:
            skills[b] = min_level
        elif a >= n - i:
            skills[b] = A
    print(max_level)
    print(' '.join(map(str, skills)))


if __name__ == '__main__':
    main()
