# the needed volume is already in the new combination
if t in detect_comb:
  ans = Combination(father_ind, needed_step, new_comb)
  return True

# the combination is already in the data
if detect_comb in [cups_data.cups_volume for cups_data in data]:
  return False

# if two former test failed, that means this is a new combination
data.append(Combination(father_ind, needed_step, new_comb))
return False

while cur_p < len(data):

print('--> Programed and run by phantom0174 <--')

# cup count
n = int(input('請輸入杯子的個數><\n'))

# needed volume
t = int(input('請輸入你想要的水量><\n'))

# cup max volume
cup_max = list(input('請輸入各杯子的最大容量>< (要以空格隔開)\n').split(' '))
cup_max = list(map(int, cup_max))

# current pop index
cur_p = int(0)


# the data of a combination
class Combination:
    def __init__(self, init_father_index: int, init_step: int, init_list: list):
        self.father_index = init_father_index
        self.step = init_step
        self.cups_volume = init_list


# answer object
ans = Combination(0, 0, list())


# iterate data
data = list()

# initialize first combination
data.append(Combination(0, 0, [0] * n))


# the function for status checking
# if we find the answer, return True; otherwise, return False
def check_and_manipulate(father_ind, needed_step, detect_comb: list) -> bool:
    global data, ans

    # the needed volume is already in the new combination
    if t in detect_comb:
        ans = Combination(father_ind, needed_step, new_comb)
        return True

    # the combination is already in the data
    if detect_comb in [cups_data.cups_volume for cups_data in data]:
        return False

    # if two former test failed, that means this is a new combination
    data.append(Combination(father_ind, needed_step, new_comb))
    return False


# main program


# initialize find status, which is equivalent to 'flag'
find = bool(False)
while cur_p < len(data):
    print(f'Searching... ({cur_p}/{len(data) - 1})')

    # try 1: fill cup to maximum volume
    for cup_index in range(n):
        # if the cup is already full, then skip this step
        if data[cur_p].cups_volume[cup_index] == cup_max[cup_index]:
            continue

        new_comb = data[cur_p].cups_volume.copy()

        # fill the cup of index 'cup_index' to its maximum volume
        new_comb[cup_index] = cup_max[cup_index]

        find = check_and_manipulate(cur_p, data[cur_p].step + 1, new_comb)
        if find:
            break
    if find:
        break

    # try 2: pour water from cup a to b
    for a_index in range(n):
        for b_index in range(n):
            # situation 1: if a-cup is b-cup, then skip this step
            # situation 2: if a-cup is empty, then skip this step
            # situation 3: if b-cup is full, then skip this step
            if a_index == b_index \
                    or data[cur_p].cups_volume[a_index] == 0 \
                    or data[cur_p].cups_volume[b_index] == cup_max[b_index]:
                continue

            new_comb = data[cur_p].cups_volume.copy()

            # criterion: delta value <= a-cup
            # situation 1: if a-cup currently has more water than b_max - b-cup,
            # then the delta value is b_max - b-cup
            # situation 2: if a-cup currently has less water than b_max - b-cup,
            # then the delta value is just a-cup itself
            delta_volume = min(cup_max[b_index] - new_comb[b_index], new_comb[a_index])
            new_comb[a_index] -= delta_volume
            new_comb[b_index] += delta_volume

            find = check_and_manipulate(cur_p, data[cur_p].step + 1, new_comb)
            if find:
                break
        if find:
            break
    if find:
        break

    # try 3: pour the water out of the cup
    for cup_index in range(n):
        # if the cup is empty, then skip this step
        if data[cur_p].cups_volume[cup_index] == 0:
            continue

        new_comb = data[cur_p].cups_volume.copy()

        # pour the water out of the cup of index 'cup_index'
        new_comb[cup_index] = 0

        find = check_and_manipulate(cur_p, data[cur_p].step + 1, new_comb)
        if find:
            break
    if find:
        break

    cur_p += 1

if not find:
    print('不要為難我了qwq, 這是不可能的任務')
else:
    print(f'恭喜！\\^~^ 你只要 {ans.step} 步就可以得到 {t} 的水量！')
    step_list = list()
    step_list.append(ans.cups_volume)

    # initialize current father_index to search
    father_index = ans.father_index

    # get the cups_volume data from father_index, and update the next father_index
    while father_index != 0:
        step_list.append(data[father_index].cups_volume)
        father_index = data[father_index].father_index

    # because we're searching from back, we'll need to reverse the step logs
    step_list.reverse()
    print('以下是步驟！')
    for step in step_list:
        print(step)