1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
def solve_pirate_division(n, m, greed):
    result = [-1] * n
    active_pirates = list(range(n))
    remaining_coins = m

    while active_pirates:
        proposer_idx = active_pirates[0]
        num_pirates = len(active_pirates)
        votes_needed = (num_pirates + 1) // 2
        
        if num_pirates == 1:
            result[proposer_idx] = remaining_coins
            break
        
        # Co się stanie w przypadku odrzucenia
        next_division = [-1] * n
        if num_pirates > 1:
            sub_result = solve_subproblem(active_pirates[1:], remaining_coins, greed)
            for i, val in enumerate(sub_result):
                next_division[active_pirates[1 + i]] = val
        
        # Minimalne wymagania
        min_coins_needed = []
        for i in active_pirates:
            di = next_division[i] if next_division[i] != -1 else 0
            ai = greed[i]
            min_coins_needed.append(di + ai)
        
        # Czy możliwe jest zdobycie głosów?
        possible_votes = sum(1 for x in min_coins_needed if x <= remaining_coins)
        if possible_votes < votes_needed:
            active_pirates.pop(0)
            continue
        
        # Proponuj podział
        division = [0] * num_pirates
        remaining = remaining_coins
        
        # Sortuj piratów: preferuj wyższe numery, minimalizuj przydziały
        sorted_indices = list(range(num_pirates))
        sorted_indices.sort(key=lambda x: (-min_coins_needed[x], -x))
        
        votes = 1
        for idx in sorted_indices[1:]:  # Pomijamy proponującego (idx 0)
            if votes >= votes_needed:
                break
            coins = min_coins_needed[idx]
            if remaining >= coins:
                division[idx] = coins
                remaining -= coins
                votes += 1
        
        # Proponujący bierze resztę
        division[0] = remaining
        
        # Jeśli podział zaakceptowany
        if votes >= votes_needed:
            for i, coins in enumerate(division):
                result[active_pirates[i]] = coins
            break
        else:
            active_pirates.pop(0)

    # Postprocessing: -1 na 0 dla niewyrzuconych
    final_pirates = set(active_pirates)
    for i in range(n):
        if result[i] == -1 and i in final_pirates:
            result[i] = 0

    return result

def solve_subproblem(pirates, coins, greed):
    n = len(pirates)
    result = [-1] * n
    
    if n == 0:
        return result
    if n == 1:
        result[0] = coins
        return result
    
    proposer_idx = pirates[0]
    votes_needed = (n + 1) // 2
    
    next_division = [-1] * len(greed)
    sub_sub_result = solve_subproblem(pirates[1:], coins, greed)
    for i, val in enumerate(sub_sub_result):
        next_division[pirates[1 + i]] = val
    
    min_coins_needed = []
    for i in pirates:
        di = next_division[i] if next_division[i] != -1 else 0
        ai = greed[i]
        min_coins_needed.append(di + ai)
    
    possible_votes = sum(1 for x in min_coins_needed if x <= coins)
    if possible_votes < votes_needed:
        return result
    
    division = [0] * n
    remaining = coins
    
    sorted_indices = list(range(n))
    sorted_indices.sort(key=lambda x: (-min_coins_needed[x], -x))
    
    votes = 1
    for idx in sorted_indices[1:]:
        if votes >= votes_needed:
            break
        need = min_coins_needed[idx]
        if remaining >= need:
            division[idx] = need
            remaining -= need
            votes += 1
    
    division[0] = remaining
    
    if votes >= votes_needed:
        return division
    return result

# Odczyt wejścia
n, m = map(int, input().split())
greed = list(map(int, input().split()))

# Rozwiązanie i wypisanie wyniku
result = solve_pirate_division(n, m, greed)
print(" ".join(map(str, result)))