#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

class BigNumber {
    std::string value;

public:
    BigNumber(const std::string& s = "0") : value(s) {
        // Remove leading zeros
        size_t firstNonZero = value.find_first_not_of('0');
        if (firstNonZero != std::string::npos)
            value = value.substr(firstNonZero);
        else
            value = "0";
    }

    bool operator==(const BigNumber& other) const {
        return value == other.value;
    }

    // Fixed multiplication by 2 specifically for this problem
    BigNumber multiplyBy2() const {
        if (value == "0") return BigNumber("0");

        std::vector<int> result(value.length() + 1, 0);
        int carry = 0;

        // Multiply each digit by 2
        for (int i = value.length() - 1; i >= 0; i--) {
            int digit = (value[i] - '0') * 2 + carry;
            result[i + 1] = digit % 10;
            carry = digit / 10;
        }
        result[0] = carry;

        // Convert back to string
        std::string resultStr;
        bool started = false;
        for (int digit : result) {
            if (digit != 0 || started) {
                resultStr += std::to_string(digit);
                started = true;
            }
        }
        if (resultStr.empty()) resultStr = "0";
        return BigNumber(resultStr);
    }

    bool operator<(const BigNumber& other) const {
        if (value.length() != other.value.length())
            return value.length() < other.value.length();
        return value < other.value;
    }

    friend std::ostream& operator<<(std::ostream& os, const BigNumber& num) {
        os << (num.value.empty() ? "0" : num.value);
        return os;
    }
};

BigNumber solve(std::vector<BigNumber>& nums) {
    bool changed = true;
    while (changed && nums.size() > 1) {
        changed = false;
        // Try merging first
        for (int i = 0; i < nums.size() - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                nums[i] = nums[i].multiplyBy2();
                nums.erase(nums.begin() + i + 1);
                changed = true;
                break;
            }
        }

        // If no merging is possible, remove the smallest number
        if (!changed && nums.size() > 1) {
            int minIdx = 0;
            for (int i = 1; i < nums.size(); i++) {
                if (nums[i] < nums[minIdx]) {
                    minIdx = i;
                }
            }
            nums.erase(nums.begin() + minIdx);
            changed = true;
        }
    }

    return nums[0];
}

int main() {
    int n;
    std::cin >> n;

    std::vector<BigNumber> nums;
    for (int i = 0; i < n; i++) {
        std::string num;
        std::cin >> num;
        nums.push_back(BigNumber(num));
    }

    BigNumber result = solve(nums);
    std::cout << result << "\n";

    return 0;
}