public List getAmbiguityMismatches(MismatchPoint m) {
        // SI POTREBBE EVITARE TUTTO QUESTO PER LA MAGGIOR PARTE DEGLI AMBIGUITY MISMATCH        
        Direction dir = m.getDir();
        // Observe that non-linear mismatches are generated together with one linear mismatch
        // For the purpose of dealing with ambiguity, it suffices to handle the linear mismatch
        if (max_ambiguity_mismatches==0 || !m.isLinear())  return Collections.EMPTY_LIST;
        /* Ambiguity mismatches occur before the  mismatch in correspondance of dom depth changes */
        List result = new LinkedList();
        int domDepth = m.getMinDOMdepth()-1; // wanted DOM depth for first ambiguity mismatch
        int order = m.getOrder();
        /* Look for tokens on the matching tokenlist at the given dom depth from the original mismatch backwards*/
        Parser parser = new Parser(m.getExpression(), dir);
        TokenListRegion matchingTLR = m.getMatchingTokenlist();
        List matchingTokens = matchingTLR.asList();
        ListIterator tokensIt = BidirectionalListFactory.newListIterator(matchingTokens, dir.uTurn());
        int tokensBack = 0, numberOfMismatches = 0;
        while (numberOfMismatches<max_ambiguity_mismatches && tokensIt.hasNext()) {
            Token token = (Token)tokensIt.next(); tokensBack++;
            if (token.depth()==domDepth) {
                //add ambiguity mismatch for that DOM depth on tokenlist
                int currentTokIdx = m.getTokenIndex() - dir.unit()*tokensBack;
                Token currentToken = m.getTokenlist().getToken(currentTokIdx);
                TokenListRegion tlr = (TokenListRegion)dir.subRegionBefore(matchingTLR, dir.posAfterIndex(currentTokIdx));
                parser.parseAllTokenlist(new TokenList(tlr.asList())); // parse to find last matching node
                List currentPaths = parser.getPathsReachedOnExpression();
                Iterator pathIt = currentPaths.iterator();
                Node.Path currentPath = null;
                while (pathIt.hasNext()) {
                    //Choose the one matching with current token
                    Node.Path path = (Node.Path)pathIt.next();
                    Node currentNode = m.getExpression().getNode(path);
                    if (currentNode instanceof Token && currentToken.matches((Token)currentNode)) {
                        currentPath = path;
                        break;
                    }
                }
                if (currentPath==null) throw new RuntimeException("Something wrong!");
                MismatchPoint mismatch = getMismatchPoint(m, currentPath,  currentTokIdx);
                mismatch.setOrder(++order);
                result.add(mismatch);
                numberOfMismatches++;
                domDepth--;
            }
        }
        return result;
    }