#include <algorithm>
#include <fstream>
#include <iostream>
#include <iterator>
#include <utility>
#include <vector>
#include <numeric>

using Task = std::pair<int, int>;

bool overlap(Task const& a, Task const& b)
{
    return !(a.second < b.first || a.first > b.second);
}

Task merge_or_split(Task const& burst, Task const& next)
{
    if (overlap(burst, next))
    {
	// merge the next task into the burst
        Task result { std::min(burst.first, next.first),
		      std::max(burst.second, next.second) };
	return result;
    }
    // split the timeline so that 'next' is the start of the next
    // burst.
    return next;
}

void read(std::istream& is, Task& task)
{
    is >> task.first >> task.second;
}

void write(std::ostream& os, Task const& task)
{
    os << task.first << " " << task.second;
}

namespace std
{
    std::istream& operator>>(std::istream& is, Task& task)
    {
	read(is, task);
	return is;
    }

    std::ostream& operator<<(std::ostream& os, Task const& task)
    {
	write(os, task);
	return os;
    }

}

int main()
{
    std::ifstream ifs { "tasks.txt" };
    std::vector<Task> tasks { std::istream_iterator<Task>{ifs},
			      std::istream_iterator<Task>{} };

    std::sort(std::begin(tasks), std::end(tasks));

    std::partial_sum(std::begin(tasks), std::end(tasks), std::begin(tasks),
		     merge_or_split);

    std::sort(std::begin(tasks), std::end(tasks),
	      [](Task const& a, Task const& b)
	      { return std::tie(a.first, b.second) < std::tie(b.first, a.second); });

    tasks.erase(std::unique(std::begin(tasks), std::end(tasks),
			    [](Task const& a, Task const& b)
			    { return a.first == b.first; }),
		std::end(tasks));

    std::copy(std::begin(tasks), std::end(tasks),
    	      std::ostream_iterator<Task>{ std::cout, "\n" });

}