maxn = 1010
stack = [0]*maxn
top = 0
data = list(map(int,input().split()))
for x in data:
    while True:
        temp = 0
        flag = False
        for i in range(top,-1,-1):
            temp+=stack[i]
            if temp == x:
                x+=temp
                top = i -1
                flag = True
                break
        if not flag:
            break
    top+=1
    stack[top]=x
while top>0:
    print(stack[top],end=' ')
    top-=1

#include <bits/stdc++.h>
using namespace std;
int main() {
    vector<int> a; // 用于存储输入的数字
    int val;
    
    // 从输入中读取数字，直到没有输入
    while (cin >> val) {
        a.push_back(val);
    }

    vector<int> stack; // 用于模拟栈操作
    for (int x : a) { // 遍历每个输入的数字
        bool ok = true; // 标志变量，用于判断条件是否满足
        
        // 当栈不为空且当前栈中元素的和大于等于 x 时，进行循环
        while (ok && accumulate(stack.begin(), stack.end(), 0) >= x) {
            int s = 0; // 用于累加栈中的元素
            int cnt = 0; // 计数器，记录参与累加的元素个数
            
            // 从栈顶向下遍历，检查当前元素和
            for (int i = stack.size() - 1; i >= 0; --i) {
                s += stack[i]; // 累加栈中元素
                cnt++; // 增加计数
                
                // 如果累加和等于 x
                if (s == x) {
                    // 删除栈顶的 cnt 个元素，并将 2 * x 入栈
                    for (int j = 0; j < cnt; ++j) {
                        x += stack.back(); // 将栈顶元素加到 x 上
                        stack.pop_back(); // 移除栈顶元素
                    }
                    break; // 结束当前循环
                } 
                // 如果累加和超过 x，则不满足条件
                else if (s > x) {
                    ok = false; // 设置标志为 false，退出循环
                    break;
                }
            }
        }
        stack.push_back(x); // 将当前元素 x 放入栈中
    }

    // 从栈顶到栈底输出结果
    for (int i = stack.size() - 1; i >= 0; --i) {
        cout << stack[i] << " "; // 输出栈中的每个元素
    }
    cout << endl; // 输出换行符

    return 0; // 程序结束
}

import java.util.*;

class Main {
    public static void main(String args[]) {
        // 创建一个 Scanner 对象用于读取输入
        Scanner s = new Scanner(System.in);
        
        // 读取一行输入，并将其拆分成字符串数组，然后转换为长整型数组
        long[] arr = Arrays.stream(s.nextLine().split(" ")).mapToLong(Long::valueOf).toArray();
        
        // 初始化一个栈，用于存储当前的积木块
        long[] stack = new long[arr.length];
        
        // 当前栈的有效元素数量
        int cur = 1;
        
        // 将第一个输入元素放入栈中
        stack[0] = arr[0];
        
        // 从第二个元素开始处理
        for (int i = 1; i < arr.length; ) {
            // 从栈顶开始向下遍历
            int j = cur - 1;
            long sum = 0; // 初始化当前和
            
            // 检查栈中元素的和是否小于等于当前元素
            while (j >= 0 && sum + stack[j] <= arr[i]) {
                sum += stack[j]; // 累加栈中的元素
                j--; // 向下移动到下一个元素
            }
            
            // 如果累加和等于当前元素
            if (sum == arr[i]) {
                // 将当前元素更新为两倍的累加和
                arr[i] = sum << 1; // 左移一位相当于乘以 2
                // cur = j + 2; // 不再使用的行
                cur = j + 1; // 更新当前有效元素的数量
            } else {
                // 如果不满足条件，则将当前元素入栈
                stack[cur++] = arr[i]; // 将当前元素放入栈中并更新 cur
                i++; // 处理下一个输入元素
            }
        }
        
        // 定义字符串数组，用于格式化输出
        String[] str = {"%d ", "%d"};
        
        // 从栈顶到栈底输出最终的结果
        for (int i = cur - 1; i >= 0; --i) {
            // 输出格式化字符串，最后一个元素输出后换行
            System.out.printf(i != 0 ? str[0] : str[1], stack[i]);
        }
    }
}

# 读取输入并将其转换为整数列表
a = list(map(int, input().split()))

# 初始化一个空列表作为栈
st = []

# 遍历输入的每个数字
for x in a:
    flg = True  # 标志变量，用于控制内部循环
    # 当栈的和大于等于当前元素 x 时，继续循环
    while flg and sum(st[:]) >= x:
        s = 0  # 初始化累加和
        cnt = 0  # 初始化计数器
        
        # 反向遍历栈中的元素
        for t in st[::-1]:
            s += t  # 累加栈中的元素
            cnt += 1  # 增加计数器
            
            # 如果累加和等于当前元素 x
            if s == x:
                # 从栈中弹出 cnt 个元素并将其累加到 x 上
                for i in range(cnt):
                    x += st.pop()
                break  # 退出当前循环
            # 如果累加和超过了当前元素 x
            elif s > x:
                flg = False  # 设置标志为 False，退出循环
                break 
    
    # 将当前元素 x 添加到栈中
    st.append(x)

# 输出结果，从栈顶到栈底
print(*st[::-1])