int firstCorrectPair = JUConstants.intUNKNOWN, cnt=0;

    for(PairScore p:pairs)

    {

      if (blue == red)

      {

        // it would be right to merge this pair.

        correctPairs.add(p);

        if (firstCorrectPair == JUConstants.intUNKNOWN)

   

    Map<Label,CmpVertex> labelToState = new TreeMap<Label,CmpVertex>();

    for(Entry<CmpVertex,Map<Label,CmpVertex>> entry:graph.transitionMatrix.entrySet())

    {

      for(Entry<Label,CmpVertex> target:entry.getValue().entrySet())

        if (!deadLabels.contains(target.getKey()))

        {// the label is not already recorded as leading to multiple different states.

            if (recordedState == null)

              // first time we've seen this label in use

              labelToState.put(target.getKey(),state);

            else

              if (recordedState != state)

    LearnerGraphND ptaInverse = new LearnerGraphND(graph.config);

    AbstractPathRoutines.buildInverse(graph, new StatesToConsider() {

      @Override public boolean stateToConsider(@SuppressWarnings("unused") CmpVertex v) { return true; }}

      , ptaInverse);

    for(int i=0;i<10;++i)

    {

      Map<Label,List<CmpVertex>> transitions = ptaInverse.transitionMatrix.get(v);

      if (transitions.size() > 1)

      {

        System.out.println(transitions);break;

      }

      List<CmpVertex> next = transitions.entrySet().iterator().next().getValue();

      if (next.size() > 1)

      {

        System.out.println(next);break;

      }

      System.out.println(v+"-"+transitions.entrySet().iterator().next().getKey()+"->"+nextState);

      v  = nextState;

    }

   

  }

    for(CmpVertex vert:sourceStates)

      if (vert != pta.getInit())

      {

        Map<Label,CmpVertex> row = pta.createNewRow();

        pta.transitionMatrix.put(newSource,row);row.put(uniqueFromInitial, pta.transitionMatrix.get(vert).get(uniqueFromInitial));

        statesOfInterest.add(newSource);

       

        Map<Label,CmpVertex> tailRow = pta.createNewRow();

        pta.transitionMatrix.put(tailState,tailRow);pta.transitionMatrix.get(vert).put(uniqueFromInitial,tailState);

      }

      else

        statesOfInterest.add(vert);

          }

     

      for(Collection<CmpVertex> vertices:labelToStates.values())

      {

        for(CmpVertex v:vertices)

        {

          if (prevVertex != null)

            pairsList.add(new StatePair(prevVertex,v));

          prevVertex = v;

        }

      }

      for(Collection<CmpVertex> vertices:labelFromStates.values())

      {

        for(CmpVertex v:vertices)

        {

          if (prevVertex != null)

            pairsList.add(new StatePair(prevVertex,v));

          prevVertex = v;

    /** There are cases when no selected pair is actually valid. The method below chooses a state to be marked as red because it is the only choice that we can make. */

    public CmpVertex resolvePotentialDeadEnd(LearnerGraph coregraph, @SuppressWarnings("unused") Collection<CmpVertex> reds, Collection<PairScore> pairs)

    {

     

      List<PairScore> correctPairs = new ArrayList<PairScore>(pairs.size()), wrongPairs = new ArrayList<PairScore>(pairs.size());

      SplitSetOfPairsIntoRightAndWrong(coregraph, referenceGraph, pairs, correctPairs, wrongPairs);

      if (correctPairs.isEmpty())

        stateToMarkRed = wrongPairs.get(0).getQ();// no correct pairs found to merge, return the first wrong pair so the corresponding state is marked as red.

     

  {

    @Override

    public CmpVertex selectRedNode(@SuppressWarnings("unused") LearnerGraph gr, @SuppressWarnings("unused") Collection<CmpVertex> reds, Collection<CmpVertex> tentativeRedNodes)

    {

      return redVertex;

    }

        // for a particular pairscore decision procedure.

        @Override

        public CmpVertex selectRedNode(@SuppressWarnings("unused") LearnerGraph gr, @SuppressWarnings("unused") Collection<CmpVertex> reds, Collection<CmpVertex> tentativeRedNodes)

        {

          return redVertex;

        }

        @SuppressWarnings("unused")

        @Override

        // for a particular pairscore decision procedure.

        @Override

        public CmpVertex selectRedNode(@SuppressWarnings("unused") LearnerGraph coregraph, @SuppressWarnings("unused") Collection<CmpVertex> reds, Collection<CmpVertex> tentativeRedNodes)

        {

          return redVertex;

        }

        @Override

        public CmpVertex resolvePotentialDeadEnd(LearnerGraph coregraph, Collection<CmpVertex> reds, List<PairScore> pairs)

        {

          dataCollector.updateDatasetWithPairs(pairs, coregraph, referenceGraph);

          return red;

         

          //return null;// for no resolution

        }

       

    /** Used to select the best red node based on what the subsequent collection of pairs will be. */

    public static CmpVertex selectRedNodeUsingQualityEstimator(LearnerGraph coregraph, Collection<CmpVertex> tentativeRedNodes, CollectionOfPairsEstimator pairQualityEstimator)

    {

     

      // It is not hard to calculate what blue states will directly surround a specific state chosen to become red, however those blue states may in turn immediately become red after evaluation and the same would apply

      // to the newly-discovered red states, so we effectively have to re-implement blue state calculation here. For this reason, it was decided not to do this but instead clone the state machine (possibly in a trimmed form)

      // and ask it for a list of pairs.

      // In practice, this algorithm turned out to be rather slow because there could be many red states to choose from and among those, many would lead to many pairs, all of which have to be scored.