code: public static <S1, I, T1, S2, T2, SP2, TP2> Mapping<S1, S2> rawCopy(AutomatonCopyMethod method,
                                                                          Automaton<S1, ? super I, T1> in,
                                                                          Collection<? extends I> inputs,
                                                                          MutableAutomaton<S2, I, T2, SP2, TP2> out,
                                                                          Function<? super S1, ? extends SP2> spMapping,
                                                                          Function<? super T1, ? extends TP2> tpMapping) {
          return rawCopy(method, in, inputs, out, spMapping, tpMapping, s -> true, (s, i, t) -> true);
      }
docs: Copies an {@link Automaton} to a {@link MutableAutomaton} with a compatible input alphabet, but possibly
  heterogeneous state and transition properties. States and transitions will not be filtered.
  
  @param <S1>
  input automaton state type
  @param <I>
  input symbol type
  @param <T1>
  input automaton transition type
  @param <S2>
  output automaton state type
  @param <T2>
  output automaton transition type
  @param <SP2>
  output automaton state property type
  @param <TP2>
  output automaton transition property type
  @param method
  the copy method to use
  @param in
  the input automaton
  @param inputs
  the inputs to consider
  @param out
  the output automaton
  @param spMapping
  the function for obtaining state properties
  @param tpMapping
  the function for obtaining transition properties
  
  @return a mapping from old to new states