code: public MatchResult match(MatchResult reuse, byte[] sequence, int start, int length, int node) {
  		if (node == 0) {
  		  reuse.reset(NO_MATCH, start, node);
  			return reuse;
  		}
  
  		final FSA fsa = this.fsa;
  		final int end = start + length;
  		for (int i = start; i < end; i++) {
  			final int arc = fsa.getArc(node, sequence[i]);
  			if (arc != 0) {
  				if (i + 1 == end && fsa.isArcFinal(arc)) {
  					/* The automaton has an exact match of the input sequence. */
  				  reuse.reset(EXACT_MATCH, i, node);
  					return reuse;
  				}
  
  				if (fsa.isArcTerminal(arc)) {
  					/* The automaton contains a prefix of the input sequence. */
  				  reuse.reset(AUTOMATON_HAS_PREFIX, i + 1, node);
  					return reuse;
  				}
  
  				// Make a transition along the arc.
  				node = fsa.getEndNode(arc);
  			} else {
  			  if (i > start) {
  			    reuse.reset(AUTOMATON_HAS_PREFIX, i, node);
  			  } else {
  	        reuse.reset(NO_MATCH, i, node);
  			  }
  				return reuse;
  			}
  		}
  
  		/* The sequence is a prefix of at least one sequence in the automaton. */
  		reuse.reset(SEQUENCE_IS_A_PREFIX, 0, node);
  		return reuse;
  	}
docs: Same as {@link #match(byte[], int, int, int)}, but allows passing
  a reusable {@link MatchResult} object so that no intermediate garbage is
  produced.
  
  @param reuse The {@link MatchResult} to reuse.
  @param sequence Input sequence to look for in the automaton.
  @param start Start index in the sequence array.
  @param length Length of the byte sequence, must be at least 1.
  @param node The node to start traversal from, typically the {@linkplain FSA#getRootNode() root node}.
  
  @return The same object as <code>reuse</code>, but with updated match {@link MatchResult#kind}
  and other relevant fields.