code: public List<Annotation> interleaved(@NonNull AnnotationType... types) {
        if (types == null || types.length == 0) {
           return Collections.emptyList();
        }
  
  
        List<Annotation> annotations = new ArrayList<>();
        for (int i = 0; i < tokenLength(); ) {
           Annotation annotation = Fragments.detachedEmptyAnnotation();
           for (AnnotationType other : types) {
              for (Annotation temp : tokenAt(i).get(other)) {
                 if (temp.tokenLength() > annotation.tokenLength()) {
                    annotation = temp;
                 }
              }
           }
  
           if (annotation.isEmpty()) {
              i++;
           } else {
              i += annotation.tokenLength();
              annotations.add(annotation);
           }
        }
        return annotations;
     }
docs: <p> Returns the annotations of the given types that overlap this string in a maximum match fashion. Each token in
  the string is examined and the annotation type with the longest span on that token is chosen. If more than one
  type has the span length, the first one found will be chose, i.e. the order in which the types are passed in to
  the method can effect the outcome. </p> <p> Examples where this is useful is when dealing with multi-word
  expressions. Using the interleaved method you can retrieve all tokens and multi-word expressions to fully match
  the span of the string. </p>
  
  @param types The other types to examine
  @return The list of interleaved annotations