Iterator<DirectedSparseEdge> edgeIter = g.getEdges().iterator();

    while(edgeIter.hasNext())

    { 

      // The line below aims to ensure that inputs are evaluated by computeStateScore in a specific order, which in conjunction with the visited set of computeStateScore permits emulating a bug in computeScore

    }

  }

      Vertex v = vertexIt.next();

      outLabels.clear();

      Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

      while(outEdgeIt.hasNext()){

      }

      transitionsToBeAdded = !alphabet.equals(outLabels);

    }

   

    if (transitionsToBeAdded)

    {

      // third pass - adding transitions

      g.addVertex(rejectVertex);

      vertexIt = g.getVertices().iterator();

      while(vertexIt.hasNext())

      {

        Vertex v = vertexIt.next();

        if (v != rejectVertex)

        {// no transitions should start from the reject vertex

          Set<Label> outgoingLabels = new TreeSet<Label>();outgoingLabels.addAll(alphabet);

         

          Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

          while(outEdgeIt.hasNext()){

          }

          if (!outgoingLabels.isEmpty())

          {

            // add a transition

            g.addEdge(edge);

          }

        }

      }

    }

    for(DirectedSparseEdge e:(Set<DirectedSparseEdge>)g.getEdges())

    {

      DeterministicVertex newSrc = DeterministicDirectedSparseGraph.copyVertex(newVertices,result,e.getSource()),

        newDst = DeterministicDirectedSparseGraph.copyVertex(newVertices, result, e.getDest());

      Set<Label> origLabels = (Set<Label>)e.getUserDatum(JUConstants.LABEL);

      TreeSet<Label> copiedLabels = new TreeSet<Label>();copiedLabels.addAll(origLabels);

      result.addEdge(newEdge);

    }

    return result;

  }

  public static Edge findEdge(Vertex from, Vertex to){

    @SuppressWarnings("unchecked")

    Iterator<DirectedSparseEdge> edgesOut = from.getOutEdges().iterator();

    while(edgesOut.hasNext()){

        return current;

    }

    return null;

  }

      Iterator<String> labelIt = labels.iterator();

      e.addUserDatum(EDGE, labelIt.next(), UserData.SHARED);

      while(labelIt.hasNext())

      {

        newEdges.add(newEdge);

      }

    }

   

    for(Edge e:newEdges)

        Iterator<DirectedSparseEdge> sourceOutIt = source.getOutEdges().iterator();

        Edge fromSourceToNewRed = null;

        while(sourceOutIt.hasNext() && fromSourceToNewRed == null)

        {

        }

        if (fromSourceToNewRed == null)

        {

          fromSourceToNewRed.setUserDatum(JUConstants.LABEL, existingLabels, UserData.CLONE);// no need to clone this one since I'll delete the edge in a bit

          g.addEdge(fromSourceToNewRed);

        }

        else

          // there is already a transition from source to newRed, hence all we have to do is merge the new labels into it.

          ((Collection<String>)fromSourceToNewRed.getUserDatum(JUConstants.LABEL)).addAll( existingLabels );

         

      }

      // now the elements of mergedVertices are in terms of the copied graph.

      for(Vertex vert:(Set<Vertex>)g.getVertices())

        if (mergedVertices.containsKey(vert))

        {// there are some vertices to merge with this one.

          usedInputs.clear();usedInputs.addAll(s.transitionMatrix.get(vert).keySet());

          for(CmpVertex toMerge:mergedVertices.get(vert))

          {// for every input, I'll have a unique target state - this is a feature of PTA

           // For this reason, every if multiple branches of PTA get merged, there will be no loops or parallel edges.

          // As a consequence, it is safe to assume that each input/target state combination will lead to a new state.

            Set<String> inputsFrom_toMerge = s.transitionMatrix.get(toMerge).keySet();

            for(String input:inputsFrom_toMerge)

              if (!usedInputs.contains(input))

              {

                Set<String> labels = new HashSet<String>();labels.add(input);

                DeterministicVertex targetVert = (DeterministicVertex)s.transitionMatrix.get(toMerge).get(input);

                g.removeEdges(targetVert.getInEdges());g.addEdge(newEdge);

              }

            usedInputs.addAll(inputsFrom_toMerge);

          }

        }

        Iterator<DirectedSparseEdge> sourceOutIt = source.getOutEdges().iterator();

        Edge fromSourceToNewRed = null;

        while(sourceOutIt.hasNext() && fromSourceToNewRed == null)

        {

        }

        if (fromSourceToNewRed == null)

        {

          fromSourceToNewRed.setUserDatum(JUConstants.LABEL, existingLabels, UserData.CLONE);// no need to clone this one since I'll delete the edge in a bit

          g.addEdge(fromSourceToNewRed);

        }

        else

          // there is already a transition from source to newRed, hence all we have to do is merge the new labels into it.

          ((Collection<Label>)fromSourceToNewRed.getUserDatum(JUConstants.LABEL)).addAll( existingLabels );

         

      }

      // now the elements of mergedVertices are in terms of the copied graph.

      for(Vertex vert:(Set<Vertex>)g.getVertices())

        if (mergedVertices.containsKey(vert))

        {// there are some vertices to merge with this one.

          usedInputs.clear();usedInputs.addAll(s.transitionMatrix.get(vert).keySet());

          for(CmpVertex toMerge:mergedVertices.get(vert))

          {// for every input, I'll have a unique target state - this is a feature of PTA

           // For this reason, every if multiple branches of PTA get merged, there will be no loops or parallel edges.

          // As a consequence, it is safe to assume that each input/target state combination will lead to a new state.

            Set<Label> inputsFrom_toMerge = s.transitionMatrix.get(toMerge).keySet();

            for(Label input:inputsFrom_toMerge)

              if (!usedInputs.contains(input))

              {

                Set<Label> labels = new HashSet<Label>();

                                                                labels.add(input);

                DeterministicVertex targetVert = (DeterministicVertex)s.transitionMatrix.get(toMerge).get(input);

                g.removeEdges(targetVert.getInEdges());g.addEdge(newEdge);

              }

            usedInputs.addAll(inputsFrom_toMerge);

          }

        }

      Vertex v = vertexIt.next();

      outLabels.clear();

      Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

      while(outEdgeIt.hasNext()){

      }

      transitionsToBeAdded = !alphabet.equals(outLabels);

    }

   

    if (transitionsToBeAdded)

    {

      // third pass - adding transitions

      g.addVertex(rejectVertex);

      vertexIt = g.getVertices().iterator();

      while(vertexIt.hasNext())

      {

        Vertex v = vertexIt.next();

        if (v != rejectVertex)

        {// no transitions should start from the reject vertex

          Set<Label> outgoingLabels = new TreeSet<Label>();outgoingLabels.addAll(alphabet);

         

          Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

          while(outEdgeIt.hasNext()){

          }

          if (!outgoingLabels.isEmpty())

          {

            // add a transition

            g.addEdge(edge);

          }

        }

      }

    }

      Vertex v = vertexIt.next();

      outLabels.clear();

      Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

      while(outEdgeIt.hasNext()){

      }

      transitionsToBeAdded = !alphabet.equals(outLabels);

    }

   

    if (transitionsToBeAdded)

    {

      // third pass - adding transitions

      g.addVertex(rejectVertex);

      vertexIt = (Iterator<Vertex>)g.getVertices().iterator();

      while(vertexIt.hasNext())

      {

        Vertex v = vertexIt.next();

        if (v != rejectVertex)

        {// no transitions should start from the reject vertex

          Set<String> outgoingLabels = new TreeSet<String>();outgoingLabels.addAll(alphabet);

         

          Iterator<DirectedSparseEdge>outEdgeIt = v.getOutEdges().iterator();

          while(outEdgeIt.hasNext()){

          }

          if (!outgoingLabels.isEmpty())

          {

            // add a transition

            g.addEdge(edge);

          }

        }

      }

    }

    for(DirectedSparseEdge e:(Set<DirectedSparseEdge>)g.getEdges())

    {

      DeterministicVertex newSrc = DeterministicDirectedSparseGraph.copyVertex(newVertices,result,e.getSource()),

        newDst = DeterministicDirectedSparseGraph.copyVertex(newVertices, result, e.getDest());

      Set<Label> origLabels = (Set<Label>)e.getUserDatum(JUConstants.LABEL);

      TreeSet<Label> copiedLabels = new TreeSet<Label>();copiedLabels.addAll(origLabels);

      result.addEdge(newEdge);

    }

    return result;

  }