done

.gitignore

@@ -0,0 +1,2 @@
+# Project exclude paths
+/out/

.idea/jpa-buddy.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JpaBuddyIdeaProjectConfig">
+    <option name="renamerInitialized" value="true" />
+  </component>
+</project>

.idea/misc.xml

@@ -7,4 +7,7 @@
   <component name="ProjectRootManager" version="2" languageLevel="JDK_11" default="true" project-jdk-name="10" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
+  <component name="ProjectType">
+    <option name="id" value="jpab" />
+  </component>
 </project>

README.md

@@ -1,4 +1,4 @@
-# Lab 4 - Software Peformance 2023
+# Lab 4 - Software Performance 2023
 
 This is Lab 4 of the **Software Performance** course at USI.
 
@@ -6,29 +6,32 @@ Go to [this Lab on iCorsi](https://www.icorsi.ch/course/view.php?id=16963).
 
 ## Submission Info
 
-Property     | Value
+| Property   | Value    |
------------- | -------------
+|------------|----------|
-First Name   | ...
+| First Name | Claudio  |
-Last Name    | ...
+| Last Name  | Maggioni |
+
+**NOTE:** the combined PDFs for all CFGs, all combined outputs and all DTs can be found in `test-output/all.cfg.pdf`, 
+`test-output/all.combined.pdf` and `test-output/all.dt.pdf` respectively.
 
 ## Submission Checklist
 
 Please complete this checklist (turn [ ] into [X]) before you submit:
 
-- [ ] I completed the above Submission Info
+- [x] I completed the above Submission Info
-- [ ] I built the project in IntelliJ (Build > Build Project)
+- [x] I built the project in IntelliJ (Build > Build Project)
-- [ ] I (re)implemented the ControlFlowGraphBuilder (copy from Lab 3)
+- [x] I (re)implemented the ControlFlowGraphBuilder (copy from Lab 3)
-- [ ] I (re)implemented the ControlFlowGraphRenderer (copy from Lab 3)
+- [x] I (re)implemented the ControlFlowGraphRenderer (copy from Lab 3)
-- [ ] I implemented the Traversal
+- [x] I implemented the Traversal
-- [ ] I implemented the DominatorAnalyzer
+- [x] I implemented the DominatorAnalyzer
-- [ ] I wrote the source code myself and did not look at the source code of my class mates
+- [x] I wrote the source code myself and did not look at the source code of my class mates
-- [ ] I ran all the JUnit tests and verified that they all pass
+- [x] I ran all the JUnit tests and verified that they all pass
-- [ ] I manually checked that my implementation is correct by doing this:
+- [x] I manually checked that my implementation is correct by doing this:
-  - [ ] I studied the test-input/ExampleClass.java source code
+  - [x] I studied the test-input/ExampleClass.java source code
-  - [ ] I ran App to produce the dot files (in test-output/)
+  - [x] I ran App to produce the dot files (in test-output/)
-  - [ ] I ran dot to turn the dot files in test-output into a PDF
+  - [x] I ran dot to turn the dot files in test-output into a PDF
-  - [ ] I manually verified that the PDF contains a set of pages per method of ExampleClass
+  - [x] I manually verified that the PDF contains a set of pages per method of ExampleClass
-  - [ ] I manually verified that the CFGs in the PDFs correspond to the methods' source code
+  - [x] I manually verified that the CFGs in the PDFs correspond to the methods' source code
-  - [ ] I manually verified that the dominator trees in the PDFs correspond to the method's source code
+  - [x] I manually verified that the dominator trees in the PDFs correspond to the method's source code
-- [ ] I committed my changes (at least one commit, but possibly many)
+- [x] I committed my changes (at least one commit, but possibly many)
-- [ ] I pushed my commits to GitHub
+- [x] I pushed my commits to GitHub

compile-tests.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+set -eou pipefail
+
+cd -- "$( dirname -- "${BASH_SOURCE[0]}" )"
+for extkind in cfg combined dt; do
+  gvpack -u test-output/*.$extkind.dot > test-output/all.$extkind.dot
+  dot -Tpdf test-output/all.$extkind.dot > test-output/all.$extkind.pdf
+done

src/ch/usi/inf/sp/cfg/ControlFlowGraph.java

@@ -1,7 +1,7 @@
 package ch.usi.inf.sp.cfg;
 
-import ch.usi.inf.sp.graph.DiGraph;
 
+import ch.usi.inf.sp.graph.DiGraph;
 
 public final class ControlFlowGraph extends DiGraph<BasicBlock, ControlFlowEdge> {
 
@@ -85,26 +85,4 @@ public final class ControlFlowGraph extends DiGraph<BasicBlock, ControlFlowEdge>
         return exit;
     }
 
-    public String toString() {
-        final StringBuffer sb = new StringBuffer("digraph CFG {\n");
-        for (final BasicBlock node : getNodes()) {
-            if (node==entry) {
-                sb.append("  " + node + " [shape=circle,style=filled,label=e]\n");
-            } else if (node==exit) {
-                    sb.append("  " + node + " [shape=circle,style=filled,label=x]\n");
-            } else {
-                sb.append("  " + node + " [shape=rectangle]\n");
-            }
-        }
-        for (final ControlFlowEdge edge : getEdges()) {
-            if (edge.getLabel().length()>0) {
-                sb.append("  " + edge + " [label=" + edge.getLabel() + "]\n");
-            } else {
-                sb.append("  " + edge + "\n");
-            }
-        }
-        sb.append("}\n");
-        return sb.toString();
-    }
-
 }

src/ch/usi/inf/sp/cfg/ControlFlowGraphBuilder.java

@@ -1,23 +1,141 @@
 package ch.usi.inf.sp.cfg;
 
-import java.util.List;
-
 import ch.usi.inf.sp.bytecode.Disassembler;
+import ch.usi.inf.sp.cfg.builder.JumpSource;
+import ch.usi.inf.sp.cfg.builder.LookupSwitchInstructionNodeInfo;
+import ch.usi.inf.sp.cfg.builder.MultiMap;
+import ch.usi.inf.sp.cfg.builder.SwitchInstructionNodeInfo;
+import ch.usi.inf.sp.cfg.builder.TableSwitchInstructionNodeInfo;
 import org.objectweb.asm.Opcodes;
-import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.*;
-import org.objectweb.asm.tree.InsnList;
-import org.objectweb.asm.tree.JumpInsnNode;
-import org.objectweb.asm.tree.LabelNode;
-import org.objectweb.asm.tree.LookupSwitchInsnNode;
-import org.objectweb.asm.tree.MethodNode;
-import org.objectweb.asm.tree.TableSwitchInsnNode;
 
+import java.util.*;
 
-public class ControlFlowGraphBuilder {
+public final class ControlFlowGraphBuilder {
+    private static final String DEFAULT_LABEL = "default";
+    private static final String TRUE_LABEL = "T";
 
-    public static ControlFlowGraph createControlFlowGraph(final MethodNode method) {
+    private final MultiMap<LabelNode, JumpSource> labelToIncomingEdges = new MultiMap<>();
-        //TODO
+    private final List<LabelNode> labels = new ArrayList<>();
-        return null;
+    private final Map<AbstractInsnNode, BasicBlock> insnToBlock = new HashMap<>();
+    private final ControlFlowGraph graph = new ControlFlowGraph();
+    private final MethodNode method;
+    private BasicBlock currentBasicBlock;
+
+    private ControlFlowGraphBuilder(MethodNode method) {
+        this.method = method;
+        setNewBasicBlock(0);
+        graph.addEntryEdge(currentBasicBlock);
     }
 
+    public static ControlFlowGraph createControlFlowGraph(final MethodNode method) {
+        return new ControlFlowGraphBuilder(method).create();
+    }
+
+    private void setNewBasicBlock(int id) {
+        currentBasicBlock = new BasicBlock(id);
+        graph.addNode(currentBasicBlock);
+    }
+
+    public ControlFlowGraph create() {
+        // get the list of all instructions in that method
+        final InsnList instructions = method.instructions;
+        for (int i = 0; i < instructions.size(); i++) {
+            final AbstractInsnNode instruction = instructions.get(i);
+
+            switch (instruction.getType()) {
+                case AbstractInsnNode.JUMP_INSN:
+                        labelToIncomingEdges.put(((JumpInsnNode) instruction).label, new JumpSource(instruction, TRUE_LABEL));
+                        break;
+                case AbstractInsnNode.LOOKUPSWITCH_INSN:
+                        captureSwitchEdges(new LookupSwitchInstructionNodeInfo((LookupSwitchInsnNode) instruction));
+                        break;
+                case AbstractInsnNode.TABLESWITCH_INSN:
+                        captureSwitchEdges(new TableSwitchInstructionNodeInfo((TableSwitchInsnNode) instruction));
+            }
+        }
+
+        for (int i = 0; i < instructions.size(); i++) {
+            final AbstractInsnNode instruction = instructions.get(i);
+
+            currentBasicBlock.appendInstruction(Disassembler.disassembleInstruction(instruction, i, instructions));
+
+            if (isReturnInstruction(instruction)) {
+                graph.addExitEdge(currentBasicBlock);
+            }
+
+            insnToBlock.put(instruction, currentBasicBlock);
+
+            if (isInsnSignificantLabel(instruction)) {
+                labels.add((LabelNode) instruction);
+            }
+
+            if (isEndOfBlock(instruction)) {
+                final BasicBlock previousBasicBlock = currentBasicBlock;
+                setNewBasicBlock(i + 1);
+
+                // GOTO and SWITCH instructions do not have a fallthrough edge, otherwise add one
+                if (instruction.getOpcode() != Opcodes.GOTO
+                        && instruction.getType() != AbstractInsnNode.LOOKUPSWITCH_INSN
+                        && instruction.getType() != AbstractInsnNode.TABLESWITCH_INSN) {
+                    graph.addFallthroughEdge(previousBasicBlock, currentBasicBlock);
+                }
+            }
+        }
+
+        for (final LabelNode label : labels) {
+            final BasicBlock toBB = Objects.requireNonNull(insnToBlock.get(label));
+            for (final JumpSource jumpSource : labelToIncomingEdges.getAll(label)) {
+                final BasicBlock fromBB = jumpSource.block(insnToBlock);
+                final ControlFlowEdge edge = jumpSource.edge();
+
+                graph.addEdge(edge);
+                graph.connect(fromBB, edge, toBB);
+            }
+        }
+
+        return graph;
+    }
+
+    private void captureSwitchEdges(final SwitchInstructionNodeInfo info) {
+        for (int j = 0; j < info.getCaseCount(); j++) {
+            final LabelNode label = info.getLabelForCase(j);
+            final String value = info.getKeyForCase(j);
+            labelToIncomingEdges.put(label, new JumpSource(info.getNode(), value));
+        }
+        if (info.getDefaultCase() != null) {
+            labelToIncomingEdges.put(info.getDefaultCase(), new JumpSource(info.getNode(), DEFAULT_LABEL));
+        }
+    }
+
+    private boolean isInsnSignificantLabel(final AbstractInsnNode node) {
+        return node instanceof LabelNode && labelToIncomingEdges.containsKey((LabelNode) node);
+    }
+
+    private boolean isReturnInstruction(final AbstractInsnNode instruction) {
+        final int opcode = instruction.getOpcode();
+        return opcode == Opcodes.RETURN ||
+                opcode == Opcodes.ARETURN ||
+                opcode == Opcodes.LRETURN ||
+                opcode == Opcodes.IRETURN ||
+                opcode == Opcodes.FRETURN;
+    }
+
+    private boolean isEndOfBlock(final AbstractInsnNode instruction) {
+        final AbstractInsnNode nextInsn = instruction.getNext();
+
+        if (nextInsn == null) {
+            return false; // cannot start another bb at the end of the method with 0 instructions
+        }
+
+        final int type = instruction.getType();
+        if (type == AbstractInsnNode.JUMP_INSN ||
+                type == AbstractInsnNode.LOOKUPSWITCH_INSN ||
+                type == AbstractInsnNode.TABLESWITCH_INSN) {
+            return true; // if we're branching or jumping after this instruction, we NEED to cut the current bb short
+        }
+
+        // if the next instruction is a label some other bb may jump into then cut, otherwise continue
+        return isInsnSignificantLabel(nextInsn);
+    }
 }

src/ch/usi/inf/sp/cfg/ControlFlowGraphRenderer.java

@@ -1,11 +1,63 @@
 package ch.usi.inf.sp.cfg;
 
 
-public class ControlFlowGraphRenderer {
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
-    public static String renderControlFlowGraph(final String label, final ControlFlowGraph cfg) {
+public class ControlFlowGraphRenderer {
-        //TODO
+    private static final String INDENTATION = "    ";
-        return null;
+    private final StringBuilder code = new StringBuilder();
+    private int indentationLevel = 0;
+
+    private static String nodeIdentifier(final BasicBlock bb, final String graphId) {
+        // as the basic block ID is negative for the entry and exit node, and negative numbers contain
+        // a dash symbol, we need to quote the identifier to make a syntactically correct DOT file
+        return String.format("\"%sbb%d\"", graphId, bb.getId());
     }
 
+    private static String nodeStyle(final BasicBlock bb, final String label) {
+        if (bb.getInEdges().isEmpty()) {
+            return "[shape=circle,label=\"e\",xlabel=\"" + label + "\"]";
+        } else if (bb.getOutEdges().isEmpty()) {
+            return "[shape=circle,label=\"x\"]";
+        } else {
+            return "[label=\"" + bb.getId() + "|{" +
+                    StreamSupport.stream(bb.getInstructions().spliterator(), false)
+                            .collect(Collectors.joining("|"))
+                    + "}\"]";
+        }
+    }
+
+    public static String renderControlFlowGraph(final String label, final ControlFlowGraph cfg) {
+        return new ControlFlowGraphRenderer().render(label, cfg);
+    }
+
+    private void line(String line) {
+        code.append(INDENTATION.repeat(indentationLevel)).append(line).append('\n');
+    }
+
+    private String render(final String desiredLabel, final ControlFlowGraph graph) {
+        final String label = desiredLabel.replaceAll("\\W+", "");
+
+        line("digraph " + label + " {");
+        code.append('\n');
+        indentationLevel++;
+
+        line("node [shape=record]");
+        for (final BasicBlock bb : graph.getNodes()) {
+            line(nodeIdentifier(bb, label) + " " + nodeStyle(bb, label));
+        }
+        code.append('\n');
+
+        for (var e : graph.getEdges()) {
+            final String l = e.getLabel();
+            final String suffix = l == null || l.isBlank() ? "" : (" [label=\"" + e.getLabel() + "\"]");
+
+            line(nodeIdentifier(e.getFrom(), label) + " -> " + nodeIdentifier(e.getTo(), label) + suffix);
+        }
+        indentationLevel--;
+        line("}");
+
+        return code.toString();
+    }
 }

src/ch/usi/inf/sp/cfg/builder/JumpSource.java

@@ -0,0 +1,40 @@
+package ch.usi.inf.sp.cfg.builder;
+
+import ch.usi.inf.sp.cfg.BasicBlock;
+import ch.usi.inf.sp.cfg.ControlFlowEdge;
+import org.objectweb.asm.tree.AbstractInsnNode;
+
+import java.util.Map;
+import java.util.Objects;
+
+public final class JumpSource {
+    private final AbstractInsnNode instruction;
+    private final String condition;
+
+    public JumpSource(AbstractInsnNode instruction, String condition) {
+        this.instruction = instruction;
+        this.condition = condition;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (JumpSource) obj;
+        return Objects.equals(this.instruction, that.instruction) &&
+                Objects.equals(this.condition, that.condition);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(instruction, condition);
+    }
+
+    public BasicBlock block(Map<AbstractInsnNode, BasicBlock> insnToBlock) {
+        return Objects.requireNonNull(insnToBlock.get(this.instruction));
+    }
+
+    public ControlFlowEdge edge() {
+        return new ControlFlowEdge(this.condition);
+    }
+}

src/ch/usi/inf/sp/cfg/builder/LookupSwitchInstructionNodeInfo.java

@@ -0,0 +1,38 @@
+package ch.usi.inf.sp.cfg.builder;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LookupSwitchInsnNode;
+
+public class LookupSwitchInstructionNodeInfo implements SwitchInstructionNodeInfo {
+    private final LookupSwitchInsnNode node;
+
+    public LookupSwitchInstructionNodeInfo(LookupSwitchInsnNode node) {
+        this.node = node;
+    }
+
+    @Override
+    public AbstractInsnNode getNode() {
+        return node;
+    }
+
+    @Override
+    public int getCaseCount() {
+        return node.labels.size();
+    }
+
+    @Override
+    public LabelNode getLabelForCase(int index) {
+        return node.labels.get(index);
+    }
+
+    @Override
+    public String getKeyForCase(int index) {
+        return Integer.toString(node.keys.get(index));
+    }
+
+    @Override
+    public LabelNode getDefaultCase() {
+        return node.dflt;
+    }
+}

src/ch/usi/inf/sp/cfg/builder/MultiMap.java

@@ -0,0 +1,23 @@
+package ch.usi.inf.sp.cfg.builder;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class MultiMap<K, V> {
+    private final Map<K, List<V>> innerMap = new HashMap<>();
+
+    public void put(K key, V value) {
+        innerMap.computeIfAbsent(key, (k) -> new ArrayList<>());
+        innerMap.get(key).add(value);
+    }
+
+    public List<V> getAll(K key) {
+        return new ArrayList<>(innerMap.getOrDefault(key, List.of()));
+    }
+
+    public boolean containsKey(K key) {
+        return innerMap.containsKey(key);
+    }
+}

src/ch/usi/inf/sp/cfg/builder/SwitchInstructionNodeInfo.java

@@ -0,0 +1,13 @@
+package ch.usi.inf.sp.cfg.builder;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+
+public interface SwitchInstructionNodeInfo {
+    AbstractInsnNode getNode();
+    int getCaseCount();
+    LabelNode getLabelForCase(int index);
+    String getKeyForCase(int index);
+
+    LabelNode getDefaultCase();
+}

src/ch/usi/inf/sp/cfg/builder/TableSwitchInstructionNodeInfo.java

@@ -0,0 +1,38 @@
+package ch.usi.inf.sp.cfg.builder;
+
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.TableSwitchInsnNode;
+
+public class TableSwitchInstructionNodeInfo implements SwitchInstructionNodeInfo {
+    private final TableSwitchInsnNode node;
+
+    public TableSwitchInstructionNodeInfo(TableSwitchInsnNode node) {
+        this.node = node;
+    }
+
+    @Override
+    public AbstractInsnNode getNode() {
+        return node;
+    }
+
+    @Override
+    public int getCaseCount() {
+        return node.labels.size();
+    }
+
+    @Override
+    public LabelNode getLabelForCase(int index) {
+        return node.labels.get(index);
+    }
+
+    @Override
+    public String getKeyForCase(int index) {
+        return Integer.toString(node.min + index);
+    }
+
+    @Override
+    public LabelNode getDefaultCase() {
+        return node.dflt;
+    }
+}

src/ch/usi/inf/sp/dom/DominatorAnalyzer.java

@@ -2,18 +2,18 @@ package ch.usi.inf.sp.dom;
 
 import ch.usi.inf.sp.cfg.BasicBlock;
 import ch.usi.inf.sp.cfg.ControlFlowGraph;
+import ch.usi.inf.sp.graph.Edge;
 import ch.usi.inf.sp.graph.Traversal;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.HashMap;
+import java.util.stream.Collectors;
-import java.util.List;
-import java.util.Map;
 
 
 public class DominatorAnalyzer {
 
     /**
      * Cooper et al.'s "Engineered Algorithm".
+     * <pre>
      * ================================================================
      * for all nodes, b   // initialize the dominators array
      *     doms[b] ← Undefined
@@ -40,13 +40,71 @@ public class DominatorAnalyzer {
      *             finger2 = doms[finger2]
      *     return finger1
      * ================================================================
+     * </pre>
      * Figure 3 of Cooper, Harvey, Kennedy
      */
     public static DominatorTree analyze(final ControlFlowGraph cfg) {
-        //TODO
+        final Map<BasicBlock, BasicBlock> dominators = new HashMap<>();
-        return null;
+        final BasicBlock entryNode = cfg.getEntry();
+        dominators.put(entryNode, entryNode);
+
+        final List<BasicBlock> rpo = Traversal.getNodesInReversePostOrder(cfg, entryNode);
+
+        boolean changed = true;
+        while (changed) {
+            changed = false;
+            for (final BasicBlock bb : rpo) {
+                if (bb == entryNode) {
+                    continue;
                 }
 
-    // probably add a method intersect(...)
+                final List<BasicBlock> predecessors = bb.getInEdges().stream()
+                        .map(Edge::getFrom)
+                        .collect(Collectors.toCollection(LinkedList::new));
 
+                if (predecessors.isEmpty()) {
+                    throw new IllegalStateException("all non-entry nodes should have one predecessor");
+                }
+
+                BasicBlock newDominator = predecessors.remove(0);
+
+                for (final BasicBlock pred : predecessors) {
+                    if (dominators.containsKey(pred)) {
+                        newDominator = intersect(pred, newDominator, dominators, Comparator.comparing(rpo::indexOf).reversed());
+                    }
+                }
+
+                if (dominators.get(bb) != newDominator) {
+                    dominators.put(bb, newDominator);
+                    changed = true;
+                }
+            }
+        }
+
+        final DominatorTree tree = new DominatorTree();
+        tree.setRootBlock(entryNode);
+        for (final Map.Entry<BasicBlock, BasicBlock> entry : dominators.entrySet()) {
+            if (entry.getKey() != entryNode) {
+                tree.addDominanceEdge(entry.getValue(), entry.getKey());
+            }
+        }
+
+        return tree;
+    }
+
+    public static BasicBlock intersect(BasicBlock b1, BasicBlock b2, Map<BasicBlock, BasicBlock> dominators, Comparator<? super BasicBlock> postOrder) {
+        BasicBlock finger1 = b1;
+        BasicBlock finger2 = b2;
+
+        while (postOrder.compare(finger1, finger2) != 0) {
+            while (postOrder.compare(finger1, finger2) < 0) {
+                finger1 = dominators.get(finger1);
+            }
+            while (postOrder.compare(finger1, finger2) > 0) {
+                finger2 = dominators.get(finger2);
+            }
+        }
+
+        return finger1;
+    }
 }

src/ch/usi/inf/sp/graph/Traversal.java

@@ -14,7 +14,8 @@ public class Traversal {
 
     /**
      * From: https://eli.thegreenplace.net/2015/directed-graph-traversal-orderings-and-applications-to-data-flow-analysis/
-     *
+     * <p>
+     * <pre>
      * def postorder(graph, root):
      *   """Return a post-order ordering of nodes in the graph."""
      *   visited = set()
@@ -27,13 +28,30 @@ public class Traversal {
      *     order.append(node)
      *   dfs_walk(root)
      *   return order
+     * </pre>
      */
     public static <G extends DiGraph<N, E>, N extends Node<E>, E extends Edge<N>>
     List<N> getNodesInPostOrder(final DiGraph<N, E> graph, final N entryNode) {
-        //TODO
+        final Set<N> visited = new HashSet<>();
-        return null;
+        final List<N> order = new ArrayList<>();
+        final Deque<N> visitStack = new ArrayDeque<>();
+        visitStack.push(entryNode);
+
+        mainLoop:
+        while (!visitStack.isEmpty()) {
+            final N node = visitStack.pop();
+            for (final E outEdge : node.getOutEdges()) {
+                final N successor = outEdge.getTo();
+                if (!visited.contains(successor)) {
+                    visited.add(successor);
+                    visitStack.push(node);
+                    visitStack.push(successor);
+                    continue mainLoop;
+                }
+            }
+            order.add(node);
         }
 
-    // probably add a method dfsWalk(...)
+        return order;
-
+    }
 }

starter-lab-04-dominator-analysis.iml

@@ -21,5 +21,21 @@
       </library>
     </orderEntry>
     <orderEntry type="library" name="asm-util-7.1" level="project" />
+    <orderEntry type="module-library" scope="TEST">
+      <library name="JUnit5.8.1">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter/5.8.1/junit-jupiter-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.8.1/junit-jupiter-api-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.8.1/junit-platform-commons-1.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.2/apiguardian-api-1.1.2.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-params/5.8.1/junit-jupiter-params-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-engine/5.8.1/junit-jupiter-engine-5.8.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.8.1/junit-platform-engine-1.8.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
   </component>
 </module>

test-output/<init>.asm.txt

@@ -0,0 +1,6 @@
+  Method: <init>()V
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 0
+  3:	INVOKESPECIAL java/lang/Object.<init> ()V
+  4:	RETURN 

test-output/<init>.cfg.dot

@@ -0,0 +1,10 @@
+digraph init {
+
+    node [shape=record]
+    "initbb-1" [shape=circle,label="e",xlabel="init"]
+    "initbb-2" [shape=circle,label="x"]
+    "initbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	INVOKESPECIAL java/lang/Object.<init> ()V|4:	RETURN }"]
+
+    "initbb-1" -> "initbb0"
+    "initbb0" -> "initbb-2"
+}

test-output/<init>.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="<init>"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 0\l|3:	INVOKESPECIAL java/lang/Object.<init> ()V\l|4:	RETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/<init>.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="<init>"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/all.cfg.dot

@@ -0,0 +1,805 @@
+digraph root {
+	node [label="\N",
+		shape=record
+	];
+	subgraph privateInstanceCallMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"privateInstanceCallMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=privateInstanceCallMethod];
+		privateInstanceCallMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	INVOKESPECIAL ExampleClass.privateInstanceCallTarget ()V|4:	 // label|\
+5:	 // line number information|6:	ICONST_2 |7:	IRETURN }"];
+		"privateInstanceCallMethodbb-1" -> privateInstanceCallMethodbb0;
+		"privateInstanceCallMethodbb-2"	[label=x,
+			shape=circle];
+		privateInstanceCallMethodbb0 -> "privateInstanceCallMethodbb-2";
+	}
+	subgraph privateInstanceCallTarget {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"privateInstanceCallTargetbb-1"	[label=e,
+			shape=circle,
+			xlabel=privateInstanceCallTarget];
+		privateInstanceCallTargetbb0	[label="0|{0:	 // label|1:	 // line number information|2:	RETURN }"];
+		"privateInstanceCallTargetbb-1" -> privateInstanceCallTargetbb0;
+		"privateInstanceCallTargetbb-2"	[label=x,
+			shape=circle];
+		privateInstanceCallTargetbb0 -> "privateInstanceCallTargetbb-2";
+	}
+	subgraph allocAndInit2dArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocAndInit2dArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocAndInit2dArrayMethod];
+		allocAndInit2dArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_1 |3:	ANEWARRAY [I|4:	DUP |5:	ICONST_0 |6:	ICONST_1 |7:	NEWARRAY T_INT|\
+8:	DUP |9:	ICONST_0 |10:	ICONST_1 |11:	IASTORE |12:	AASTORE |13:	ARETURN }"];
+		"allocAndInit2dArrayMethodbb-1" -> allocAndInit2dArrayMethodbb0;
+		"allocAndInit2dArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocAndInit2dArrayMethodbb0 -> "allocAndInit2dArrayMethodbb-2";
+	}
+	subgraph allocAndInitIntArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocAndInitIntArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocAndInitIntArrayMethod];
+		allocAndInitIntArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	NEWARRAY T_INT|4:	DUP |5:	ICONST_0 |6:	ICONST_1 |7:	IASTORE |8:	DUP |\
+9:	ICONST_1 |10:	ICONST_2 |11:	IASTORE |12:	ARETURN }"];
+		"allocAndInitIntArrayMethodbb-1" -> allocAndInitIntArrayMethodbb0;
+		"allocAndInitIntArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocAndInitIntArrayMethodbb0 -> "allocAndInitIntArrayMethodbb-2";
+	}
+	subgraph allocAndInitObjectArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocAndInitObjectArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocAndInitObjectArrayMethod];
+		allocAndInitObjectArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ANEWARRAY java/lang/Object|4:	DUP |5:	ICONST_0 |6:	LDC 1|7:	AASTORE |\
+8:	DUP |9:	ICONST_1 |10:	LDC 2|11:	AASTORE |12:	ARETURN }"];
+		"allocAndInitObjectArrayMethodbb-1" -> allocAndInitObjectArrayMethodbb0;
+		"allocAndInitObjectArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocAndInitObjectArrayMethodbb0 -> "allocAndInitObjectArrayMethodbb-2";
+	}
+	subgraph allocIncomplete2dArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocIncomplete2dArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocIncomplete2dArrayMethod];
+		allocIncomplete2dArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ANEWARRAY [I|4:	ARETURN }"];
+		"allocIncomplete2dArrayMethodbb-1" -> allocIncomplete2dArrayMethodbb0;
+		"allocIncomplete2dArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocIncomplete2dArrayMethodbb0 -> "allocIncomplete2dArrayMethodbb-2";
+	}
+	subgraph forMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=forMethod];
+		forMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ICONST_0 |\
+7:	ISTORE 3}"];
+		"forMethodbb-1" -> forMethodbb0;
+		"forMethodbb-2"	[label=x,
+			shape=circle];
+		forMethodbb8	[label="8|{8:	 // label|9:	 // stack frame map|10:	ILOAD 3|11:	ILOAD 1|12:	IF_ICMPGE 23}"];
+		forMethodbb0 -> forMethodbb8;
+		forMethodbb13	[label="13|{13:	 // label|14:	 // line number information|15:	ILOAD 2|16:	ILOAD 3|17:	IADD |18:	ISTORE 2|19:	 // label|20:	 // line number \
+information|21:	IINC 1 1|22:	GOTO 8}"];
+		forMethodbb8 -> forMethodbb13;
+		forMethodbb23	[label="23|{23:	 // label|24:	 // line number information|25:	 // stack frame map|26:	ILOAD 2|27:	IRETURN }"];
+		forMethodbb8 -> forMethodbb23	[label=T];
+		forMethodbb13 -> forMethodbb8	[label=T];
+		forMethodbb23 -> "forMethodbb-2";
+	}
+	subgraph forWithBreakMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forWithBreakMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=forWithBreakMethod];
+		forWithBreakMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ICONST_0 |\
+7:	ISTORE 3}"];
+		"forWithBreakMethodbb-1" -> forWithBreakMethodbb0;
+		"forWithBreakMethodbb-2"	[label=x,
+			shape=circle];
+		forWithBreakMethodbb8	[label="8|{8:	 // label|9:	 // stack frame map|10:	ILOAD 3|11:	ILOAD 1|12:	IF_ICMPGE 32}"];
+		forWithBreakMethodbb0 -> forWithBreakMethodbb8;
+		forWithBreakMethodbb13	[label="13|{13:	 // label|14:	 // line number information|15:	ILOAD 3|16:	BIPUSH 10|17:	IF_ICMPNE 21}"];
+		forWithBreakMethodbb8 -> forWithBreakMethodbb13;
+		forWithBreakMethodbb32	[label="32|{32:	 // label|33:	 // line number information|34:	 // stack frame map|35:	ILOAD 2|36:	IRETURN }"];
+		forWithBreakMethodbb8 -> forWithBreakMethodbb32	[label=T];
+		forWithBreakMethodbb18	[label="18|{18:	 // label|19:	 // line number information|20:	GOTO 32}"];
+		forWithBreakMethodbb13 -> forWithBreakMethodbb18;
+		forWithBreakMethodbb21	[label="21|{21:	 // label|22:	 // line number information|23:	 // stack frame map|24:	ILOAD 2|25:	ILOAD 3|26:	IADD |27:	ISTORE 2|28:	 // \
+label|29:	 // line number information|30:	IINC 3 1|31:	GOTO 8}"];
+		forWithBreakMethodbb13 -> forWithBreakMethodbb21	[label=T];
+		forWithBreakMethodbb18 -> forWithBreakMethodbb32	[label=T];
+		forWithBreakMethodbb21 -> forWithBreakMethodbb8	[label=T];
+		forWithBreakMethodbb32 -> "forWithBreakMethodbb-2";
+	}
+	subgraph forWithContinueMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forWithContinueMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=forWithContinueMethod];
+		forWithContinueMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ICONST_0 |\
+7:	ISTORE 3}"];
+		"forWithContinueMethodbb-1" -> forWithContinueMethodbb0;
+		"forWithContinueMethodbb-2"	[label=x,
+			shape=circle];
+		forWithContinueMethodbb8	[label="8|{8:	 // label|9:	 // stack frame map|10:	ILOAD 3|11:	ILOAD 1|12:	IF_ICMPGE 33}"];
+		forWithContinueMethodbb0 -> forWithContinueMethodbb8;
+		forWithContinueMethodbb13	[label="13|{13:	 // label|14:	 // line number information|15:	ILOAD 3|16:	BIPUSH 10|17:	IF_ICMPNE 21}"];
+		forWithContinueMethodbb8 -> forWithContinueMethodbb13;
+		forWithContinueMethodbb33	[label="33|{33:	 // label|34:	 // line number information|35:	 // stack frame map|36:	ILOAD 2|37:	IRETURN }"];
+		forWithContinueMethodbb8 -> forWithContinueMethodbb33	[label=T];
+		forWithContinueMethodbb18	[label="18|{18:	 // label|19:	 // line number information|20:	GOTO 28}"];
+		forWithContinueMethodbb13 -> forWithContinueMethodbb18;
+		forWithContinueMethodbb21	[label="21|{21:	 // label|22:	 // line number information|23:	 // stack frame map|24:	ILOAD 2|25:	ILOAD 3|26:	IADD |27:	ISTORE 2}"];
+		forWithContinueMethodbb13 -> forWithContinueMethodbb21	[label=T];
+		forWithContinueMethodbb28	[label="28|{28:	 // label|29:	 // line number information|30:	 // stack frame map|31:	IINC 3 1|32:	GOTO 8}"];
+		forWithContinueMethodbb18 -> forWithContinueMethodbb28	[label=T];
+		forWithContinueMethodbb21 -> forWithContinueMethodbb28;
+		forWithContinueMethodbb28 -> forWithContinueMethodbb8	[label=T];
+		forWithContinueMethodbb33 -> "forWithContinueMethodbb-2";
+	}
+	subgraph ifElseMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"ifElseMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=ifElseMethod];
+		ifElseMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ILOAD 1|7:	\
+IFLE 13}"];
+		"ifElseMethodbb-1" -> ifElseMethodbb0;
+		"ifElseMethodbb-2"	[label=x,
+			shape=circle];
+		ifElseMethodbb8	[label="8|{8:	 // label|9:	 // line number information|10:	ICONST_0 |11:	ISTORE 2|12:	GOTO 18}"];
+		ifElseMethodbb0 -> ifElseMethodbb8;
+		ifElseMethodbb13	[label="13|{13:	 // label|14:	 // line number information|15:	 // stack frame map|16:	ILOAD 1|17:	ISTORE 2}"];
+		ifElseMethodbb0 -> ifElseMethodbb13	[label=T];
+		ifElseMethodbb18	[label="18|{18:	 // label|19:	 // line number information|20:	 // stack frame map|21:	ILOAD 2|22:	IRETURN }"];
+		ifElseMethodbb8 -> ifElseMethodbb18	[label=T];
+		ifElseMethodbb13 -> ifElseMethodbb18;
+		ifElseMethodbb18 -> "ifElseMethodbb-2";
+	}
+	subgraph instanceCallMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"instanceCallMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=instanceCallMethod];
+		instanceCallMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	INVOKEVIRTUAL ExampleClass.instanceCallTarget ()V|4:	 // label|5:	 // \
+line number information|6:	ICONST_2 |7:	IRETURN }"];
+		"instanceCallMethodbb-1" -> instanceCallMethodbb0;
+		"instanceCallMethodbb-2"	[label=x,
+			shape=circle];
+		instanceCallMethodbb0 -> "instanceCallMethodbb-2";
+	}
+	subgraph instanceCallTarget {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"instanceCallTargetbb-1"	[label=e,
+			shape=circle,
+			xlabel=instanceCallTarget];
+		instanceCallTargetbb0	[label="0|{0:	 // label|1:	 // line number information|2:	RETURN }"];
+		"instanceCallTargetbb-1" -> instanceCallTargetbb0;
+		"instanceCallTargetbb-2"	[label=x,
+			shape=circle];
+		instanceCallTargetbb0 -> "instanceCallTargetbb-2";
+	}
+	subgraph interfaceCallMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"interfaceCallMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=interfaceCallMethod];
+		interfaceCallMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	INVOKEINTERFACE ExampleClass$Interface.interfaceCallTarget ()V|4:	 // \
+label|5:	 // line number information|6:	ICONST_2 |7:	IRETURN }"];
+		"interfaceCallMethodbb-1" -> interfaceCallMethodbb0;
+		"interfaceCallMethodbb-2"	[label=x,
+			shape=circle];
+		interfaceCallMethodbb0 -> "interfaceCallMethodbb-2";
+	}
+	subgraph nestedFor {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"nestedForbb-1"	[label=e,
+			shape=circle,
+			xlabel=nestedFor];
+		nestedForbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ICONST_0 |\
+7:	ISTORE 3}"];
+		"nestedForbb-1" -> nestedForbb0;
+		"nestedForbb-2"	[label=x,
+			shape=circle];
+		nestedForbb8	[label="8|{8:	 // label|9:	 // stack frame map|10:	ILOAD 3|11:	ILOAD 1|12:	IF_ICMPGE 37}"];
+		nestedForbb0 -> nestedForbb8;
+		nestedForbb13	[label="13|{13:	 // label|14:	 // line number information|15:	ICONST_0 |16:	ISTORE 4}"];
+		nestedForbb8 -> nestedForbb13;
+		nestedForbb37	[label="37|{37:	 // label|38:	 // line number information|39:	 // stack frame map|40:	ILOAD 2|41:	IRETURN }"];
+		nestedForbb8 -> nestedForbb37	[label=T];
+		nestedForbb17	[label="17|{17:	 // label|18:	 // stack frame map|19:	ILOAD 4|20:	ILOAD 3|21:	IF_ICMPGE 32}"];
+		nestedForbb13 -> nestedForbb17;
+		nestedForbb22	[label="22|{22:	 // label|23:	 // line number information|24:	ILOAD 2|25:	ILOAD 4|26:	IADD |27:	ISTORE 2|28:	 // label|29:	 // line number \
+information|30:	IINC 4 1|31:	GOTO 17}"];
+		nestedForbb17 -> nestedForbb22;
+		nestedForbb32	[label="32|{32:	 // label|33:	 // line number information|34:	 // stack frame map|35:	IINC 3 1|36:	GOTO 8}"];
+		nestedForbb17 -> nestedForbb32	[label=T];
+		nestedForbb22 -> nestedForbb17	[label=T];
+		nestedForbb32 -> nestedForbb8	[label=T];
+		nestedForbb37 -> "nestedForbb-2";
+	}
+	subgraph nonShortCircuitMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"nonShortCircuitMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=nonShortCircuitMethod];
+		nonShortCircuitMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ILOAD 1|3:	ILOAD 2|4:	IF_ICMPLE 7}"];
+		"nonShortCircuitMethodbb-1" -> nonShortCircuitMethodbb0;
+		"nonShortCircuitMethodbb-2"	[label=x,
+			shape=circle];
+		nonShortCircuitMethodbb5	[label="5|{5:	ICONST_1 |6:	GOTO 10}"];
+		nonShortCircuitMethodbb0 -> nonShortCircuitMethodbb5;
+		nonShortCircuitMethodbb7	[label="7|{7:	 // label|8:	 // stack frame map|9:	ICONST_0 }"];
+		nonShortCircuitMethodbb0 -> nonShortCircuitMethodbb7	[label=T];
+		nonShortCircuitMethodbb10	[label="10|{10:	 // label|11:	 // stack frame map|12:	ILOAD 1|13:	ILOAD 3|14:	IF_ICMPGE 17}"];
+		nonShortCircuitMethodbb5 -> nonShortCircuitMethodbb10	[label=T];
+		nonShortCircuitMethodbb7 -> nonShortCircuitMethodbb10;
+		nonShortCircuitMethodbb15	[label="15|{15:	ICONST_1 |16:	GOTO 20}"];
+		nonShortCircuitMethodbb10 -> nonShortCircuitMethodbb15;
+		nonShortCircuitMethodbb17	[label="17|{17:	 // label|18:	 // stack frame map|19:	ICONST_0 }"];
+		nonShortCircuitMethodbb10 -> nonShortCircuitMethodbb17	[label=T];
+		nonShortCircuitMethodbb20	[label="20|{20:	 // label|21:	 // stack frame map|22:	IAND |23:	IFEQ 28}"];
+		nonShortCircuitMethodbb15 -> nonShortCircuitMethodbb20	[label=T];
+		nonShortCircuitMethodbb17 -> nonShortCircuitMethodbb20;
+		nonShortCircuitMethodbb24	[label="24|{24:	 // label|25:	 // line number information|26:	ICONST_1 |27:	IRETURN }"];
+		nonShortCircuitMethodbb20 -> nonShortCircuitMethodbb24;
+		nonShortCircuitMethodbb28	[label="28|{28:	 // label|29:	 // line number information|30:	 // stack frame map|31:	ICONST_0 |32:	IRETURN }"];
+		nonShortCircuitMethodbb20 -> nonShortCircuitMethodbb28	[label=T];
+		nonShortCircuitMethodbb24 -> "nonShortCircuitMethodbb-2";
+		nonShortCircuitMethodbb24 -> nonShortCircuitMethodbb28;
+		nonShortCircuitMethodbb28 -> "nonShortCircuitMethodbb-2";
+	}
+	subgraph shortCircuitMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"shortCircuitMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=shortCircuitMethod];
+		shortCircuitMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ILOAD 1|3:	ILOAD 2|4:	IF_ICMPLE 12}"];
+		"shortCircuitMethodbb-1" -> shortCircuitMethodbb0;
+		"shortCircuitMethodbb-2"	[label=x,
+			shape=circle];
+		shortCircuitMethodbb5	[label="5|{5:	ILOAD 1|6:	ILOAD 3|7:	IF_ICMPGE 12}"];
+		shortCircuitMethodbb0 -> shortCircuitMethodbb5;
+		shortCircuitMethodbb12	[label="12|{12:	 // label|13:	 // line number information|14:	 // stack frame map|15:	ICONST_0 |16:	IRETURN }"];
+		shortCircuitMethodbb0 -> shortCircuitMethodbb12	[label=T];
+		shortCircuitMethodbb8	[label="8|{8:	 // label|9:	 // line number information|10:	ICONST_1 |11:	IRETURN }"];
+		shortCircuitMethodbb5 -> shortCircuitMethodbb8;
+		shortCircuitMethodbb5 -> shortCircuitMethodbb12	[label=T];
+		shortCircuitMethodbb8 -> "shortCircuitMethodbb-2";
+		shortCircuitMethodbb8 -> shortCircuitMethodbb12;
+		shortCircuitMethodbb12 -> "shortCircuitMethodbb-2";
+	}
+	subgraph staticCallMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"staticCallMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=staticCallMethod];
+		staticCallMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	INVOKESTATIC ExampleClass.staticCallTarget ()V|3:	 // label|4:	 // line number \
+information|5:	ICONST_2 |6:	IRETURN }"];
+		"staticCallMethodbb-1" -> staticCallMethodbb0;
+		"staticCallMethodbb-2"	[label=x,
+			shape=circle];
+		staticCallMethodbb0 -> "staticCallMethodbb-2";
+	}
+	subgraph staticCallTarget {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"staticCallTargetbb-1"	[label=e,
+			shape=circle,
+			xlabel=staticCallTarget];
+		staticCallTargetbb0	[label="0|{0:	 // label|1:	 // line number information|2:	RETURN }"];
+		"staticCallTargetbb-1" -> staticCallTargetbb0;
+		"staticCallTargetbb-2"	[label=x,
+			shape=circle];
+		staticCallTargetbb0 -> "staticCallTargetbb-2";
+	}
+	subgraph staticFieldReadMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"staticFieldReadMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=staticFieldReadMethod];
+		staticFieldReadMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	GETSTATIC ExampleClass.staticField Ljava/lang/String;|3:	ARETURN }"];
+		"staticFieldReadMethodbb-1" -> staticFieldReadMethodbb0;
+		"staticFieldReadMethodbb-2"	[label=x,
+			shape=circle];
+		staticFieldReadMethodbb0 -> "staticFieldReadMethodbb-2";
+	}
+	subgraph staticFieldWriteMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"staticFieldWriteMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=staticFieldWriteMethod];
+		staticFieldWriteMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	PUTSTATIC ExampleClass.staticField Ljava/lang/String;|4:	 // label|\
+5:	 // line number information|6:	RETURN }"];
+		"staticFieldWriteMethodbb-1" -> staticFieldWriteMethodbb0;
+		"staticFieldWriteMethodbb-2"	[label=x,
+			shape=circle];
+		staticFieldWriteMethodbb0 -> "staticFieldWriteMethodbb-2";
+	}
+	subgraph switchMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"switchMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=switchMethod];
+		switchMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ILOAD 1|7:	\
+TABLESWITCH 0: 8, 1: 14, 2: 20, default: 26}"];
+		"switchMethodbb-1" -> switchMethodbb0;
+		"switchMethodbb-2"	[label=x,
+			shape=circle];
+		switchMethodbb8	[label="8|{8:	 // label|9:	 // line number information|10:	 // stack frame map|11:	ICONST_0 |12:	ISTORE 2|13:	GOTO 31}"];
+		switchMethodbb0 -> switchMethodbb8	[label=0];
+		switchMethodbb14	[label="14|{14:	 // label|15:	 // line number information|16:	 // stack frame map|17:	ICONST_1 |18:	ISTORE 2|19:	GOTO 31}"];
+		switchMethodbb0 -> switchMethodbb14	[label=1];
+		switchMethodbb20	[label="20|{20:	 // label|21:	 // line number information|22:	 // stack frame map|23:	ICONST_2 |24:	ISTORE 2|25:	GOTO 31}"];
+		switchMethodbb0 -> switchMethodbb20	[label=2];
+		switchMethodbb26	[label="26|{26:	 // label|27:	 // line number information|28:	 // stack frame map|29:	ICONST_M1 |30:	ISTORE 2}"];
+		switchMethodbb0 -> switchMethodbb26	[label=default];
+		switchMethodbb31	[label="31|{31:	 // label|32:	 // line number information|33:	 // stack frame map|34:	ILOAD 2|35:	IRETURN }"];
+		switchMethodbb8 -> switchMethodbb31	[label=T];
+		switchMethodbb14 -> switchMethodbb31	[label=T];
+		switchMethodbb20 -> switchMethodbb31	[label=T];
+		switchMethodbb26 -> switchMethodbb31;
+		switchMethodbb31 -> "switchMethodbb-2";
+	}
+	subgraph switchMethod2 {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"switchMethod2bb-1"	[label=e,
+			shape=circle,
+			xlabel=switchMethod2];
+		switchMethod2bb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ILOAD 1|7:	\
+LOOKUPSWITCH 0: 8, 1000: 14, 2000: 20, default: 26}"];
+		"switchMethod2bb-1" -> switchMethod2bb0;
+		"switchMethod2bb-2"	[label=x,
+			shape=circle];
+		switchMethod2bb8	[label="8|{8:	 // label|9:	 // line number information|10:	 // stack frame map|11:	ICONST_0 |12:	ISTORE 2|13:	GOTO 31}"];
+		switchMethod2bb0 -> switchMethod2bb8	[label=0];
+		switchMethod2bb14	[label="14|{14:	 // label|15:	 // line number information|16:	 // stack frame map|17:	ICONST_1 |18:	ISTORE 2|19:	GOTO 31}"];
+		switchMethod2bb0 -> switchMethod2bb14	[label=1000];
+		switchMethod2bb20	[label="20|{20:	 // label|21:	 // line number information|22:	 // stack frame map|23:	ICONST_2 |24:	ISTORE 2|25:	GOTO 31}"];
+		switchMethod2bb0 -> switchMethod2bb20	[label=2000];
+		switchMethod2bb26	[label="26|{26:	 // label|27:	 // line number information|28:	 // stack frame map|29:	ICONST_M1 |30:	ISTORE 2}"];
+		switchMethod2bb0 -> switchMethod2bb26	[label=default];
+		switchMethod2bb31	[label="31|{31:	 // label|32:	 // line number information|33:	 // stack frame map|34:	ILOAD 2|35:	IRETURN }"];
+		switchMethod2bb8 -> switchMethod2bb31	[label=T];
+		switchMethod2bb14 -> switchMethod2bb31	[label=T];
+		switchMethod2bb20 -> switchMethod2bb31	[label=T];
+		switchMethod2bb26 -> switchMethod2bb31;
+		switchMethod2bb31 -> "switchMethod2bb-2";
+	}
+	subgraph whileMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"whileMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=whileMethod];
+		whileMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2}"];
+		"whileMethodbb-1" -> whileMethodbb0;
+		"whileMethodbb-2"	[label=x,
+			shape=circle];
+		whileMethodbb4	[label="4|{4:	 // label|5:	 // line number information|6:	 // stack frame map|7:	ILOAD 1|8:	IFLE 19}"];
+		whileMethodbb0 -> whileMethodbb4;
+		whileMethodbb9	[label="9|{9:	 // label|10:	 // line number information|11:	ILOAD 2|12:	ILOAD 1|13:	IADD |14:	ISTORE 2|15:	 // label|16:	 // line number \
+information|17:	IINC 1 -1|18:	GOTO 4}"];
+		whileMethodbb4 -> whileMethodbb9;
+		whileMethodbb19	[label="19|{19:	 // label|20:	 // line number information|21:	 // stack frame map|22:	ILOAD 2|23:	IRETURN }"];
+		whileMethodbb4 -> whileMethodbb19	[label=T];
+		whileMethodbb9 -> whileMethodbb4	[label=T];
+		whileMethodbb19 -> "whileMethodbb-2";
+	}
+	subgraph whileTrueMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"whileTrueMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=whileTrueMethod];
+		whileTrueMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	 // stack frame map|3:	IINC 1 1|4:	GOTO 0}"];
+		"whileTrueMethodbb-1" -> whileTrueMethodbb0;
+		"whileTrueMethodbb-2"	[label=e,
+			shape=circle,
+			xlabel=whileTrueMethod];
+		whileTrueMethodbb0 -> whileTrueMethodbb0	[label=T];
+	}
+	subgraph alloc2Of3dArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"alloc2Of3dArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=alloc2Of3dArrayMethod];
+		alloc2Of3dArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ICONST_3 |4:	MULTIANEWARRAY [[[I 2|5:	ARETURN }"];
+		"alloc2Of3dArrayMethodbb-1" -> alloc2Of3dArrayMethodbb0;
+		"alloc2Of3dArrayMethodbb-2"	[label=x,
+			shape=circle];
+		alloc2Of3dArrayMethodbb0 -> "alloc2Of3dArrayMethodbb-2";
+	}
+	subgraph alloc2dArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"alloc2dArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=alloc2dArrayMethod];
+		alloc2dArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ICONST_3 |4:	MULTIANEWARRAY [[I 2|5:	ARETURN }"];
+		"alloc2dArrayMethodbb-1" -> alloc2dArrayMethodbb0;
+		"alloc2dArrayMethodbb-2"	[label=x,
+			shape=circle];
+		alloc2dArrayMethodbb0 -> "alloc2dArrayMethodbb-2";
+	}
+	subgraph allocIntArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocIntArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocIntArrayMethod];
+		allocIntArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_3 |3:	NEWARRAY T_INT|4:	ARETURN }"];
+		"allocIntArrayMethodbb-1" -> allocIntArrayMethodbb0;
+		"allocIntArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocIntArrayMethodbb0 -> "allocIntArrayMethodbb-2";
+	}
+	subgraph allocObjectArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocObjectArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocObjectArrayMethod];
+		allocObjectArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_3 |3:	ANEWARRAY java/lang/Object|4:	ARETURN }"];
+		"allocObjectArrayMethodbb-1" -> allocObjectArrayMethodbb0;
+		"allocObjectArrayMethodbb-2"	[label=x,
+			shape=circle];
+		allocObjectArrayMethodbb0 -> "allocObjectArrayMethodbb-2";
+	}
+	subgraph allocObjectMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"allocObjectMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=allocObjectMethod];
+		allocObjectMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	NEW java/lang/Object|3:	DUP |4:	INVOKESPECIAL java/lang/Object.<init> ()V|5:	ARETURN }"];
+		"allocObjectMethodbb-1" -> allocObjectMethodbb0;
+		"allocObjectMethodbb-2"	[label=x,
+			shape=circle];
+		allocObjectMethodbb0 -> "allocObjectMethodbb-2";
+	}
+	subgraph arrayLengthMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"arrayLengthMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=arrayLengthMethod];
+		arrayLengthMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ARRAYLENGTH |4:	IRETURN }"];
+		"arrayLengthMethodbb-1" -> arrayLengthMethodbb0;
+		"arrayLengthMethodbb-2"	[label=x,
+			shape=circle];
+		arrayLengthMethodbb0 -> "arrayLengthMethodbb-2";
+	}
+	subgraph arrayReadMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"arrayReadMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=arrayReadMethod];
+		arrayReadMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ICONST_0 |4:	AALOAD |5:	ARETURN }"];
+		"arrayReadMethodbb-1" -> arrayReadMethodbb0;
+		"arrayReadMethodbb-2"	[label=x,
+			shape=circle];
+		arrayReadMethodbb0 -> "arrayReadMethodbb-2";
+	}
+	subgraph arrayWriteMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"arrayWriteMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=arrayWriteMethod];
+		arrayWriteMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ICONST_0 |4:	ALOAD 2|5:	AASTORE |6:	 // label|7:	 // line number information|\
+8:	RETURN }"];
+		"arrayWriteMethodbb-1" -> arrayWriteMethodbb0;
+		"arrayWriteMethodbb-2"	[label=x,
+			shape=circle];
+		arrayWriteMethodbb0 -> "arrayWriteMethodbb-2";
+	}
+	subgraph condMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"condMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=condMethod];
+		condMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ILOAD 1|3:	ILOAD 2|4:	IF_ICMPLE 7}"];
+		"condMethodbb-1" -> condMethodbb0;
+		"condMethodbb-2"	[label=x,
+			shape=circle];
+		condMethodbb5	[label="5|{5:	ILOAD 1|6:	GOTO 10}"];
+		condMethodbb0 -> condMethodbb5;
+		condMethodbb7	[label="7|{7:	 // label|8:	 // stack frame map|9:	ILOAD 2}"];
+		condMethodbb0 -> condMethodbb7	[label=T];
+		condMethodbb10	[label="10|{10:	 // label|11:	 // stack frame map|12:	IRETURN }"];
+		condMethodbb5 -> condMethodbb10	[label=T];
+		condMethodbb7 -> condMethodbb10;
+		condMethodbb10 -> "condMethodbb-2";
+	}
+	subgraph doWhileMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"doWhileMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=doWhileMethod];
+		doWhileMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2}"];
+		"doWhileMethodbb-1" -> doWhileMethodbb0;
+		"doWhileMethodbb-2"	[label=x,
+			shape=circle];
+		doWhileMethodbb4	[label="4|{4:	 // label|5:	 // line number information|6:	 // stack frame map|7:	ILOAD 2|8:	ILOAD 1|9:	IADD |10:	ISTORE 2|11:	 // label|\
+12:	 // line number information|13:	IINC 1 -1|14:	 // label|15:	 // line number information|16:	ILOAD 1|17:	IFGT 4}"];
+		doWhileMethodbb0 -> doWhileMethodbb4;
+		doWhileMethodbb4 -> doWhileMethodbb4	[label=T];
+		doWhileMethodbb18	[label="18|{18:	 // label|19:	 // line number information|20:	ILOAD 2|21:	IRETURN }"];
+		doWhileMethodbb4 -> doWhileMethodbb18;
+		doWhileMethodbb18 -> "doWhileMethodbb-2";
+	}
+	subgraph doWhileTrue {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"doWhileTruebb-1"	[label=e,
+			shape=circle,
+			xlabel=doWhileTrue];
+		doWhileTruebb0	[label="0|{0:	 // label|1:	 // line number information|2:	 // stack frame map|3:	IINC 1 1|4:	 // label|5:	 // line number information|6:	\
+GOTO 0}"];
+		"doWhileTruebb-1" -> doWhileTruebb0;
+		"doWhileTruebb-2"	[label=e,
+			shape=circle,
+			xlabel=doWhileTrue];
+		doWhileTruebb0 -> doWhileTruebb0	[label=T];
+	}
+	subgraph emptyMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"emptyMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=emptyMethod];
+		emptyMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	RETURN }"];
+		"emptyMethodbb-1" -> emptyMethodbb0;
+		"emptyMethodbb-2"	[label=x,
+			shape=circle];
+		emptyMethodbb0 -> "emptyMethodbb-2";
+	}
+	subgraph fieldReadMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"fieldReadMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=fieldReadMethod];
+		fieldReadMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	GETFIELD ExampleClass.field Ljava/lang/String;|4:	ARETURN }"];
+		"fieldReadMethodbb-1" -> fieldReadMethodbb0;
+		"fieldReadMethodbb-2"	[label=x,
+			shape=circle];
+		fieldReadMethodbb0 -> "fieldReadMethodbb-2";
+	}
+	subgraph fieldWriteMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"fieldWriteMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=fieldWriteMethod];
+		fieldWriteMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	ALOAD 1|4:	PUTFIELD ExampleClass.field Ljava/lang/String;|5:	 // label|\
+6:	 // line number information|7:	RETURN }"];
+		"fieldWriteMethodbb-1" -> fieldWriteMethodbb0;
+		"fieldWriteMethodbb-2"	[label=x,
+			shape=circle];
+		fieldWriteMethodbb0 -> "fieldWriteMethodbb-2";
+	}
+	subgraph forEachArrayMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forEachArrayMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=forEachArrayMethod];
+		forEachArrayMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ALOAD 1|7:	\
+ASTORE 3|8:	ALOAD 3|9:	ARRAYLENGTH |10:	ISTORE 4|11:	ICONST_0 |12:	ISTORE 5}"];
+		"forEachArrayMethodbb-1" -> forEachArrayMethodbb0;
+		"forEachArrayMethodbb-2"	[label=x,
+			shape=circle];
+		forEachArrayMethodbb13	[label="13|{13:	 // label|14:	 // stack frame map|15:	ILOAD 5|16:	ILOAD 4|17:	IF_ICMPGE 29}"];
+		forEachArrayMethodbb0 -> forEachArrayMethodbb13;
+		forEachArrayMethodbb18	[label="18|{18:	ALOAD 3|19:	ILOAD 5|20:	AALOAD |21:	ASTORE 6|22:	 // label|23:	 // line number information|24:	IINC 2 1|25:	 // label|26:	 // \
+line number information|27:	IINC 5 1|28:	GOTO 13}"];
+		forEachArrayMethodbb13 -> forEachArrayMethodbb18;
+		forEachArrayMethodbb29	[label="29|{29:	 // label|30:	 // line number information|31:	 // stack frame map|32:	ILOAD 2|33:	IRETURN }"];
+		forEachArrayMethodbb13 -> forEachArrayMethodbb29	[label=T];
+		forEachArrayMethodbb18 -> forEachArrayMethodbb13	[label=T];
+		forEachArrayMethodbb29 -> "forEachArrayMethodbb-2";
+	}
+	subgraph forEachCollectionMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forEachCollectionMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=forEachCollectionMethod];
+		forEachCollectionMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ALOAD 1|7:	\
+INVOKEINTERFACE java/util/Set.iterator ()Ljava/util/Iterator;|8:	ASTORE 3}"];
+		"forEachCollectionMethodbb-1" -> forEachCollectionMethodbb0;
+		"forEachCollectionMethodbb-2"	[label=x,
+			shape=circle];
+		forEachCollectionMethodbb9	[label="9|{9:	 // label|10:	 // stack frame map|11:	ALOAD 3|12:	INVOKEINTERFACE java/util/Iterator.hasNext ()Z|13:	IFEQ 24}"];
+		forEachCollectionMethodbb0 -> forEachCollectionMethodbb9;
+		forEachCollectionMethodbb14	[label="14|{14:	ALOAD 3|15:	INVOKEINTERFACE java/util/Iterator.next ()Ljava/lang/Object;|16:	CHECKCAST java/lang/String|17:	ASTORE 4|18:	 // \
+label|19:	 // line number information|20:	IINC 2 1|21:	 // label|22:	 // line number information|23:	GOTO 9}"];
+		forEachCollectionMethodbb9 -> forEachCollectionMethodbb14;
+		forEachCollectionMethodbb24	[label="24|{24:	 // label|25:	 // line number information|26:	 // stack frame map|27:	ILOAD 2|28:	IRETURN }"];
+		forEachCollectionMethodbb9 -> forEachCollectionMethodbb24	[label=T];
+		forEachCollectionMethodbb14 -> forEachCollectionMethodbb9	[label=T];
+		forEachCollectionMethodbb24 -> "forEachCollectionMethodbb-2";
+	}
+	subgraph ifMethod {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"ifMethodbb-1"	[label=e,
+			shape=circle,
+			xlabel=ifMethod];
+		ifMethodbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ILOAD 1|7:	\
+IFGE 12}"];
+		"ifMethodbb-1" -> ifMethodbb0;
+		"ifMethodbb-2"	[label=x,
+			shape=circle];
+		ifMethodbb8	[label="8|{8:	 // label|9:	 // line number information|10:	ICONST_1 |11:	ISTORE 2}"];
+		ifMethodbb0 -> ifMethodbb8;
+		ifMethodbb12	[label="12|{12:	 // label|13:	 // line number information|14:	 // stack frame map|15:	ILOAD 2|16:	IRETURN }"];
+		ifMethodbb0 -> ifMethodbb12	[label=T];
+		ifMethodbb8 -> ifMethodbb12;
+		ifMethodbb12 -> "ifMethodbb-2";
+	}
+	subgraph init {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		"initbb-1"	[label=e,
+			shape=circle,
+			xlabel=init];
+		initbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	INVOKESPECIAL java/lang/Object.<init> ()V|4:	RETURN }"];
+		"initbb-1" -> initbb0;
+		"initbb-2"	[label=x,
+			shape=circle];
+		initbb0 -> "initbb-2";
+	}
+	subgraph forEver {
+		node [label="\N",
+			shape=record,
+			xlabel=""
+		];
+		edge [label=""];
+		"forEverbb-1"	[label=e,
+			shape=circle,
+			xlabel=forEver];
+		forEverbb0	[label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2}"];
+		"forEverbb-1" -> forEverbb0;
+		"forEverbb-2"	[label=e,
+			shape=circle,
+			xlabel=forEver];
+		forEverbb4	[label="4|{4:	 // label|5:	 // stack frame map|6:	IINC 2 1|7:	GOTO 4}"];
+		forEverbb0 -> forEverbb4;
+		forEverbb4 -> forEverbb4	[label=T];
+	}
+}

test-output/all.dt.dot

@@ -0,0 +1,448 @@
+digraph root {
+	node [label="\N"];
+	subgraph dominatorTree_gv5 {
+		graph [label=allocAndInitObjectArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv5"	[style=filled];
+		"D(-1)_gv5" -> "D(0)_gv5";
+		"D(0)_gv5" -> "D(-2)_gv5";
+	}
+	subgraph dominatorTree_gv6 {
+		graph [label=allocIncomplete2dArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv6"	[style=filled];
+		"D(-1)_gv6" -> "D(0)_gv6";
+		"D(0)_gv6" -> "D(-2)_gv6";
+	}
+	subgraph dominatorTree_gv7 {
+		graph [label=allocIntArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv7"	[style=filled];
+		"D(-1)_gv7" -> "D(0)_gv7";
+		"D(0)_gv7" -> "D(-2)_gv7";
+	}
+	subgraph dominatorTree_gv8 {
+		graph [label=allocObjectArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv8"	[style=filled];
+		"D(-1)_gv8" -> "D(0)_gv8";
+		"D(0)_gv8" -> "D(-2)_gv8";
+	}
+	subgraph dominatorTree_gv9 {
+		graph [label=allocObjectMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv9"	[style=filled];
+		"D(-1)_gv9" -> "D(0)_gv9";
+		"D(0)_gv9" -> "D(-2)_gv9";
+	}
+	subgraph dominatorTree_gv10 {
+		graph [label=arrayLengthMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv10"	[style=filled];
+		"D(-1)_gv10" -> "D(0)_gv10";
+		"D(0)_gv10" -> "D(-2)_gv10";
+	}
+	subgraph dominatorTree_gv11 {
+		graph [label=arrayReadMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv11"	[style=filled];
+		"D(-1)_gv11" -> "D(0)_gv11";
+		"D(0)_gv11" -> "D(-2)_gv11";
+	}
+	subgraph dominatorTree_gv12 {
+		graph [label=arrayWriteMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv12"	[style=filled];
+		"D(-1)_gv12" -> "D(0)_gv12";
+		"D(0)_gv12" -> "D(-2)_gv12";
+	}
+	subgraph dominatorTree_gv13 {
+		graph [label=condMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv13"	[style=filled];
+		"D(-1)_gv13" -> "D(0)_gv13";
+		"D(0)_gv13" -> "D(7)";
+		"D(0)_gv13" -> "D(10)";
+		"D(0)_gv13" -> "D(5)";
+		"D(10)" -> "D(-2)_gv13";
+	}
+	subgraph dominatorTree_gv14 {
+		graph [label=doWhileMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv14"	[style=filled];
+		"D(-1)_gv14" -> "D(0)_gv14";
+		"D(0)_gv14" -> "D(4)";
+		"D(18)" -> "D(-2)_gv14";
+		"D(4)" -> "D(18)";
+	}
+	subgraph dominatorTree_gv15 {
+		graph [label=doWhileTrue];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv15"	[style=filled];
+		"D(-1)_gv15" -> "D(0)_gv15";
+	}
+	subgraph dominatorTree_gv16 {
+		graph [label=emptyMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv16"	[style=filled];
+		"D(-1)_gv16" -> "D(0)_gv16";
+		"D(0)_gv16" -> "D(-2)_gv15";
+	}
+	subgraph dominatorTree_gv17 {
+		graph [label=fieldReadMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv17"	[style=filled];
+		"D(-1)_gv17" -> "D(0)_gv17";
+		"D(0)_gv17" -> "D(-2)_gv16";
+	}
+	subgraph dominatorTree_gv18 {
+		graph [label=fieldWriteMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv18"	[style=filled];
+		"D(-1)_gv18" -> "D(0)_gv18";
+		"D(0)_gv18" -> "D(-2)_gv17";
+	}
+	subgraph dominatorTree_gv19 {
+		graph [label=forEachArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv19"	[style=filled];
+		"D(-1)_gv19" -> "D(0)_gv19";
+		"D(13)" -> "D(29)";
+		"D(13)" -> "D(18)_gv1";
+		"D(29)" -> "D(-2)_gv18";
+		"D(0)_gv19" -> "D(13)";
+	}
+	subgraph dominatorTree_gv20 {
+		graph [label=forEachCollectionMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv20"	[style=filled];
+		"D(-1)_gv20" -> "D(0)_gv20";
+		"D(9)" -> "D(14)";
+		"D(9)" -> "D(24)";
+		"D(0)_gv20" -> "D(9)";
+		"D(24)" -> "D(-2)_gv19";
+	}
+	subgraph dominatorTree_gv21 {
+		graph [label=forEver];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv21"	[style=filled];
+		"D(-1)_gv21" -> "D(0)_gv21";
+		"D(0)_gv21" -> "D(4)_gv1";
+	}
+	subgraph dominatorTree_gv22 {
+		graph [label=forMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv22"	[style=filled];
+		"D(-1)_gv22" -> "D(0)_gv22";
+		"D(0)_gv22" -> "D(8)";
+		"D(8)" -> "D(23)";
+		"D(8)" -> "D(13)_gv1";
+		"D(23)" -> "D(-2)_gv20";
+	}
+	subgraph dominatorTree_gv23 {
+		graph [label=forWithBreakMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv23"	[style=filled];
+		"D(-1)_gv23" -> "D(0)_gv23";
+		"D(0)_gv23" -> "D(8)_gv1";
+		"D(32)" -> "D(-2)_gv21";
+		"D(13)_gv2" -> "D(21)";
+		"D(13)_gv2" -> "D(18)_gv2";
+		"D(8)_gv1" -> "D(32)";
+		"D(8)_gv1" -> "D(13)_gv2";
+	}
+	subgraph dominatorTree_gv24 {
+		graph [label=forWithContinueMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv24"	[style=filled];
+		"D(-1)_gv24" -> "D(0)_gv24";
+		"D(33)" -> "D(-2)_gv22";
+		"D(8)_gv2" -> "D(33)";
+		"D(8)_gv2" -> "D(13)_gv3";
+		"D(13)_gv3" -> "D(21)_gv1";
+		"D(13)_gv3" -> "D(18)_gv3";
+		"D(13)_gv3" -> "D(28)";
+		"D(0)_gv24" -> "D(8)_gv2";
+	}
+	subgraph dominatorTree_gv25 {
+		graph [label=ifElseMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv25"	[style=filled];
+		"D(-1)_gv25" -> "D(0)_gv25";
+		"D(0)_gv25" -> "D(13)_gv4";
+		"D(0)_gv25" -> "D(18)_gv4";
+		"D(0)_gv25" -> "D(8)_gv3";
+		"D(18)_gv4" -> "D(-2)_gv23";
+	}
+	subgraph dominatorTree_gv26 {
+		graph [label=ifMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv26"	[style=filled];
+		"D(-1)_gv26" -> "D(0)_gv26";
+		"D(0)_gv26" -> "D(8)_gv4";
+		"D(0)_gv26" -> "D(12)";
+		"D(12)" -> "D(-2)_gv24";
+	}
+	subgraph dominatorTree_gv27 {
+		graph [label=instanceCallMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv27"	[style=filled];
+		"D(-1)_gv27" -> "D(0)_gv27";
+		"D(0)_gv27" -> "D(-2)_gv25";
+	}
+	subgraph dominatorTree_gv28 {
+		graph [label=instanceCallTarget];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv28"	[style=filled];
+		"D(-1)_gv28" -> "D(0)_gv28";
+		"D(0)_gv28" -> "D(-2)_gv26";
+	}
+	subgraph dominatorTree_gv29 {
+		graph [label=interfaceCallMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv29"	[style=filled];
+		"D(-1)_gv29" -> "D(0)_gv29";
+		"D(0)_gv29" -> "D(-2)_gv27";
+	}
+	subgraph dominatorTree_gv30 {
+		graph [label=nestedFor];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv30"	[style=filled];
+		"D(-1)_gv30" -> "D(0)_gv30";
+		"D(17)" -> "D(32)_gv1";
+		"D(17)" -> "D(22)";
+		"D(0)_gv30" -> "D(8)_gv5";
+		"D(8)_gv5" -> "D(13)_gv5";
+		"D(8)_gv5" -> "D(37)";
+		"D(13)_gv5" -> "D(17)";
+		"D(37)" -> "D(-2)_gv28";
+	}
+	subgraph dominatorTree_gv31 {
+		graph [label=nonShortCircuitMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv31"	[style=filled];
+		"D(-1)_gv31" -> "D(0)_gv31";
+		"D(10)_gv1" -> "D(20)";
+		"D(10)_gv1" -> "D(17)_gv1";
+		"D(10)_gv1" -> "D(15)";
+		"D(20)" -> "D(-2)_gv29";
+		"D(20)" -> "D(28)_gv1";
+		"D(20)" -> "D(24)_gv1";
+		"D(0)_gv31" -> "D(10)_gv1";
+		"D(0)_gv31" -> "D(7)_gv1";
+		"D(0)_gv31" -> "D(5)_gv1";
+	}
+	subgraph dominatorTree_gv32 {
+		graph [label=privateInstanceCallMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv32"	[style=filled];
+		"D(-1)_gv32" -> "D(0)_gv32";
+		"D(0)_gv32" -> "D(-2)_gv30";
+	}
+	subgraph dominatorTree_gv33 {
+		graph [label=privateInstanceCallTarget];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv33"	[style=filled];
+		"D(-1)_gv33" -> "D(0)_gv33";
+		"D(0)_gv33" -> "D(-2)_gv31";
+	}
+	subgraph dominatorTree_gv34 {
+		graph [label=shortCircuitMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv34"	[style=filled];
+		"D(-1)_gv34" -> "D(0)_gv34";
+		"D(0)_gv34" -> "D(5)_gv2";
+		"D(0)_gv34" -> "D(12)_gv1";
+		"D(0)_gv34" -> "D(-2)_gv32";
+		"D(5)_gv2" -> "D(8)_gv6";
+	}
+	subgraph dominatorTree_gv35 {
+		graph [label=staticCallMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv35"	[style=filled];
+		"D(-1)_gv35" -> "D(0)_gv35";
+		"D(0)_gv35" -> "D(-2)_gv33";
+	}
+	subgraph dominatorTree_gv36 {
+		graph [label=staticCallTarget];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv36"	[style=filled];
+		"D(-1)_gv36" -> "D(0)_gv36";
+		"D(0)_gv36" -> "D(-2)_gv34";
+	}
+	subgraph dominatorTree_gv37 {
+		graph [label=staticFieldReadMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv37"	[style=filled];
+		"D(-1)_gv37" -> "D(0)_gv37";
+		"D(0)_gv37" -> "D(-2)_gv35";
+	}
+	subgraph dominatorTree_gv38 {
+		graph [label=staticFieldWriteMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv38"	[style=filled];
+		"D(-1)_gv38" -> "D(0)_gv38";
+		"D(0)_gv38" -> "D(-2)_gv36";
+	}
+	subgraph dominatorTree_gv39 {
+		graph [label=switchMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv39"	[style=filled];
+		"D(-1)_gv39" -> "D(0)_gv39";
+		"D(31)" -> "D(-2)_gv37";
+		"D(0)_gv39" -> "D(31)";
+		"D(0)_gv39" -> "D(26)";
+		"D(0)_gv39" -> "D(8)_gv7";
+		"D(0)_gv39" -> "D(20)_gv1";
+		"D(0)_gv39" -> "D(14)_gv1";
+	}
+	subgraph dominatorTree_gv40 {
+		graph [label=switchMethod2];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv40"	[style=filled];
+		"D(-1)_gv40" -> "D(0)_gv40";
+		"D(0)_gv40" -> "D(31)_gv1";
+		"D(0)_gv40" -> "D(8)_gv8";
+		"D(0)_gv40" -> "D(14)_gv2";
+		"D(0)_gv40" -> "D(20)_gv2";
+		"D(0)_gv40" -> "D(26)_gv1";
+		"D(31)_gv1" -> "D(-2)_gv38";
+	}
+	subgraph dominatorTree_gv41 {
+		graph [label=whileMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv41"	[style=filled];
+		"D(-1)_gv41" -> "D(0)_gv41";
+		"D(0)_gv41" -> "D(4)_gv2";
+		"D(4)_gv2" -> "D(19)";
+		"D(4)_gv2" -> "D(9)_gv1";
+		"D(19)" -> "D(-2)_gv39";
+	}
+	subgraph dominatorTree_gv42 {
+		graph [label=whileTrueMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv42"	[style=filled];
+		"D(-1)_gv42" -> "D(0)_gv42";
+	}
+	subgraph dominatorTree {
+		graph [label="<init>"];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)"	[style=filled];
+		"D(-1)" -> "D(0)";
+		"D(0)" -> "D(-2)";
+	}
+	subgraph dominatorTree_gv1 {
+		graph [label=alloc2Of3dArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv1"	[style=filled];
+		"D(-1)_gv1" -> "D(0)_gv1";
+		"D(0)_gv1" -> "D(-2)_gv1";
+	}
+	subgraph dominatorTree_gv2 {
+		graph [label=alloc2dArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv2"	[style=filled];
+		"D(-1)_gv2" -> "D(0)_gv2";
+		"D(0)_gv2" -> "D(-2)_gv2";
+	}
+	subgraph dominatorTree_gv3 {
+		graph [label=allocAndInit2dArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv3"	[style=filled];
+		"D(-1)_gv3" -> "D(0)_gv3";
+		"D(0)_gv3" -> "D(-2)_gv3";
+	}
+	subgraph dominatorTree_gv4 {
+		graph [label=allocAndInitIntArrayMethod];
+		node [label="\N",
+			style=""
+		];
+		"D(-1)_gv4"	[style=filled];
+		"D(-1)_gv4" -> "D(0)_gv4";
+		"D(0)_gv4" -> "D(-2)_gv4";
+	}
+}

test-output/alloc2Of3dArrayMethod.asm.txt

@@ -0,0 +1,7 @@
+  Method: alloc2Of3dArrayMethod()[[[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_2 
+  3:	ICONST_3 
+  4:	MULTIANEWARRAY [[[I 2
+  5:	ARETURN 

test-output/alloc2Of3dArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph alloc2Of3dArrayMethod {
+
+    node [shape=record]
+    "alloc2Of3dArrayMethodbb-1" [shape=circle,label="e",xlabel="alloc2Of3dArrayMethod"]
+    "alloc2Of3dArrayMethodbb-2" [shape=circle,label="x"]
+    "alloc2Of3dArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ICONST_3 |4:	MULTIANEWARRAY [[[I 2|5:	ARETURN }"]
+
+    "alloc2Of3dArrayMethodbb-1" -> "alloc2Of3dArrayMethodbb0"
+    "alloc2Of3dArrayMethodbb0" -> "alloc2Of3dArrayMethodbb-2"
+}

test-output/alloc2Of3dArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="alloc2Of3dArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_2 \l|3:	ICONST_3 \l|4:	MULTIANEWARRAY [[[I 2\l|5:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/alloc2Of3dArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="alloc2Of3dArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/alloc2dArrayMethod.asm.txt

@@ -0,0 +1,7 @@
+  Method: alloc2dArrayMethod()[[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_2 
+  3:	ICONST_3 
+  4:	MULTIANEWARRAY [[I 2
+  5:	ARETURN 

test-output/alloc2dArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph alloc2dArrayMethod {
+
+    node [shape=record]
+    "alloc2dArrayMethodbb-1" [shape=circle,label="e",xlabel="alloc2dArrayMethod"]
+    "alloc2dArrayMethodbb-2" [shape=circle,label="x"]
+    "alloc2dArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ICONST_3 |4:	MULTIANEWARRAY [[I 2|5:	ARETURN }"]
+
+    "alloc2dArrayMethodbb-1" -> "alloc2dArrayMethodbb0"
+    "alloc2dArrayMethodbb0" -> "alloc2dArrayMethodbb-2"
+}

test-output/alloc2dArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="alloc2dArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_2 \l|3:	ICONST_3 \l|4:	MULTIANEWARRAY [[I 2\l|5:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/alloc2dArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="alloc2dArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/allocAndInit2dArrayMethod.asm.txt

@@ -0,0 +1,15 @@
+  Method: allocAndInit2dArrayMethod()[[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_1 
+  3:	ANEWARRAY [I
+  4:	DUP 
+  5:	ICONST_0 
+  6:	ICONST_1 
+  7:	NEWARRAY T_INT
+  8:	DUP 
+  9:	ICONST_0 
+  10:	ICONST_1 
+  11:	IASTORE 
+  12:	AASTORE 
+  13:	ARETURN 

test-output/allocAndInit2dArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocAndInit2dArrayMethod {
+
+    node [shape=record]
+    "allocAndInit2dArrayMethodbb-1" [shape=circle,label="e",xlabel="allocAndInit2dArrayMethod"]
+    "allocAndInit2dArrayMethodbb-2" [shape=circle,label="x"]
+    "allocAndInit2dArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_1 |3:	ANEWARRAY [I|4:	DUP |5:	ICONST_0 |6:	ICONST_1 |7:	NEWARRAY T_INT|8:	DUP |9:	ICONST_0 |10:	ICONST_1 |11:	IASTORE |12:	AASTORE |13:	ARETURN }"]
+
+    "allocAndInit2dArrayMethodbb-1" -> "allocAndInit2dArrayMethodbb0"
+    "allocAndInit2dArrayMethodbb0" -> "allocAndInit2dArrayMethodbb-2"
+}

test-output/allocAndInit2dArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocAndInit2dArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_1 \l|3:	ANEWARRAY [I\l|4:	DUP \l|5:	ICONST_0 \l|6:	ICONST_1 \l|7:	NEWARRAY T_INT\l|8:	DUP \l|9:	ICONST_0 \l|10:	ICONST_1 \l|11:	IASTORE \l|12:	AASTORE \l|13:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/allocAndInit2dArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocAndInit2dArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/allocAndInitIntArrayMethod.asm.txt

@@ -0,0 +1,14 @@
+  Method: allocAndInitIntArrayMethod()[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_2 
+  3:	NEWARRAY T_INT
+  4:	DUP 
+  5:	ICONST_0 
+  6:	ICONST_1 
+  7:	IASTORE 
+  8:	DUP 
+  9:	ICONST_1 
+  10:	ICONST_2 
+  11:	IASTORE 
+  12:	ARETURN 

test-output/allocAndInitIntArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocAndInitIntArrayMethod {
+
+    node [shape=record]
+    "allocAndInitIntArrayMethodbb-1" [shape=circle,label="e",xlabel="allocAndInitIntArrayMethod"]
+    "allocAndInitIntArrayMethodbb-2" [shape=circle,label="x"]
+    "allocAndInitIntArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	NEWARRAY T_INT|4:	DUP |5:	ICONST_0 |6:	ICONST_1 |7:	IASTORE |8:	DUP |9:	ICONST_1 |10:	ICONST_2 |11:	IASTORE |12:	ARETURN }"]
+
+    "allocAndInitIntArrayMethodbb-1" -> "allocAndInitIntArrayMethodbb0"
+    "allocAndInitIntArrayMethodbb0" -> "allocAndInitIntArrayMethodbb-2"
+}

test-output/allocAndInitIntArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocAndInitIntArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_2 \l|3:	NEWARRAY T_INT\l|4:	DUP \l|5:	ICONST_0 \l|6:	ICONST_1 \l|7:	IASTORE \l|8:	DUP \l|9:	ICONST_1 \l|10:	ICONST_2 \l|11:	IASTORE \l|12:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/allocAndInitIntArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocAndInitIntArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/allocAndInitObjectArrayMethod.asm.txt

@@ -0,0 +1,14 @@
+  Method: allocAndInitObjectArrayMethod()[Ljava/lang/Object;
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_2 
+  3:	ANEWARRAY java/lang/Object
+  4:	DUP 
+  5:	ICONST_0 
+  6:	LDC 1
+  7:	AASTORE 
+  8:	DUP 
+  9:	ICONST_1 
+  10:	LDC 2
+  11:	AASTORE 
+  12:	ARETURN 

test-output/allocAndInitObjectArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocAndInitObjectArrayMethod {
+
+    node [shape=record]
+    "allocAndInitObjectArrayMethodbb-1" [shape=circle,label="e",xlabel="allocAndInitObjectArrayMethod"]
+    "allocAndInitObjectArrayMethodbb-2" [shape=circle,label="x"]
+    "allocAndInitObjectArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ANEWARRAY java/lang/Object|4:	DUP |5:	ICONST_0 |6:	LDC 1|7:	AASTORE |8:	DUP |9:	ICONST_1 |10:	LDC 2|11:	AASTORE |12:	ARETURN }"]
+
+    "allocAndInitObjectArrayMethodbb-1" -> "allocAndInitObjectArrayMethodbb0"
+    "allocAndInitObjectArrayMethodbb0" -> "allocAndInitObjectArrayMethodbb-2"
+}

test-output/allocAndInitObjectArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocAndInitObjectArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_2 \l|3:	ANEWARRAY java/lang/Object\l|4:	DUP \l|5:	ICONST_0 \l|6:	LDC 1\l|7:	AASTORE \l|8:	DUP \l|9:	ICONST_1 \l|10:	LDC 2\l|11:	AASTORE \l|12:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/allocAndInitObjectArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocAndInitObjectArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/allocIncomplete2dArrayMethod.asm.txt

@@ -0,0 +1,6 @@
+  Method: allocIncomplete2dArrayMethod()[[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_2 
+  3:	ANEWARRAY [I
+  4:	ARETURN 

test-output/allocIncomplete2dArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocIncomplete2dArrayMethod {
+
+    node [shape=record]
+    "allocIncomplete2dArrayMethodbb-1" [shape=circle,label="e",xlabel="allocIncomplete2dArrayMethod"]
+    "allocIncomplete2dArrayMethodbb-2" [shape=circle,label="x"]
+    "allocIncomplete2dArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_2 |3:	ANEWARRAY [I|4:	ARETURN }"]
+
+    "allocIncomplete2dArrayMethodbb-1" -> "allocIncomplete2dArrayMethodbb0"
+    "allocIncomplete2dArrayMethodbb0" -> "allocIncomplete2dArrayMethodbb-2"
+}

test-output/allocIncomplete2dArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocIncomplete2dArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_2 \l|3:	ANEWARRAY [I\l|4:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/allocIncomplete2dArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocIncomplete2dArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/allocIntArrayMethod.asm.txt

@@ -0,0 +1,6 @@
+  Method: allocIntArrayMethod()[I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_3 
+  3:	NEWARRAY T_INT
+  4:	ARETURN 

test-output/allocIntArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocIntArrayMethod {
+
+    node [shape=record]
+    "allocIntArrayMethodbb-1" [shape=circle,label="e",xlabel="allocIntArrayMethod"]
+    "allocIntArrayMethodbb-2" [shape=circle,label="x"]
+    "allocIntArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_3 |3:	NEWARRAY T_INT|4:	ARETURN }"]
+
+    "allocIntArrayMethodbb-1" -> "allocIntArrayMethodbb0"
+    "allocIntArrayMethodbb0" -> "allocIntArrayMethodbb-2"
+}

test-output/allocIntArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocIntArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_3 \l|3:	NEWARRAY T_INT\l|4:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/allocIntArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocIntArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/allocObjectArrayMethod.asm.txt

@@ -0,0 +1,6 @@
+  Method: allocObjectArrayMethod()[Ljava/lang/Object;
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_3 
+  3:	ANEWARRAY java/lang/Object
+  4:	ARETURN 

test-output/allocObjectArrayMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocObjectArrayMethod {
+
+    node [shape=record]
+    "allocObjectArrayMethodbb-1" [shape=circle,label="e",xlabel="allocObjectArrayMethod"]
+    "allocObjectArrayMethodbb-2" [shape=circle,label="x"]
+    "allocObjectArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_3 |3:	ANEWARRAY java/lang/Object|4:	ARETURN }"]
+
+    "allocObjectArrayMethodbb-1" -> "allocObjectArrayMethodbb0"
+    "allocObjectArrayMethodbb0" -> "allocObjectArrayMethodbb-2"
+}

test-output/allocObjectArrayMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocObjectArrayMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_3 \l|3:	ANEWARRAY java/lang/Object\l|4:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/allocObjectArrayMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocObjectArrayMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/allocObjectMethod.asm.txt

@@ -0,0 +1,7 @@
+  Method: allocObjectMethod()Ljava/lang/Object;
+  0:	 // label
+  1:	 // line number information
+  2:	NEW java/lang/Object
+  3:	DUP 
+  4:	INVOKESPECIAL java/lang/Object.<init> ()V
+  5:	ARETURN 

test-output/allocObjectMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph allocObjectMethod {
+
+    node [shape=record]
+    "allocObjectMethodbb-1" [shape=circle,label="e",xlabel="allocObjectMethod"]
+    "allocObjectMethodbb-2" [shape=circle,label="x"]
+    "allocObjectMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	NEW java/lang/Object|3:	DUP |4:	INVOKESPECIAL java/lang/Object.<init> ()V|5:	ARETURN }"]
+
+    "allocObjectMethodbb-1" -> "allocObjectMethodbb0"
+    "allocObjectMethodbb0" -> "allocObjectMethodbb-2"
+}

test-output/allocObjectMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="allocObjectMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	NEW java/lang/Object\l|3:	DUP \l|4:	INVOKESPECIAL java/lang/Object.<init> ()V\l|5:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/allocObjectMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="allocObjectMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/arrayLengthMethod.asm.txt

@@ -0,0 +1,6 @@
+  Method: arrayLengthMethod([Ljava/lang/String;)I
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 1
+  3:	ARRAYLENGTH 
+  4:	IRETURN 

test-output/arrayLengthMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph arrayLengthMethod {
+
+    node [shape=record]
+    "arrayLengthMethodbb-1" [shape=circle,label="e",xlabel="arrayLengthMethod"]
+    "arrayLengthMethodbb-2" [shape=circle,label="x"]
+    "arrayLengthMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ARRAYLENGTH |4:	IRETURN }"]
+
+    "arrayLengthMethodbb-1" -> "arrayLengthMethodbb0"
+    "arrayLengthMethodbb0" -> "arrayLengthMethodbb-2"
+}

test-output/arrayLengthMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="arrayLengthMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 1\l|3:	ARRAYLENGTH \l|4:	IRETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/arrayLengthMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="arrayLengthMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/arrayReadMethod.asm.txt

@@ -0,0 +1,7 @@
+  Method: arrayReadMethod([Ljava/lang/String;)Ljava/lang/String;
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 1
+  3:	ICONST_0 
+  4:	AALOAD 
+  5:	ARETURN 

test-output/arrayReadMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph arrayReadMethod {
+
+    node [shape=record]
+    "arrayReadMethodbb-1" [shape=circle,label="e",xlabel="arrayReadMethod"]
+    "arrayReadMethodbb-2" [shape=circle,label="x"]
+    "arrayReadMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ICONST_0 |4:	AALOAD |5:	ARETURN }"]
+
+    "arrayReadMethodbb-1" -> "arrayReadMethodbb0"
+    "arrayReadMethodbb0" -> "arrayReadMethodbb-2"
+}

test-output/arrayReadMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="arrayReadMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 1\l|3:	ICONST_0 \l|4:	AALOAD \l|5:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/arrayReadMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="arrayReadMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/arrayWriteMethod.asm.txt

@@ -0,0 +1,10 @@
+  Method: arrayWriteMethod([Ljava/lang/String;Ljava/lang/String;)V
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 1
+  3:	ICONST_0 
+  4:	ALOAD 2
+  5:	AASTORE 
+  6:	 // label
+  7:	 // line number information
+  8:	RETURN 

test-output/arrayWriteMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph arrayWriteMethod {
+
+    node [shape=record]
+    "arrayWriteMethodbb-1" [shape=circle,label="e",xlabel="arrayWriteMethod"]
+    "arrayWriteMethodbb-2" [shape=circle,label="x"]
+    "arrayWriteMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 1|3:	ICONST_0 |4:	ALOAD 2|5:	AASTORE |6:	 // label|7:	 // line number information|8:	RETURN }"]
+
+    "arrayWriteMethodbb-1" -> "arrayWriteMethodbb0"
+    "arrayWriteMethodbb0" -> "arrayWriteMethodbb-2"
+}

test-output/arrayWriteMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="arrayWriteMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 1\l|3:	ICONST_0 \l|4:	ALOAD 2\l|5:	AASTORE \l|6:	 // label\l|7:	 // line number information\l|8:	RETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/arrayWriteMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="arrayWriteMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/condMethod.asm.txt

@@ -0,0 +1,14 @@
+  Method: condMethod(II)I
+  0:	 // label
+  1:	 // line number information
+  2:	ILOAD 1
+  3:	ILOAD 2
+  4:	IF_ICMPLE 7
+  5:	ILOAD 1
+  6:	GOTO 10
+  7:	 // label
+  8:	 // stack frame map
+  9:	ILOAD 2
+  10:	 // label
+  11:	 // stack frame map
+  12:	IRETURN 

test-output/condMethod.cfg.dot

@@ -0,0 +1,17 @@
+digraph condMethod {
+
+    node [shape=record]
+    "condMethodbb-1" [shape=circle,label="e",xlabel="condMethod"]
+    "condMethodbb-2" [shape=circle,label="x"]
+    "condMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ILOAD 1|3:	ILOAD 2|4:	IF_ICMPLE 7}"]
+    "condMethodbb5" [label="5|{5:	ILOAD 1|6:	GOTO 10}"]
+    "condMethodbb7" [label="7|{7:	 // label|8:	 // stack frame map|9:	ILOAD 2}"]
+    "condMethodbb10" [label="10|{10:	 // label|11:	 // stack frame map|12:	IRETURN }"]
+
+    "condMethodbb-1" -> "condMethodbb0"
+    "condMethodbb0" -> "condMethodbb5"
+    "condMethodbb7" -> "condMethodbb10"
+    "condMethodbb10" -> "condMethodbb-2"
+    "condMethodbb0" -> "condMethodbb7" [label="T"]
+    "condMethodbb5" -> "condMethodbb10" [label="T"]
+}

test-output/condMethod.combined.dot

@@ -0,0 +1,20 @@
+digraph combined {
+  label="condMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ILOAD 1\l|3:	ILOAD 2\l|4:	IF_ICMPLE 7\l}"]
+  5 [shape=record,label="5|{5:	ILOAD 1\l|6:	GOTO 10\l}"]
+  7 [shape=record,label="7|{7:	 // label\l|8:	 // stack frame map\l|9:	ILOAD 2\l}"]
+  10 [shape=record,label="10|{10:	 // label\l|11:	 // stack frame map\l|12:	IRETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> 5 [label=""]
+  7 -> 10 [label=""]
+  10 -> -2 [label=""]
+  0 -> 7 [label="T"]
+  5 -> 10 [label="T"]
+  -1 -> 0 [style=dotted]
+  0 -> 7 [style=dotted]
+  10 -> -2 [style=dotted]
+  0 -> 10 [style=dotted]
+  0 -> 5 [style=dotted]
+}

test-output/condMethod.dt.dot

@@ -0,0 +1,14 @@
+digraph dominatorTree {
+  label="condMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(7)"
+  "D(10)"
+  "D(-2)"
+  "D(5)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(7)"
+  "D(10)" -> "D(-2)"
+  "D(0)" -> "D(10)"
+  "D(0)" -> "D(5)"
+}

test-output/doWhileMethod.asm.txt

@@ -0,0 +1,23 @@
+  Method: doWhileMethod(I)I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_0 
+  3:	ISTORE 2
+  4:	 // label
+  5:	 // line number information
+  6:	 // stack frame map
+  7:	ILOAD 2
+  8:	ILOAD 1
+  9:	IADD 
+  10:	ISTORE 2
+  11:	 // label
+  12:	 // line number information
+  13:	IINC 1 -1
+  14:	 // label
+  15:	 // line number information
+  16:	ILOAD 1
+  17:	IFGT 4
+  18:	 // label
+  19:	 // line number information
+  20:	ILOAD 2
+  21:	IRETURN 

test-output/doWhileMethod.cfg.dot

@@ -0,0 +1,15 @@
+digraph doWhileMethod {
+
+    node [shape=record]
+    "doWhileMethodbb-1" [shape=circle,label="e",xlabel="doWhileMethod"]
+    "doWhileMethodbb-2" [shape=circle,label="x"]
+    "doWhileMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2}"]
+    "doWhileMethodbb4" [label="4|{4:	 // label|5:	 // line number information|6:	 // stack frame map|7:	ILOAD 2|8:	ILOAD 1|9:	IADD |10:	ISTORE 2|11:	 // label|12:	 // line number information|13:	IINC 1 -1|14:	 // label|15:	 // line number information|16:	ILOAD 1|17:	IFGT 4}"]
+    "doWhileMethodbb18" [label="18|{18:	 // label|19:	 // line number information|20:	ILOAD 2|21:	IRETURN }"]
+
+    "doWhileMethodbb-1" -> "doWhileMethodbb0"
+    "doWhileMethodbb0" -> "doWhileMethodbb4"
+    "doWhileMethodbb4" -> "doWhileMethodbb18"
+    "doWhileMethodbb18" -> "doWhileMethodbb-2"
+    "doWhileMethodbb4" -> "doWhileMethodbb4" [label="T"]
+}

test-output/doWhileMethod.combined.dot

@@ -0,0 +1,17 @@
+digraph combined {
+  label="doWhileMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ICONST_0 \l|3:	ISTORE 2\l}"]
+  4 [shape=record,label="4|{4:	 // label\l|5:	 // line number information\l|6:	 // stack frame map\l|7:	ILOAD 2\l|8:	ILOAD 1\l|9:	IADD \l|10:	ISTORE 2\l|11:	 // label\l|12:	 // line number information\l|13:	IINC 1 -1\l|14:	 // label\l|15:	 // line number information\l|16:	ILOAD 1\l|17:	IFGT 4\l}"]
+  18 [shape=record,label="18|{18:	 // label\l|19:	 // line number information\l|20:	ILOAD 2\l|21:	IRETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> 4 [label=""]
+  4 -> 18 [label=""]
+  18 -> -2 [label=""]
+  4 -> 4 [label="T"]
+  -1 -> 0 [style=dotted]
+  18 -> -2 [style=dotted]
+  4 -> 18 [style=dotted]
+  0 -> 4 [style=dotted]
+}

test-output/doWhileMethod.dt.dot

@@ -0,0 +1,12 @@
+digraph dominatorTree {
+  label="doWhileMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(18)"
+  "D(-2)"
+  "D(4)"
+  "D(-1)" -> "D(0)"
+  "D(18)" -> "D(-2)"
+  "D(4)" -> "D(18)"
+  "D(0)" -> "D(4)"
+}

test-output/doWhileTrue.asm.txt

@@ -0,0 +1,8 @@
+  Method: doWhileTrue(I)I
+  0:	 // label
+  1:	 // line number information
+  2:	 // stack frame map
+  3:	IINC 1 1
+  4:	 // label
+  5:	 // line number information
+  6:	GOTO 0

test-output/doWhileTrue.cfg.dot

@@ -0,0 +1,10 @@
+digraph doWhileTrue {
+
+    node [shape=record]
+    "doWhileTruebb-1" [shape=circle,label="e",xlabel="doWhileTrue"]
+    "doWhileTruebb-2" [shape=circle,label="e",xlabel="doWhileTrue"]
+    "doWhileTruebb0" [label="0|{0:	 // label|1:	 // line number information|2:	 // stack frame map|3:	IINC 1 1|4:	 // label|5:	 // line number information|6:	GOTO 0}"]
+
+    "doWhileTruebb-1" -> "doWhileTruebb0"
+    "doWhileTruebb0" -> "doWhileTruebb0" [label="T"]
+}

test-output/doWhileTrue.combined.dot

@@ -0,0 +1,9 @@
+digraph combined {
+  label="doWhileTrue"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	 // stack frame map\l|3:	IINC 1 1\l|4:	 // label\l|5:	 // line number information\l|6:	GOTO 0\l}"]
+  -1 -> 0 [label=""]
+  0 -> 0 [label="T"]
+  -1 -> 0 [style=dotted]
+}

test-output/doWhileTrue.dt.dot

@@ -0,0 +1,6 @@
+digraph dominatorTree {
+  label="doWhileTrue"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-1)" -> "D(0)"
+}

test-output/emptyMethod.asm.txt

@@ -0,0 +1,4 @@
+  Method: emptyMethod()V
+  0:	 // label
+  1:	 // line number information
+  2:	RETURN 

test-output/emptyMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph emptyMethod {
+
+    node [shape=record]
+    "emptyMethodbb-1" [shape=circle,label="e",xlabel="emptyMethod"]
+    "emptyMethodbb-2" [shape=circle,label="x"]
+    "emptyMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	RETURN }"]
+
+    "emptyMethodbb-1" -> "emptyMethodbb0"
+    "emptyMethodbb0" -> "emptyMethodbb-2"
+}

test-output/emptyMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="emptyMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	RETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  0 -> -2 [style=dotted]
+  -1 -> 0 [style=dotted]
+}

test-output/emptyMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="emptyMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(0)" -> "D(-2)"
+  "D(-1)" -> "D(0)"
+}

test-output/fieldReadMethod.asm.txt

@@ -0,0 +1,6 @@
+  Method: fieldReadMethod()Ljava/lang/String;
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 0
+  3:	GETFIELD ExampleClass.field Ljava/lang/String;
+  4:	ARETURN 

test-output/fieldReadMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph fieldReadMethod {
+
+    node [shape=record]
+    "fieldReadMethodbb-1" [shape=circle,label="e",xlabel="fieldReadMethod"]
+    "fieldReadMethodbb-2" [shape=circle,label="x"]
+    "fieldReadMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	GETFIELD ExampleClass.field Ljava/lang/String;|4:	ARETURN }"]
+
+    "fieldReadMethodbb-1" -> "fieldReadMethodbb0"
+    "fieldReadMethodbb0" -> "fieldReadMethodbb-2"
+}

test-output/fieldReadMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="fieldReadMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 0\l|3:	GETFIELD ExampleClass.field Ljava/lang/String;\l|4:	ARETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/fieldReadMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="fieldReadMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/fieldWriteMethod.asm.txt

@@ -0,0 +1,9 @@
+  Method: fieldWriteMethod(Ljava/lang/String;)V
+  0:	 // label
+  1:	 // line number information
+  2:	ALOAD 0
+  3:	ALOAD 1
+  4:	PUTFIELD ExampleClass.field Ljava/lang/String;
+  5:	 // label
+  6:	 // line number information
+  7:	RETURN 

test-output/fieldWriteMethod.cfg.dot

@@ -0,0 +1,10 @@
+digraph fieldWriteMethod {
+
+    node [shape=record]
+    "fieldWriteMethodbb-1" [shape=circle,label="e",xlabel="fieldWriteMethod"]
+    "fieldWriteMethodbb-2" [shape=circle,label="x"]
+    "fieldWriteMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ALOAD 0|3:	ALOAD 1|4:	PUTFIELD ExampleClass.field Ljava/lang/String;|5:	 // label|6:	 // line number information|7:	RETURN }"]
+
+    "fieldWriteMethodbb-1" -> "fieldWriteMethodbb0"
+    "fieldWriteMethodbb0" -> "fieldWriteMethodbb-2"
+}

test-output/fieldWriteMethod.combined.dot

@@ -0,0 +1,10 @@
+digraph combined {
+  label="fieldWriteMethod"
+  -1 [shape=record,style=filled,label="-1|entry"]
+  -2 [shape=record,label="-2|exit"]
+  0 [shape=record,label="0|{0:	 // label\l|1:	 // line number information\l|2:	ALOAD 0\l|3:	ALOAD 1\l|4:	PUTFIELD ExampleClass.field Ljava/lang/String;\l|5:	 // label\l|6:	 // line number information\l|7:	RETURN \l}"]
+  -1 -> 0 [label=""]
+  0 -> -2 [label=""]
+  -1 -> 0 [style=dotted]
+  0 -> -2 [style=dotted]
+}

test-output/fieldWriteMethod.dt.dot

@@ -0,0 +1,8 @@
+digraph dominatorTree {
+  label="fieldWriteMethod"
+  "D(-1)" [style=filled]
+  "D(0)"
+  "D(-2)"
+  "D(-1)" -> "D(0)"
+  "D(0)" -> "D(-2)"
+}

test-output/forEachArrayMethod.asm.txt

@@ -0,0 +1,35 @@
+  Method: forEachArrayMethod([Ljava/lang/String;)I
+  0:	 // label
+  1:	 // line number information
+  2:	ICONST_0 
+  3:	ISTORE 2
+  4:	 // label
+  5:	 // line number information
+  6:	ALOAD 1
+  7:	ASTORE 3
+  8:	ALOAD 3
+  9:	ARRAYLENGTH 
+  10:	ISTORE 4
+  11:	ICONST_0 
+  12:	ISTORE 5
+  13:	 // label
+  14:	 // stack frame map
+  15:	ILOAD 5
+  16:	ILOAD 4
+  17:	IF_ICMPGE 29
+  18:	ALOAD 3
+  19:	ILOAD 5
+  20:	AALOAD 
+  21:	ASTORE 6
+  22:	 // label
+  23:	 // line number information
+  24:	IINC 2 1
+  25:	 // label
+  26:	 // line number information
+  27:	IINC 5 1
+  28:	GOTO 13
+  29:	 // label
+  30:	 // line number information
+  31:	 // stack frame map
+  32:	ILOAD 2
+  33:	IRETURN 

test-output/forEachArrayMethod.cfg.dot

@@ -0,0 +1,17 @@
+digraph forEachArrayMethod {
+
+    node [shape=record]
+    "forEachArrayMethodbb-1" [shape=circle,label="e",xlabel="forEachArrayMethod"]
+    "forEachArrayMethodbb-2" [shape=circle,label="x"]
+    "forEachArrayMethodbb0" [label="0|{0:	 // label|1:	 // line number information|2:	ICONST_0 |3:	ISTORE 2|4:	 // label|5:	 // line number information|6:	ALOAD 1|7:	ASTORE 3|8:	ALOAD 3|9:	ARRAYLENGTH |10:	ISTORE 4|11:	ICONST_0 |12:	ISTORE 5}"]
+    "forEachArrayMethodbb13" [label="13|{13:	 // label|14:	 // stack frame map|15:	ILOAD 5|16:	ILOAD 4|17:	IF_ICMPGE 29}"]
+    "forEachArrayMethodbb18" [label="18|{18:	ALOAD 3|19:	ILOAD 5|20:	AALOAD |21:	ASTORE 6|22:	 // label|23:	 // line number information|24:	IINC 2 1|25:	 // label|26:	 // line number information|27:	IINC 5 1|28:	GOTO 13}"]
+    "forEachArrayMethodbb29" [label="29|{29:	 // label|30:	 // line number information|31:	 // stack frame map|32:	ILOAD 2|33:	IRETURN }"]
+
+    "forEachArrayMethodbb-1" -> "forEachArrayMethodbb0"
+    "forEachArrayMethodbb0" -> "forEachArrayMethodbb13"
+    "forEachArrayMethodbb13" -> "forEachArrayMethodbb18"
+    "forEachArrayMethodbb29" -> "forEachArrayMethodbb-2"
+    "forEachArrayMethodbb18" -> "forEachArrayMethodbb13" [label="T"]
+    "forEachArrayMethodbb13" -> "forEachArrayMethodbb29" [label="T"]
+}