// Remove the dispatch to certain entrypoints
public static void RemoveEntryPoints(Program program, HashSet <string> procs)
{
var mainImpl = BoogieUtil.findProcedureImpl(program.TopLevelDeclarations, AvnAnnotations.CORRAL_MAIN_PROC);
foreach (var block in mainImpl.Blocks)
{
if (block.Cmds.OfType <CallCmd>().Any(cc => procs.Contains(cc.callee)))
{
block.Cmds.Clear();
}
}
BoogieUtil.pruneProcs(program, mainImpl.Name);
}
static Program GetProgram(string filename)
{
var init = GetInputProgram(filename);
if (Options.addInitialization)
{
ComputeandInitializeUninitializedLocals(init);
}
// Do some instrumentation for the input program
if (Options.markAssumesAsSlic)
{
// Mark all assumes as "slic"
var AddAnnotation = new Action <AssumeCmd>(ac =>
{
ac.Attributes = new QKeyValue(Token.NoToken, "slic", new List <object>(), ac.Attributes);
});
init.TopLevelDeclarations.OfType <Implementation>()
.Iter(impl => impl.Blocks
.Iter(blk => blk.Cmds.OfType <AssumeCmd>()
.Iter(AddAnnotation)));
}
// Only keep assertions in assertProc procedures
if (Options.assertProcs != null)
{
(new Instrumentations.PruneNonAssertProcs(Options.assertProcs)).Visit(init);
}
// Inline procedures supplied with {:inline} annotation
cba.Driver.InlineProcedures(init);
// Remove {:inline} impls
init.RemoveTopLevelDeclarations(decl => (decl is Implementation) &&
(BoogieUtil.checkAttrExists("inline", decl.Attributes) ||
BoogieUtil.checkAttrExists("inline", (decl as Implementation).Proc.Attributes)));
// Restrict entrypoints to those provided explicitly (overrides any other way to providing entryPoints)
if (Options.entryPointProcs != null)
{
//only consider the user provided entry points in command line
Options.useHarnessTag = false;
Options.useProvidedEntryPoints = true;
init.TopLevelDeclarations.OfType <NamedDeclaration>()
.Iter(d => d.Attributes = BoogieUtil.removeAttr("entrypoint", d.Attributes));
}
var matchesEntryPointExclude = new Func <string, bool>(s =>
{
return(Options.entryPointExcludes.Any(t => new System.Text.RegularExpressions.Regex(t).IsMatch(s)));
});
//when both entryPointProcs == null and entryPointExcludes == null, it should not add any entrypointProcs
if (Options.entryPointProcs != null || Options.entryPointExcludes != null)
{
init.TopLevelDeclarations.OfType <NamedDeclaration>()
.Where(d => d is Procedure || d is Implementation)
.Where(d => Options.entryPointProcs == null || Options.entryPointProcs.Contains(d.Name))
.Where(d => (Options.entryPointExcludes == null || !matchesEntryPointExclude(d.Name)))
.Iter(d => d.AddAttribute("entrypoint"));
}
// Add {:entrypoint} to procs with {:harness}
if (Options.useHarnessTag)
{
foreach (var decl in init.TopLevelDeclarations.OfType <NamedDeclaration>()
.Where(d => QKeyValue.FindBoolAttribute(d.Attributes, "harness")))
{
decl.AddAttribute("entrypoint");
}
}
// inlining introduces havoc statements; lets just delete them (TODO: make inlining not introduce redundant havoc statements)
//foreach (var impl in init.TopLevelDeclarations.OfType<Implementation>())
//{
// impl.Blocks.Iter(blk =>
// blk.Cmds.RemoveAll(cmd => cmd is HavocCmd));
//}
ReplaceHavocsWithNonDet(init);
//Instrument to create the harness
harnessInstrumentation = new Instrumentations.HarnessInstrumentation(init, AvnAnnotations.CORRAL_MAIN_PROC, Options.useProvidedEntryPoints);
harnessInstrumentation.DoInstrument();
//resolve+typecheck wo bothering about modSets
CommandLineOptions.Clo.DoModSetAnalysis = true;
init = BoogieUtil.ReResolveInMem(init);
CommandLineOptions.Clo.DoModSetAnalysis = false;
// Update mod sets
BoogieUtil.DoModSetAnalysis(init);
if (Options.AddMapSelectNonNullAssumptions)
{
(new Instrumentations.AssertMapSelectsNonNull()).Visit(init);
}
BoogieUtil.pruneProcs(init, AvnAnnotations.CORRAL_MAIN_PROC);
if (Options.deadCodeDetect)
{
// Tag branches as reachable
var tup = InstrumentBranches.Run(init, AvnAnnotations.CORRAL_MAIN_PROC, Options.UseAliasAnalysisForAngelicAssertions, false);
init = tup.Item1;
// TODO: inject this information into the program itself
DeadCodeBranchesDependencyInfo = tup.Item2;
}
return(init);
}
static void Main(string[] args)
{
con = new Context();
string
inFileName = null,
unrolledFileName = null,
tidRewrittenFileName = null,
expandedFileName = null,
annotatedFileName = null,
splitFileName = null,
yieldedFileName = null,
instantiatedFileName = null,
finalFileName = null,
mhpFileName = null,
hmifFileName = null;
dbg = false;
inFileName = parseCommandLine(args);
string[] parts = inFileName.Split('.');
if (parts.Count() == 1)
{
unrolledFileName = inFileName + "_unrolled";
hmifFileName = inFileName + "_hmif";
expandedFileName = inFileName + "_expanded";
tidRewrittenFileName = inFileName + "_tidRewritten";
annotatedFileName = inFileName + "_annotated";
splitFileName = inFileName + "_split";
yieldedFileName = inFileName + "_yielded";
finalFileName = inFileName + "_final";
mhpFileName = inFileName + "_mhp";
instantiatedFileName = inFileName + "_inst";
}
else
{
string name = parts[0];
unrolledFileName = name + "_unrolled";
hmifFileName = name + "_hmif";
expandedFileName = name + "_expanded";
annotatedFileName = name + "_annotated";
splitFileName = name + "_split";
yieldedFileName = name + "_yielded";
finalFileName = name + "_final";
mhpFileName = name + "_mhp";
instantiatedFileName = name + "_inst";
tidRewrittenFileName = name + "_tidRewritten";
for (int i = 1; i < parts.Count(); ++i)
{
unrolledFileName += "." + parts[i];
hmifFileName += "." + parts[i];
expandedFileName += "." + parts[i];
annotatedFileName += "." + parts[i];
splitFileName += "." + parts[i];
yieldedFileName += "." + parts[i];
finalFileName += "." + parts[i];
tidRewrittenFileName += "." + parts[i];
mhpFileName += "." + parts[i];
instantiatedFileName += "." + parts[i];
}
}
var tmpFileName = "og__tmp.bpl";
ExecutionEngine.printer = new ConsolePrinter();
//CommanLineOptions will control how boogie parses the program and gives us the IR
CommandLineOptions.Install(new CommandLineOptions());
CommandLineOptions.Clo.Parse(new string[] { });
CommandLineOptions.Clo.PrintInstrumented = true;
CommandLineOptions.Clo.StratifiedInliningVerbose = 2;
CommandLineOptions.Clo.UseArrayTheory = true;
CommandLineOptions.Clo.TypeEncodingMethod = CommandLineOptions.TypeEncoding.Monomorphic;
Program program;
program = BoogieUtil.ReadAndOnlyResolve(inFileName);
// TODO: assert that no procedure can be called in both sync and async mode!
// Find entrypoint and initialize con
var entry = program.TopLevelDeclarations.OfType <Procedure>()
.Where(proc => QKeyValue.FindBoolAttribute(proc.Attributes, "entrypoint"))
.FirstOrDefault();
if (entry == null)
{
Console.WriteLine("Warning: No entrypoint given");
con.entryFunc = null;
}
else
{
con.entryFunc = entry.Name;
}
// Remove unreachable procedures
BoogieUtil.pruneProcs(program, con.entryFunc);
// Extract loops
if (extractLoops)
{
program.ExtractLoops();
}
BoogieUtil.DoModSetAnalysis(program);
if (pruneAsserts)
{
program = og.GuardAsserts(program);
}
if (injectYields)
{
program = og.InsertYields(program);
}
if (instantiateTemplates)
{
var inst = new TemplateInstantiator(program);
inst.Instantiate(program);
program = BoogieUtil.ReResolve(program, dbg ? instantiatedFileName : tmpFileName);
}
var sp = new SplitThreads(con, dbg);
var hmif = new HowManyInstanceFinder(con, dbg);
var split = new Converter <Program, Program>(sp.split);
var findHowManyInstances = new Converter <Program, Program>(hmif.Compute);
if (entry != null && splitThreads)
{
if (dbg)
{
Console.WriteLine("Splitting procedures on thread entry: {0}", splitFileName);
}
program = split(program);
program = BoogieUtil.ReResolve(program, dbg ? hmifFileName : tmpFileName);
program = findHowManyInstances(program);
program = BoogieUtil.ReResolve(program, dbg ? splitFileName : tmpFileName);
}
// Get rid of corral_yield
program = og.RemoveCorralYield(program, con.yieldProc);
var yieldedProgram = new ProgTransformation.PersistentProgram(program);
if (dbg)
{
Console.WriteLine("Instrumenting: {0}", annotatedFileName);
}
if (!noTid)
{
program = og.InstrumentTid(program);
}
program = og.InstrumentAtomicBlocks(program);
if (instrumentPermissions)
{
program = og.InstrumentPermissions(program);
}
program = BoogieUtil.ReResolve(program, dbg ? annotatedFileName : tmpFileName);
CommandLineOptions.Clo.ContractInfer = true;
CommandLineOptions.Clo.AbstractHoudini = absDomain;
CommandLineOptions.Clo.UseProverEvaluate = true;
CommandLineOptions.Clo.ModelViewFile = "z3model";
Microsoft.Boogie.Houdini.AbstractDomainFactory.Initialize(program);
// First, do sequential
var answer = DoInference(program, InferenceMode.SEQUENTIAL, annotatedFileName, expandedFileName);
program = BoogieUtil.ReadAndOnlyResolve(dbg ? annotatedFileName : tmpFileName);
// prune "true" functions
var progFuncs = new Dictionary <string, Function>();
program.TopLevelDeclarations.OfType <Function>()
.Iter(f => progFuncs.Add(f.Name, f));
var truefuncs = new List <Function>();
foreach (var f in answer)
{
if (f.Body is LiteralExpr && (f.Body as LiteralExpr).IsTrue)
{
truefuncs.Add(f);
var actualf = progFuncs[f.Name];
actualf.Attributes = BoogieUtil.removeAttr("existential", actualf.Attributes);
actualf.Body = Expr.True;
}
}
Console.WriteLine("Sequential check pruned away {0} functions, {1} remain", truefuncs.Count, answer.Count() - truefuncs.Count);
// now do concurrent
answer = DoInference(program, InferenceMode.CONCURRENT, annotatedFileName, expandedFileName);
answer = answer.Concat(truefuncs);
var provedAsserts = new Dictionary <string, bool>();
answer.Where(func => QKeyValue.FindBoolAttribute(func.Attributes, "assertGuard"))
.Iter(func => {
var le = func.Body as LiteralExpr;
System.Diagnostics.Debug.Assert(le != null);
provedAsserts.Add(func.Name, le.IsFalse);
});
// remove injected existential functions
answer = answer.Where(func => !QKeyValue.FindBoolAttribute(func.Attributes, "chignore") &&
!QKeyValue.FindBoolAttribute(func.Attributes, "assertGuard"));
if (printAssignment)
{
using (var tt = new TokenTextWriter(Console.Out))
answer.ToList().Iter(func => func.Emit(tt, 0));
}
if (dbg)
{
Console.WriteLine("Injecting invariants back into the original program: {0}", finalFileName);
}
program = yieldedProgram.getProgram();
// remove existential functions
program.RemoveTopLevelDeclarations(decl => (decl is Function) && QKeyValue.FindBoolAttribute((decl as Function).Attributes, "existential"));
program.AddTopLevelDeclarations(answer);
program = og.PruneProvedAsserts(program, f => provedAsserts[f]);
// Remove ensures and requires
program = og.RemoveRequiresAndEnsures(program);
// Remove tid func
program = og.RemoveThreadIdFunc(program);
using (Microsoft.Boogie.TokenTextWriter writer = new Microsoft.Boogie.TokenTextWriter(finalFileName))
program.Emit(writer);
}
static Program GetProgram(string filename)
{
var init = GetInputProgram(filename);
if (Options.addInitialization)
{
ComputeandInitializeUninitializedLocals(init);
}
// Do some instrumentation for the input program
if (Options.markAssumesAsSlic)
{
// Mark all assumes as "slic"
var AddAnnotation = new Action <AssumeCmd>(ac =>
{
ac.Attributes = new QKeyValue(Token.NoToken, "slic", new List <object>(), ac.Attributes);
});
init.TopLevelDeclarations.OfType <Implementation>()
.Iter(impl => impl.Blocks
.Iter(blk => blk.Cmds.OfType <AssumeCmd>()
.Iter(AddAnnotation)));
}
// Inline procedures supplied with {:inline} annotation
cba.Driver.InlineProcedures(init);
// Remove {:inline} impls
init.RemoveTopLevelDeclarations(decl => (decl is Implementation) &&
(BoogieUtil.checkAttrExists("inline", decl.Attributes) ||
BoogieUtil.checkAttrExists("inline", (decl as Implementation).Proc.Attributes)));
// Add {:entrypoint} to procs with {:harness}
if (Options.useHarnessTag)
{
foreach (var decl in init.TopLevelDeclarations.OfType <NamedDeclaration>()
.Where(d => QKeyValue.FindBoolAttribute(d.Attributes, "harness")))
{
decl.AddAttribute("entrypoint");
}
}
// inlining introduces havoc statements; lets just delete them (TODO: make inlining not introduce redundant havoc statements)
foreach (var impl in init.TopLevelDeclarations.OfType <Implementation>())
{
impl.Blocks.Iter(blk =>
blk.Cmds.RemoveAll(cmd => cmd is HavocCmd));
}
//Instrument to create the harness
harnessInstrumentation = new Instrumentations.HarnessInstrumentation(init, AvnAnnotations.CORRAL_MAIN_PROC, Options.useProvidedEntryPoints);
harnessInstrumentation.DoInstrument();
//resolve+typecheck wo bothering about modSets
CommandLineOptions.Clo.DoModSetAnalysis = true;
init = BoogieUtil.ReResolve(init);
CommandLineOptions.Clo.DoModSetAnalysis = false;
// Update mod sets
BoogieUtil.DoModSetAnalysis(init);
if (Options.AddMapSelectNonNullAssumptions)
{
(new Instrumentations.AssertMapSelectsNonNull()).Visit(init);
}
BoogieUtil.pruneProcs(init, AvnAnnotations.CORRAL_MAIN_PROC);
if (Options.deadCodeDetect)
{
// Tag branches as reachable
var tup = InstrumentBranches.Run(init, AvnAnnotations.CORRAL_MAIN_PROC, Options.UseAliasAnalysisForAngelicAssertions, false);
init = tup.Item1;
// TODO: inject this information into the program itself
DeadCodeBranchesDependencyInfo = tup.Item2;
}
return(init);
}
public override CBAProgram runCBAPass(CBAProgram program)
{
// Add blanks
blanksInfo = AddBlanks(program);
// Remove unreachable procedures
BoogieUtil.pruneProcs(program, program.mainProcName);
if (!Options.TraceSlicing)
{
// Remove source line annotations
sourceInfo = cba.PrintSdvPath.DeleteSourceInfo(program);
}
else
{
sourceInfo = null;
}
// Remove print info
//printInfo = cba.PrintSdvPath.DeletePrintCmds(program);
// Compress
compressBlocks.VisitProgram(program);
// name Ebasic
NameEnvironmentConstraints(program);
// Instrument assertions
int tokenId = 0;
origMainName = program.mainProcName;
CBAProgram ret = null;
if (!Options.DeepAsserts)
{
// Do error-bit instrumentation
var impls = BoogieUtil.nameImplMapping(program);
var pwa = cba.SequentialInstrumentation.procsWithAsserts(program);
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
var instrumented = new List <Block>();
foreach (var blk in impl.Blocks)
{
var currCmds = new List <Cmd>();
var currLabel = blk.Label;
assertInstrInfo.addTrans(impl.Name, blk.Label, blk.Label);
var incnt = -1;
foreach (Cmd cmd in blk.Cmds)
{
incnt++;
// instrument assert
if (cmd is AssertCmd && !BoogieUtil.isAssertTrue(cmd))
{
currCmds.Add(BoogieAstFactory.MkVarEqExpr(assertsPassed, (cmd as AssertCmd).Expr));
var token = new AssertToken(tokenId);
originalAssertions.Add(token, cmd as AssertCmd);
tokenLocation.Add(token, Tuple.Create(impl.Name, currLabel));
procToTokens.InitAndAdd(impl.Name, token);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
currLabel = addInstr(instrumented, currCmds, currLabel, tokenId);
tokenId++;
currCmds = new List <Cmd>();
continue;
}
// procedure call
if (cmd is CallCmd && pwa.Contains((cmd as CallCmd).callee))
{
currCmds.Add(cmd);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
currLabel = addInstr(instrumented, currCmds, currLabel, -1);
currCmds = new List <Cmd>();
continue;
}
currCmds.Add(cmd);
addedTrans(impl.Name, blk.Label, incnt, cmd, currLabel, currCmds);
}
instrumented.Add(new Block(Token.NoToken, currLabel, currCmds, blk.TransferCmd));
}
impl.Blocks = instrumented;
}
program.AddTopLevelDeclaration(assertsPassed);
var newMain = addMain(program);
BoogieUtil.DoModSetAnalysis(program);
// Set inline attribute
// free requires assertsPassed == true;
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
impl.Proc.Requires.Add(new Requires(true, Expr.Ident(assertsPassed)));
}
// convert free ensures e to:
// free ensures assertsPassed == false || e
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>()
.Where(impl => pwa.Contains(impl.Name)))
{
foreach (Ensures ens in impl.Proc.Ensures)
{
ens.Condition = Expr.Or(Expr.Not(Expr.Ident(assertsPassed)), ens.Condition);
}
}
currProg = program;
ret = new CBAProgram(program, newMain, 0);
}
else
{
// Use Deep-assert instrumentation
da = new cba.DeepAssertRewrite();
// First, tag assertions with tokens
foreach (var impl in program.TopLevelDeclarations.OfType <Implementation>())
{
foreach (var blk in impl.Blocks)
{
foreach (var cmd in blk.Cmds.OfType <AssertCmd>())
{
if (BoogieUtil.isAssertTrue(cmd))
{
continue;
}
var token = new AssertToken(tokenId);
cmd.Attributes = new QKeyValue(Token.NoToken, "avn", new List <object> {
Expr.Literal(tokenId)
},
cmd.Attributes);
originalAssertions.Add(token, cmd);
tokenLocation.Add(token, Tuple.Create(impl.Name, blk.Label));
procToTokens.InitAndAdd(impl.Name, token);
tokenId++;
}
}
}
// Second, do the rewrite
var t1 = new PersistentProgram(program, program.mainProcName, program.contextBound);
var t2 = da.run(t1);
var daprog = t2.getCBAProgram();
// Third, revisit the assertions and remember their location
// in the output program. This is a bit of a hack. The "tokenLocation"
// of a token is the pair (p1,b1) where p1 is the procedure the assertion
// originally came from and b1 is the block in the new main that contains
// that assertion.
var main = BoogieUtil.findProcedureImpl(daprog.TopLevelDeclarations, daprog.mainProcName);
foreach (var block in main.Blocks)
{
foreach (var cmd in block.Cmds.OfType <AssertCmd>())
{
var tok = QKeyValue.FindIntAttribute(cmd.Attributes, "avn", -1);
if (tok < 0)
{
continue;
}
var token = new AssertToken(tok);
Debug.Assert(tokenLocation.ContainsKey(token));
var oldloc = tokenLocation[token];
tokenLocation[token] = Tuple.Create(oldloc.Item1, block.Label);
}
}
currProg = daprog;
ret = daprog;
}
return(ret);
}
public void Run()
{
Implementation impl;
var rd = "";
while (true)
{
if (!impls.TryTake(out impl))
{
break;
}
while (!resources.TryTake(out rd))
{
Thread.Sleep(100);
}
sem.WaitOne();
var wd = Path.Combine(rd, impl.Name); // create new directory for each entrypoint
Directory.CreateDirectory(wd); // create new directory for each entrypoint
RemoteExec.CleanDirectory(wd);
var pruneFile = Path.Combine(wd, "pruneSlice.bpl");
Program newprogram;
// lock because Parsing a program is not thread-safe
lock (fslock)
{
BoogieUtil.PrintProgram(program, pruneFile); // dump original program (so that each entrypoint has its own copy of program)
newprogram = BoogieUtil.ReadAndOnlyResolve(pruneFile); // entrypoint's copy of the program
}
// slice the program by entrypoints
Program shallowP = pruneDeepProcs(newprogram, ref edges, impl.Name, approximationDepth, implNames);
BoogieUtil.pruneProcs(shallowP,
shallowP.TopLevelDeclarations.OfType <Procedure>()
.Where(proc => BoogieUtil.checkAttrExists("entrypoint", proc.Attributes))
.Select(proc => proc.Name)
.FirstOrDefault());
File.Delete(pruneFile);
lock (fslock)
{
BoogieUtil.PrintProgram(shallowP, pruneFile); // dump sliced program
}
sem.Release();
if (Driver.createEntryPointBplsOnly)
{
Console.WriteLine("Skipping AVN run for {0} given /createEntrypointBplsOnly", impl.Name);
resources.Add(rd);
continue;
}
if (!remotedirs.Contains(rd))
{
Console.WriteLine("Running entrypoint {0} locally {{", impl.Name);
if (deadlineReached)
{
return;
}
// spawn the job -- local
var output = RemoteExec.run(wd, avnPath, string.Format("\"{0}\" {1}", pruneFile, avnArgs));
lock (fslock)
{
// delete temp files
if (!keepFiles)
{
var files = System.IO.Directory.GetFiles(wd, "*.bpl");
foreach (var f in files)
{
System.IO.File.Delete(f);
}
}
using (StreamWriter sw = new StreamWriter(Path.Combine(wd, "stdout.txt")))
output.Iter(s => sw.WriteLine("{0}", s));
}
Console.WriteLine("Running entrypoint {0} locally }}", impl.Name);
}
else
{
// spawn the job -- remote
if (psexecPath == null)
{
throw new FileNotFoundException("Cannot find PSEXEC!");
}
// find the name of the machine from the remote folder name
var machine = "";
var remoteroot = RemoteExec.GetRemoteFolder(rd, out machine);
Console.WriteLine("Running entrypoint {0} on {1} {{", impl.Name, machine);
// psexec machine -w remoteroot\impl remoteroot\fastavn\fastavn.exe remoteroot args
wd = Path.Combine(remoteroot, impl.Name);
var cmd = string.Format("{0} -w {1} {2} {3} {4}", machine, wd, Path.Combine(remoteroot, "fastavn", "AngelicVerifierNull.exe"),
"pruneSlice.bpl", avnArgs);
//Console.WriteLine("PSEXEC Running: {0}", cmd);
if (deadlineReached)
{
return;
}
var output = RemoteExec.run(Directory.GetCurrentDirectory(), psexecPath, cmd);
lock (fslock)
{
// delete temp files
var td = Path.Combine(rd, impl.Name);
if (debug)
{
Console.WriteLine("Getting files in directory: {0}", td);
}
var files = System.IO.Directory.GetFiles(td, "*.bpl");
foreach (var f in files)
{
if (debug)
{
Console.WriteLine("Deleting {0}", f);
}
System.IO.File.Delete(f);
}
// copy the results back
var ld = Path.Combine(Directory.GetCurrentDirectory(), impl.Name);
Directory.CreateDirectory(ld);
RemoteExec.CleanDirectory(ld);
RemoteExec.CopyFolder(rd, Directory.GetCurrentDirectory(), impl.Name, true);
using (StreamWriter sw = new StreamWriter(Path.Combine(ld, "stdout.txt")))
output.Iter(s => sw.WriteLine("{0}", s));
}
Console.WriteLine("Running entrypoint {0} on {1} }}", impl.Name, machine);
}
lock (fslock)
{
// collect and merge bugs
var bugs = collectBugs(Path.Combine(Directory.GetCurrentDirectory(), impl.Name, bugReportFileName));
bugs.Iter(b =>
{
if (!mergedBugs.ContainsKey(b))
{
mergedBugs[b] = 0;
}
mergedBugs[b] += 1;
});
Utils.Print(string.Format("Bugs found so far: {0}", mergedBugs.Count));
resources.Add(rd);
}
}
}
