class NotIsolatedAnalysis extends BackwardFlowAnalysis<Unit, FlowSet<EquivalentValue>> {

  private final LatestComputation unitToLatest;
  private final Map<Unit, EquivalentValue> unitToGen;
  private final FlowSet<EquivalentValue> set;

  /**
   * Automatically performs the Isolation-analysis on the graph <code>dg</code> using the Latest-computation
   * <code>latest</code>.<br>
   * the <code>equivRhsMap</code> is only here to avoid doing these things again...
   *
   * @param dg
   *          a ExceptionalUnitGraph
   * @param latest
   *          the latest-computation of the same graph.
   * @param equivRhsMap
   *          the rhs of each unit (if assignment-stmt).
   */
  public NotIsolatedAnalysis(DirectedGraph<Unit> dg, LatestComputation latest, Map<Unit, EquivalentValue> equivRhsMap) {
    this(dg, latest, equivRhsMap,
        new ArrayPackedSet<EquivalentValue>(new CollectionFlowUniverse<EquivalentValue>(equivRhsMap.values())));
  }

  /**
   * Automatically performs the Isolation-analysis on the graph <code>dg</code> using the Latest-computation
   * <code>latest</code>.<br>
   * the <code>equivRhsMap</code> is only here to avoid doing these things again...<br>
   * the shared set allows more efficient set-operations, when this analysis is joined with other analyses/computations.
   *
   * @param dg
   *          a ExceptionalUnitGraph
   * @param latest
   *          the latest-computation of the same graph.
   * @param equivRhsMap
   *          the rhs of each unit (if assignment-stmt).
   * @param set
   *          the shared set.
   */
  public NotIsolatedAnalysis(DirectedGraph<Unit> dg, LatestComputation latest, Map<Unit, EquivalentValue> equivRhsMap,
      BoundedFlowSet<EquivalentValue> set) {
    super(dg);
    this.set = set;
    this.unitToGen = equivRhsMap;
    this.unitToLatest = latest;
    doAnalysis();
  }

  @Override
  protected FlowSet<EquivalentValue> newInitialFlow() {
    return set.emptySet();
  }

  @Override
  protected FlowSet<EquivalentValue> entryInitialFlow() {
    return newInitialFlow();
  }

  @Override
  protected void flowThrough(FlowSet<EquivalentValue> in, Unit unit, FlowSet<EquivalentValue> out) {<FILL_FUNCTION_BODY>}

  @Override
  protected void merge(FlowSet<EquivalentValue> inSet1, FlowSet<EquivalentValue> inSet2, FlowSet<EquivalentValue> outSet) {
    inSet1.union(inSet2, outSet);
  }

  @Override
  protected void copy(FlowSet<EquivalentValue> sourceSet, FlowSet<EquivalentValue> destSet) {
    sourceSet.copy(destSet);
  }
}

    in.copy(out);

    // Perform generation
    EquivalentValue rhs = (EquivalentValue) unitToGen.get(unit);
    if (rhs != null) {
      out.add(rhs);
    }

    // perform kill
    FlowSet<EquivalentValue> latest = unitToLatest.getFlowBefore(unit);
    out.difference(latest);
  
<methods>public void <init>(DirectedGraph<soot.Unit>) <variables>