Finite State Machine validity I've been around for a while, watching you golf and I really enjoy it.
I came up with a challenge for you all so let's begin!
Challenge
I assume that everyone knows what Finite State Machine (FSM) is, I will edit the the description if needed.

Your program will take only one input consisting in a string that represents a FSM.
The first character of the input is the FSM's initial state and the last character is the FSM's final state.
Transitions are represented as two consecutive characters (AB will be the transition from state A to state B. ABCD will be the two transitions A to B and C to D)
In this challenge, the FSM is considered valid when you have at least one path from the initial state to the final state.

Goal
Output a truthy value, telling the world if the input is a valid FSM (any equivalent for True of False is fine)
Bonus

-20% if you add all the sequences of valid paths to the output

Examples
AB should output (with bonus) true AB
ABC should output false (No transition to state C)
ABCEBD should output (with bonus) true ABD (The presence of unreachable states C and E doesn't make it false)
ISSTSFTF should output (with bonus) true ISF ISTF
ABACBCCD should output (with bonus) true ACD ABCD
ABACBCD should output false
ABACADCDBCDEBE should output (with bonus) true ABE ADE ACDE ABCDE
Final word
If you think this challenge lacks something, please tell me, I'd really like to see the answers you can come up with
JavaScript (ES6), 81 bytes

s=&gt;(a=[...s]).map(_=&gt;a.map((m,i)=&gt;p=i%2&amp;r[s[i-1]]?r[m]=1:r[m]),r={},r[s[0]]=1)&amp;&amp;p


Explanation

Takes the states as a string and returns a 1 for true or undefined for false. This method was the shortest I could find, but it means that it's impossible to include the bonus because it just determines reachability, not the paths.

s=&gt;
  (a=[...s])        // a = states as an array
  .map(_=&gt;          // loop a number of times to ensure all states have been reached
    a.map((m,i)=&gt;   // for each state m at index i
      p=            // p = the reachability of the final state
        i%2         // if this is the last state of a pair
        &amp;r[s[i-1]]? // and the first state is reachable
          r[m]=1    // set the last state and p to reachable
          :r[m]     // else set p to the reachability of the state
    ),
    r={},           // map of truthy values for reachable states
    r[s[0]]=1       // set the initial state to reachable
  )
  &amp;&amp;p               // return the final result


Test



var solution = s=&gt;(a=[...s]).map(_=&gt;a.map((m,i)=&gt;p=i%2&amp;r[s[i-1]]?r[m]=1:r[m]),r={},r[s[0]]=1)&amp;&amp;p
&lt;input type="text" id="input" value="ABACADCDBCDEBE" /&gt;
&lt;button onclick="result.textContent=solution(input.value)"&gt;Go&lt;/button&gt;
&lt;pre id="result"&gt;&lt;/pre&gt;