sudo apt-get install wine

sudo apt-get install geany

#include <argp.h>
#include <cassert>
#include <cstdio>
#include <ext/hash_map>
#include <fstream>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
#include "CompactReport.h"
#include "NumRuns.h"
#include "PredStats.h"
#include "Progress/Bounded.h"
#include "ReportReader.h"
#include "RunsDirectory.h"
#include "RunSet.h"
#include "OutcomeRunSets.h"
#include "SiteCoords.h"
#include "classify_runs.h"
#include "fopen.h"
#include "termination.h"
#include "utils.h"
 
using namespace std;
using __gnu_cxx::hash_map;
 
////////////////////////////////////////////////////////////////////////
//
//  information about one interesting predicate
//
 
 
struct PredInfo
{
    OutcomeRunSets tek;
    OutcomeRunSets lek;
};
 
class PredInfos : public hash_map<PredCoords, PredInfo>
{
};
 
static PredInfos predInfos;
 
class Reader : public ReportReader
{
public:
    Reader(Outcome, unsigned);
 
protected:
    void handleSite(const SiteCoords &, vector<count_tp> &);
 
private:
    void notice(const SiteCoords &coords, unsigned, bool) const;
 
    const Outcome outcome;
    const unsigned runId;
};
 
 
inline
Reader::Reader(Outcome outcome, unsigned runId)
    : outcome(outcome),
      runId(runId)
{
}
 
 
static void process_cmdline(int argc, char **argv)
{
    static const argp_child children[] = {
	{ &CompactReport::argp, 0, 0, 0 },
	{ &NumRuns::argp, 0, 0, 0 },
	{ &ReportReader::argp, 0, 0, 0 },
	{ &RunsDirectory::argp, 0, 0, 0 },
	{ 0, 0, 0, 0 }
    };
 
    static const argp argp = {
	0, 0, 0, 0, children, 0, 0
    };
 
    argp_parse(&argp, argc, argv, 0, 0, 0);
};
 
int main(int argc, char** argv)
{
    set_terminate_verbose();
    process_cmdline(argc, argv);
 
    classify_runs();
 
    ofstream ofp("tek.txt");
    ofstream tfp("lek.txt");
 
    // interesting predicates in "preds.txt" order
    typedef queue<const PredInfo *> InterestingPreds;
    InterestingPreds interesting;
 
    {
	const unsigned numPreds = PredStats::count();
	Progress::Bounded progress("reading interesting predicate list", numPreds);
	FILE * const pfp = fopenRead(PredStats::filename);
	pred_info pi;
	while (read_pred_full(pfp, pi)) {
	    progress.step();
	    const PredInfo &info = predInfos[pi];
	    interesting.push(&info);
	}
	fclose(pfp);
    }
 
[B]    {
	Progress::Bounded progress("computing tek lek", NumRuns::count());
	for (unsigned runId = NumRuns::begin; runId < NumRuns::end; ++runId) {
	    progress.step();
 
	    Outcome outcome = 0;
	    if (is_srun[runId])
		outcome = &OutcomeRunSets::success;
	    else if (is_frun[runId])
		outcome = &OutcomeRunSets::failure;
	    else
		continue;
 
	    Reader(outcome, runId).read(runId);
	}
    }
 
[/B]    {
	Progress::Bounded progress("printing tek and lek", predInfos.size());
	while (!interesting.empty()) {
	    progress.step();
	    const PredInfo * const info = interesting.front();
	    ofp << info->tek ;
	    tfp << info->lek;
	    interesting.pop();
	}
    }
 
    return 0;
}

    while (file >> runId && runId < numRuns) {
    progress.stepTo(runId);
    if (runId >= NumRuns::begin) {
        bits[runId] = 1;
        ++count;
    }
    }