public static int equalStacks(List<Integer> h1, List<Integer> h2, List<Integer> h3) {
    // Write your code here
        // there are 3 stacks involved
        List<Integer> cumulHeights = new ArrayList<>();
        Integer cumul = 0;
        for (int i = h1.size() - 1; i>=0; i--) {
            cumul += h1.get(i);
            cumulHeights.add(cumul);
        }
        cumul = 0;
        for (int i = h2.size() - 1; i>=0; i--) {
            cumul += h2.get(i);
            cumulHeights.add(cumul);
        }
        cumul = 0;
        for (int i = h3.size() - 1; i>=0; i--) {
            cumul += h3.get(i);
            cumulHeights.add(cumul);
        }
        Optional<Map.Entry<Integer, Long>> mm = cumulHeights.stream().collect(Collectors.groupingBy(s -> s, Collectors.counting())).entrySet()
                .stream().filter((s) -> s.getValue() == 3).max(Comparator.comparingInt(s -> s.getKey()));
        if (mm.isPresent()) {
            return mm.get().getKey();
        }
        return 0;
    }

int equalStacks(std::vector<int> h1, std::vector<int> h2, std::vector<int> h3) {
    std::multimap<int, std::vector<int>> stacks {  };
    stacks.insert({ std::accumulate(h1.begin(), h1.end(), 0), h1 });
    stacks.insert({ std::accumulate(h2.begin(), h2.end(), 0), h2 });
    stacks.insert({ std::accumulate(h3.begin(), h3.end(), 0), h3 });
    
    while (stacks.count(stacks.begin()->first) != stacks.size()) {
        auto max_sum { stacks.rbegin()->first };
        auto max_stacks { stacks.equal_range(max_sum) };
        auto max_stacks_copy { std::vector<decltype(stacks)::iterator>() };
        
        for (auto it = max_stacks.first; it != max_stacks.second; ++it) {
            max_stacks_copy.push_back(it);
        }
        
        for (auto it : max_stacks_copy) {    
            auto node { stacks.extract(it->first) };            
            node.key() -= *node.mapped().begin();
            node.mapped().erase(node.mapped().begin());
            
            stacks.insert(std::move(node));
        }
    }
    
    return stacks.begin()->first;
}

int getSum(vector<int> h);

int equalStacks(vector<int> h1, vector<int> h2, vector<int> h3) {      
    int h1sum = getSum(h1);
    int h2sum = getSum(h2);
    int h3sum = getSum(h3);
    
    while (h1.size() && h2.size() && h3.size() && !(h1sum == h2sum && h1sum == h3sum)) {
        auto maxVal = max({ h1sum, h2sum, h3sum });
        if (maxVal == h1sum) {
            h1sum -= h1.at(0);
            h1.erase(h1.begin());
        }
        else if (maxVal == h2sum) {
            h2sum -= h2.at(0);
            h2.erase(h2.begin());
        }
        else {
            h3sum -= h3.at(0);
            h3.erase(h3.begin());
        }
    }

    if (h1.size() && h2.size() && h3.size()) {
        return h1sum;
    }
    else {
        return 0;
    }
}

int getSum(vector<int> h){
   return accumulate(h.begin(), h.end(), 0); 
}

public static int equalStacks(List<Integer> h1, List<Integer> h2, List<Integer> h3) {
        int s1 = h1.stream().mapToInt(x -> x.intValue()).sum();
        int s2 = h2.stream().mapToInt(x -> x.intValue()).sum();
        int s3 = h3.stream().mapToInt(x -> x.intValue()).sum();
        Collections.reverse(h1);
        Collections.reverse(h2);
        Collections.reverse(h3);
        while(s1 != s2 || s2 != s3){
            if(s1 > s2 || s1 > s3){
                s1 -= h1.remove(h1.size() - 1);
            }
            
            if(s2 > s1 || s2 > s3){
                s2 -= h2.remove(h2.size() - 1);
            }
            
            if(s3 > s2 || s3 > s1){
                s3 -= h3.remove(h3.size() - 1);
            }
            
        }
        return s1;
    }