std::list<Build::ptr> newBuilds; // FIXME: use queue

    std::multimap<Path, Build::ptr> newBuilds;

            std::cerr << build->id << " " << build->buildTimeout  << std::endl;

            newBuilds.push_back(build);

            newBuilds.emplace(std::make_pair(build->drvPath, build));

    /* Now instantiate build steps for each new build. The builder
       threads can start building the runnable build steps right away,
       even while we're still processing other new builds. */
    for (auto & build : newBuilds) {
        // FIXME: remove build from newBuilds to ensure quick destruction
        // FIXME: exception handling

    std::set<Step::ptr> newRunnable;
    unsigned int nrAdded;
    std::function<void(Build::ptr)> createBuild;

    createBuild = [&](Build::ptr build) {

        nrAdded++;

            continue;

            return;

        std::set<Step::ptr> newSteps, newRunnable;

        std::set<Step::ptr> newSteps;

        /* Some of the new steps may be the top level of builds that
           we haven't processed yet. So do them now. This ensures that
           if build A depends on build B with top-level step X, then X
           will be "accounted" to B in doBuildStep(). */
        for (auto & r : newSteps) {
            while (true) {
                auto i = newBuilds.find(r->drvPath);
                if (i == newBuilds.end()) break;
                Build::ptr b = i->second;
                newBuilds.erase(i);
                createBuild(b);
            }
        }

            continue;

            return;

        if (badStep) continue;

        if (badStep) return;

        printMsg(lvlChatty, format("added build %1% (top-level step %2%, %3% new steps, %4% new runnable steps)")
            % build->id % step->drvPath % newSteps.size() % newRunnable.size());

        printMsg(lvlChatty, format("added build %1% (top-level step %2%, %3% new steps)")
            % build->id % step->drvPath % newSteps.size());

    };
    /* Now instantiate build steps for each new build. The builder
       threads can start building the runnable build steps right away,
       even while we're still processing other new builds. */
    while (!newBuilds.empty()) {
        auto build = newBuilds.begin()->second;
        newBuilds.erase(newBuilds.begin());
        newRunnable.clear();
        nrAdded = 0;
        createBuild(build);

        printMsg(lvlChatty, format("got %1% new runnable steps from %2% new builds") % newRunnable.size() % nrAdded);

    sleep(5);