(DFA Outputs) We only defined a DFA to either "accept" or "not accept" a string, based on whether the machine, when reading that string, ended in a final state or not. Consider a variant called an Output-DFA: it is a 6-tuple (Q, sigma, Gamma, delta, q_0, F) where Q, sigma, q_0, F are defined exactly as in a normal DFA, but Gamma is the output alphabet, and delta: Q times sigma times (Gamma Union {epsilon}) plusminus Q is the transition function. In other words, we associate either a character of Gamma epsilon as the "output" of executing that transition. We commonly write a transition of this form as q q' where a is the character read, and b is the character outputted. For such an Output-DFA M and w elementof sigma, let M(w) be the concatenation of the characters outputted on each transition taken, and the machine only outputs anything if and only if the machine has read all of its input. If M has language L, let Out(M) = {M (w): w elementof L}. (a) Prove that if L is regular, then Out(M) is regular. (b) A fired point string is a string that, when applying some function to it, the function returns the same string. Consider an Output-DFA M with the same input and output alphabet. Prove that the language FP = (M) = {w elementof sigma: M (w) = w} is regular. (c) Suppose that instead of outputting a single character from Gamma (epsilon) on each transition, we output a string in Gamma. Call these machines Output*-DFAs. Prove that the languages outputted by Output-DFAs and those outputted by Output*-DFAs are the same