`iژdZddlmZddlmZddlmZddlmZm Z m Z m Z m Z m Z mZmZddlmZGddeZeGd d ZeZd ee eeffd Ze d eZe deZGdde eefZGddeZGddZdZdZ dZ!dZ"dZ#dS)zX Finite state machine library, extracted from `greenery.fsm` and adapted by MegaIng )deque) defaultdict)total_ordering)AnySetDictUnionNewTypeMappingTupleIterable soft_reprceZdZdS)_MarkerN)__name__ __module__ __qualname__c/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/interegular/fsm.pyrr sDrrc0eZdZdZdZdZdZdZdZdS)_AnythingElseClsa This is a surrogate symbol which you can use in your finite state machines to represent "any symbol not in the official alphabet". For example, if your state machine's alphabet is {"a", "b", "c", "d", fsm.anything_else}, then you can pass "e" in as a symbol and it will be converted to fsm.anything_else, then follow the appropriate transition. cdSN anything_elserselfs r__str__z_AnythingElseCls.__str__rcdSrrrs r__repr__z_AnythingElseCls.__repr__r rcdS)NFrrothers r__lt__z_AnythingElseCls.__lt__ surc ||uSNrr$s r__eq__z_AnythingElseCls.__eq__#s u}rc:tt|Sr()hashidrs r__hash__z_AnythingElseCls.__hash__&sBtHH~~rN) rrr__doc__rr"r&r)r-rrrrrsirrcharsc g}g}t|D]}|turA|r?t|ddzt|kr||Lt |dkrA|t |ddt |dn(|tt ||g}t |dkrA|t |ddt |dn(|tt |d|S)Nr-,) sortedrordappendlenrextendmapjoin)r/out current_rangecs rnice_char_groupr@/sa CM E]] M ! !m !M"O4P4PRRSSSS 3y-00111 88C==rState TransitionKeyceZdZedZdZdZdefdZdZ de e e e feffdZd Zd Zdd ZedZddZdZdS)Alphabetc|jSr()_by_transitionrs r by_transitionzAlphabet.by_transitionGs ""rc|g}dt|jD]p\}}|t |t |ft |ddkrt |ddqdfd|DS)Nrr1 c30K|]\}}|d|VdS)z | Nr).0abwidths r z#Alphabet.__str__..Rs:>>$!QAu---!-->>>>>>r)r6rFitemsr8r@strr9r<)rr=tksymbolsrNs @rrzAlphabet.__str__Ks!$"5";";"="=>> ( (KB JJ00#b'': ; ; ;3r71:&&CGAJyy>>>>#>>>>>>rc@t|jd|jdS)N())typer_symbol_mappingrs rr"zAlphabet.__repr__Ts%t**%AA(<AAAArreturnc*t|jSr()r9rXrs r__len__zAlphabet.__len__Ws4'(((rc*t|jSr()iterrXrs r__iter__zAlphabet.__iter__ZsD()))rsymbol_mappingc||_tt}|jD] \}}|||!t ||_dSr()rXrlistrPr8dictrF)rr_rGsts r__init__zAlphabet.__init__]sk-#D)) (..00 ' 'DAq !  # #A & & & &"=11rcr||jvr"t|jvr|jtSdS|j|Sr()rXrritems r __getitem__zAlphabet.__getitem__ds? t+ + + 444+M::t'- -rc||jvSr()rXrgs r __contains__zAlphabet.__contains__mst+++r alphabets?Tuple[Alphabet, Tuple[Dict[TransitionKey, TransitionKey], ...]]c$ tjdD}fd|D}tt}|D] \}}|||!dt |D t fd|D}dD} D] \}}t||D] \} } | | |< !|t|fS)Nc3HK|]}|jVdSr()rXkeys)rKrLs rrOz!Alphabet.union..qs1)V)Vq!*;*@*@*B*B)V)V)V)V)V)VrcJi|]tfdDS)c3(K|] }|V dSr(rrKrLsymbols rrOz,Alphabet.union...rs''E'Ea& 'E'E'E'E'E'Ertuple)rKrtrls @r z"Alphabet.union..rs9```&&%'E'E'E'E9'E'E'E"E"E```rci|]\}}|| SrrrKiks rrwz"Alphabet.union..vCCC1q!CCCrc2i|]\}}|D] }|| SrrrKrprSrt keys_to_keys rrwz"Alphabet.union..wI222,tW)022%";t#42222rcg|]}iSrrrK_s r z"Alphabet.union..zs555ar555r) frozensetunionrrarPr8 enumeraterDziprv) rl all_symbolssymbol_to_keyskeys_to_symbolsrtrpresultnew_to_old_mappingsnew_keyold_key new_to_oldrs ` @rrzAlphabet.unionps^'ikk')V)VI)V)V)VW ````T_```%d++*0022 1 1LFD D ! ( ( 0 0 0 0CC /(B(BCCC 22220?0E0E0G0G22233659555(..00 . .MD''*41D'E'E . .#&- 7## .u01111rcNtdt|DS)Nc>i|]\}}|D]}|t|Sr)rB)rKrzgrouprcs rrwz(Alphabet.from_groups..s5^^^EX]^^STM!,,^^^^r)rDr)clsgroupss r from_groupszAlphabet.from_groupss'^^Yv=N=N^^^___rr%ctjj}fd|D}tt}|D] \}}|||!dt|Dtfd|D}dfD}dfD} D]=\}} t||| D]&\} } } | | | | | | <'>|t| fS)NcNi|] tfdfD!S)c3(K|] }|V dSr(rrss rrOz0Alphabet.intersect...s''I'Ia& 'I'I'I'I'I'Irru)rKrtr%rs @rrwz&Alphabet.intersect..s=dddf&%'I'I'I'ID%='I'I'I"I"Idddrci|]\}}|| Srrrys rrwz&Alphabet.intersect..r|rc2i|]\}}|D] }|| Srrr~s rrwz&Alphabet.intersect..rrc6g|]}ttSr)rrars rrz&Alphabet.intersect..s HHHQ{400HHHrcg|]}iSrrrs rrz&Alphabet.intersect..s999ar999r) rrX intersectionrrarPr8rrDrrv)rr%rrrrtrprold_to_new_mappingsrrr old_to_newrrs`` @r intersectzAlphabet.intersects 455BB5CXYY dddddXcddd%d++*0022 1 1LFD D ! ( ( 0 0 0 0CC /(B(BCCC 22220?0E0E0G0G22233IH4-HHH99D%=999(..00 . .MD'36t=PRe3f3f . ./Z7#**7333&- 7## .u01111rcNt|jSr()rDrXcopyrs rrz Alphabet.copys,1133444rN)rlrDrYrm)r%rDrYrm)rrrpropertyrGrr"intr[r^rr rQrrBrerirkr classmethodrrrrrrrDrDFs ##X#???BBB)))))***2tE#7G2G,H-,W'X2222...,,,2222 ``[`2222$55555rrDceZdZdZdS) OblivionErroraJ This exception is thrown while `crawl()`ing an FSM if we transition to the oblivion state. For example while crawling two FSMs in parallel we may transition to the oblivion state of both FSMs at once. This warrants an out-of-bound signal which will reduce the complexity of the new FSM's map. N)rrrr.rrrrrs  DrrceZdZUdZeed<eed<eeed<eeed<eeee effed<dZ dd defd Z d e fd Z d ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdddefdZd Z d!Z!d"Z"d#Z#d9d%Z$d&Z%d'Z&d(Z'd)Z(d*Z)d+Z*d,Z+d-Z,d.Z-d/Z.d0Z/d1Z0d2Z1d3Z2d4Z3d5Z4d6Z5d7Z6d8Z7d$S):FSMa* A Finite State Machine or FSM has an alphabet and a set of states. At any given moment, the FSM is in one state. When passed a symbol from the alphabet, the FSM jumps to another state (or possibly the same state). A map (Python dictionary) indicates where to jump. One state is nominated as a starting state. Zero or more states are nominated as final states. If, after consuming a string of symbols, the FSM is in a final state, then it is said to "accept" the string. This class also has some pretty powerful methods which allow FSMs to be concatenated, alternated between, multiplied, looped (Kleene star closure), intersected, and simplified. The majority of these methods are available using operator overloads. alphabetinitialstatesfinalsr;c td)z.Immutability prevents some potential problems.zThis object is immutable.) Exception)rnamevalues r __setattr__zFSM.__setattr__s3444rF)__no_validation__c |s't|tstd||vr2tdt |zdzt |z||s2tdt |zdzt |z|D]q}||D]f}||||vrTtdt |zdzt |zdzt |||zd zgr||jd <t||jd <||jd <t||jd <||jd<dS)a~ `alphabet` is an iterable of symbols the FSM can be fed. `states` is the set of states for the FSM `initial` is the initial state `finals` is the set of accepting states `map` may be sparse (i.e. it may omit transitions). In the case of omitted transitions, a non-final "oblivion" state is simulated. zExpected an Alphabet instancezInitial state z must be one of z Final states z must be a subset of zTransition for state z and symbol z leads to z, which is not a staterrrrr;N) isinstancerD TypeErrorrreprissubsetrp__dict__r) rrrrrr;rstaterts rrez FSM.__init__s! Ph11 A ?@@@f$$ 04== @CU UX\]cXdXd deee??6** i$v,, >AX X[_`f[g[g ghhh P P!%jPPFu:f-77'3d5kkANRUYZ`UaUaadppsw #E 6 2t4t446NOPPP8P%- j!"+F"3"3 h#* i "+F"3"3 h" erinputc|j}|D][}t|jvr||jvrt}|j|}||jvr||j|vsdS|j||}\||jvS)a Test whether the present FSM accepts the supplied string (iterable of symbols). Equivalently, consider `self` as a possibly-infinite set of strings and test whether `string` is a member of it. This is actually mainly used for unit testing purposes. If `fsm.anything_else` is in your alphabet, then any symbol not in your alphabet will be converted to `fsm.anything_else`. F)rrrr;r)rrrrt transitions racceptsz FSM.acceptss  0 0F --f 6M6M&v.JTX%%**G*GuuHUOJ/EE ##rc,||S)z This lets you use the syntax `"a" in fsm1` to see whether the string "a" is in the set of strings accepted by `fsm1`. rrstrings rrkzFSM.__contains__s ||F###rcN|S)z A result by Brzozowski (1963) shows that a minimal finite state machine equivalent to the original can be obtained by reversing the original twice. reversedrs rreducez FSM.reduces }}'')))rcd}|dt|jzz }|dt|jzz }|dt|jzz }|dt|jzz }|dt|jzz }|dz }|S)Nzfsm(z alphabet = z , states = z , initial = z , finals = z, map = rV)rrrrrr;rs rr"z FSM.__repr__s-$t}"5"555-$t{"3"333.4 #5#555-$t{"3"333*tDH~~--#  rc bggd}|dt|jD||jD]3}g}||jkr|dn|d|t |||jvr|dn|dt|jD]f\}}||j vrC||j |vr4|t |j ||Q|dg|5g}ttdD]N|tfdttDd zOttD]W}tt|D]2| ||<3Xd d |Ddd DS) N)rzfinal?c34K|]}t|VdSr(r)rKrts rrOzFSM.__str__..s*II9V$$IIIIIIr*rTrueFalserc3hK|],}tt|V-dSr()r9rQ)rKyrowsxs rrOzFSM.__str__..*s9 P P!Sa__!5!5 P P P P P Prr2cg|]}d|zS)r4r)rKcolwidths rrzFSM.__str__..2sAAA8hAAArc3FK|]}d|dzVdS)rrIN)r<)rKrows rrOzFSM.__str__..4s1;;srwws||d*;;;;;;r)r:r6rr8rrrQrrPr;ranger9maxljustinsertr<) rrrrtr colwidthsrrrs @@rrz FSM.__str__ s%$$ II6$-3H3HIIIIII C[  EC $$ 3 2 JJs5zz " " " ## 6"""" 7###&,T]-@-@-B-B&C&C # #" DH$$tx)F)FJJs48E?:#>??@@@@JJrNNNN KK     s47||$$ V VA   S P P P P PuSYY?O?O P P PPPSTT U U U Us4yy!! < .<s/M/M/M /M/M/Mrr2r1c||fh}|krM||jvr>|dz }|j}|||f|kr||jv>|S)a Take a state in the numbered FSM and return a set containing it, plus (if it's final) the first state from the next FSM, plus (if that's final) the first state from the next but one FSM, plus... r2)rradd)rzsubstaterfsms last_indexs r connect_allz$FSM.concatenate..connect_all?su (m_Fj..Xa%?%?Q7? Ax=)))j..Xa%?%?Mrc<|D]\}}|kr |jvrdSdS)z7If you're in a final state of the final FSM, it's finalTFr)rrzrlastrs rfinalzFSM.concatenate..finalTs8!&  H ??x4;'>'>445rc 0t}|D]m\}}|}||jvrW|||j|vr<|||j|||n|stt |S)z Follow the collection of states through all FSMs at once, jumping to the next FSM if we reach the end of the current one TODO: improve all follow() implementations to allow for dead metastates? )setr;updaterr) currentnew_transitionnextrzrrrrrs rfollowzFSM.concatenate..follow[s 55D!( b b H1gsw&&:a=+HCGT\L]+]+]KK Aswx/@A~A^/_ ` `aaa $##T?? "r) r9epsilonrDrrrrrcrawl) rrrrrrrrrs ` @@@@r concatenatezFSM.concatenate6s& t99>>8B<<(( ('~/M/M/M/M/MN*t99q=$r( D       %% t99q== NN;;q$q'/:: ; ; ;G$$       # # # # # # #Xwv666rc,||S)aK Concatenate two finite state machines together. For example, if self accepts "0*" and other accepts "1+(0|1)", will return a finite state machine accepting "0*1+(0|1)". Accomplished by effectively following non-deterministically. Call using "fsm3 = fsm1 + fsm2" )rr$s r__add__z FSM.__add__ls&&&rcj}jh}fd}fd}t||||}|j|jhz|jd<|S)z If the present FSM accepts X, returns an FSM accepting X* (i.e. 0 or more Xes). This is NOT as simple as naively connecting the final states back to the initial state: see (b*ab)* for example. ct}|D]}|jvr5|j|vr&|j|||jvrMjjvr?|jjvr+|jj||st t |Sr()rr;rrrrr)rrrrrs rrzFSM.star..follows55D! A Atx''J$(8:L,L,LHHTXh/ ;<<<t{** LDH44&$(4<*@@@HHTXdl3J?@@@ $##T?? "rc:tfd|DS)Nc3*K|] }|jvVdSr(r)rKrrs rrOz*FSM.star..final..s*EE8x4;.EEEEEEranyrrs rrzFSM.star..finals&EEEEuEEEEE Err)rrrrr)rrrrrbases` rstarzFSM.starvs} =<. # # # # #$ F F F F FXwv66"&+"> h rcdkrtdtzj}jdfh}fd}fd}t ||||S)O Given an FSM and a multiplier, return the multiplied FSM. rzCan't multiply an FSM by c\|D]'\}}|jkrjjvs|krdS(dS)zAIf the initial state is final then multiplying doesn't alter thatTF)rr)rr iteration multiplierrs rrzFSM.times..finalsJ).  %9t|++!\T[88I.followsD)0 C C%9z))$00&$(8*<<<KK(!3J!? KLLLx)*5DD T\9q=$ABBB4yyA~~##T?? "r)rrrrr)rrrrrrs`` rtimesz FSM.timess >>7$z:J:JJKK K=L!$%       # # # # # #Xwv666rc,||S)r)r)rrs r__mul__z FSM.__mul__szz*%%%rc,t|tS)z Treat `fsms` as a collection of arbitrary FSMs and return the union FSM. Can be used as `fsm1.union(fsm2, ...)` or `fsm.union(fsm1, ...)`. `fsms` may be empty. )parallelrrs rrz FSM.unions c"""rc,||S)a/ Alternation. Return a finite state machine which accepts any sequence of symbols that is accepted by either self or other. Note that the set of strings recognised by the two FSMs undergoes a set union. Call using "fsm3 = fsm1 | fsm2" )rr$s r__or__z FSM.__or__szz%   rc,t|tS)al Intersection. Take FSMs and AND them together. That is, return an FSM which accepts any sequence of symbols that is accepted by both of the original FSMs. Note that the set of strings recognised by the two FSMs undergoes a set intersection operation. Call using "fsm3 = fsm1 & fsm2" )r allr s rrzFSM.intersectionsc"""rc,||S)z Treat the FSMs as sets of strings and return the intersection of those sets in the form of a new FSM. `fsm1.intersection(fsm2, ...)` or `fsm.intersection(fsm1, ...)` are acceptable. )rr$s r__and__z FSM.__and__s   '''rc$t|dS)a Treat `fsms` as a collection of sets of strings and compute the symmetric difference of them all. The python set method only allows two sets to be operated on at once, but we go the extra mile since it's not too hard. c:|ddzdkS)NTr3r2)countrs rz*FSM.symmetric_difference..sw}}T/B/BQ/F1.Lrr r s rsymmetric_differencezFSM.symmetric_differences LLMMMrc,||S)z Symmetric difference. Returns an FSM which recognises only the strings recognised by `self` or `other` but not both. )rr$s r__xor__z FSM.__xor__s ((///rc\j}dji}fd}fd}t||||S)a, Return a finite state machine which will accept any string NOT accepted by self, and will not accept any string accepted by self. This is more complicated if there are missing transitions, because the missing "dead" state must now be reified. rci}d|vr@|djvr1|j|dvrj|d||d<|SNr)r;)rrrrs rrz!FSM.everythingbut..followsWDG|| dh 6 6:RYZ[R\I];];](71:.z:QKrc,d|vo|djv Srrrs rrz FSM.everythingbut..final s U >uQx4;'>? ?r)rrr)rrrrrs` r everythingbutzFSM.everythingbutse=dl#      @ @ @ @ @Xwv666rr%rYcjj\}jjf}fd}fd} t||||dS#t$rYdSwxYw)NcD|\}}|jvr;d|j|vr j|d|}nd}|jvr;d|j|vr j|d|}nd}|r|st||fSNrr2r;r) rrssossnonrr%rs rrzFSM.isdisjoint..followsFBTX~~*Q- ";tx|"K"KXb\*Q- ";<UY:a=#< " #M#MYr]:a=#<= $R $##r6MrcV|djvr|djvr tdSdSr!)rr)rr%rs rrzFSM.isdisjoint..final"s7Qx4;&&58u|+C+C '&+C+CrTF)rrrcrawl_hash_no_resultr)rr%rrrrrs`` @r isdisjointzFSM.isdisjoints#}66u~FF*</                7E6 B B B4   55 sA A$#A$cV j}tj}i jD]U\}}|D];\}}||f vrt ||f< ||f|.followDsg%%K  P P"";??E:3F#N#NOOOO $##[)) )rcj|vSr(rrs rrzFSM.reversed..finalMs<5( (r)rrrr;rPrrr) rrrrtransition_mapr next_staterrr/s ` @rrz FSM.reversed.s = DK(( %)X^^%5%5 A A !E>*8*>*>*@*@ A A& J +;>>.s4NN54;;u;M;MNNNNNNNrrr2Nz Couldn't find an example within z iterations) rrrrrr8popleftr;r6rrG ValueError) rmax_iterations livestatesstringscstatecstringrzrnstatertnstrings ` rrBz FSM.stringsxs&NNNNDKNNNNN '' Z  $$ NNGV, - - -  a ' 1 1 Wf FA!!"(&)9":":>>J!Xf-j9F++&,T]-H-T&U&U>>F&-&8G%44&- #NNGV+<====)a..@.@ !_N!_!_!_``` a a a a arc*|S)zY This allows you to do `for string in fsm1` as a list comprehension! )rBrs rr^z FSM.__iter__s||~~rc0||z S)z Two FSMs are considered equivalent if they recognise the same strings. Or, to put it another way, if their symmetric difference recognises no strings. r;r$s r equivalentzFSM.equivalents u ##%%%rc,||S)zv You can use `fsm1 == fsm2` to determine whether two FSMs recognise the same strings. )rJr$s rr)z FSM.__eq__ u%%%rc2||z S)zr Two FSMs are considered different if they have a non-empty symmetric difference. rIr$s r differentz FSM.differents 5L''))))rc,||S)zo Use `fsm1 != fsm2` to determine whether two FSMs recognise different strings. )rNr$s r__ne__z FSM.__ne__s ~~e$$$rc$t|dS)z Difference. Returns an FSM which recognises only the strings recognised by the first FSM in the list, but none of the others. cB|dot|dd Sr!rrs rrz FSM.difference..s"gaj.QWQRR[AQAQ=Qrrr s r differencezFSM.differences QQRRRrc,||Sr()rSr$s r__sub__z FSM.__sub__su%%%rc:ifdjS) Consider the FSM as a set of strings and return the cardinality of that set, or raise an OverflowError if there are infinitely many ct|r|vr|t||Sd|<d}|jvr|dz }|jvrOj|D]A}|j||t jj|zz }B||<nd|<|Sr!)r9 OverflowErrorrr;r9rrG)rnrget_num_strings num_stringsrs rr[z(FSM.cardinality..get_num_stringss{{5!! 'K''"5)1+E222&u--%) E"DK''FADH$$&*huoyy __TXe_Z-HIICPTP]PklvPwLxLxxx%& E""&' E"u% %rr1)rr[r\s`@@r cardinalityzFSM.cardinalitysC   & & & & & & &0t|,,,rc*|S)rW)r]rs rr[z FSM.__len__s !!!rc0||z Sz Treat `self` and `other` as sets of strings and see if `self` is a subset of `other`... `self` recognises no strings which `other` doesn't. rIr$s rrz FSM.issubsets u ##%%%rc,||Sr`)rr$s r__le__z FSM.__le__ s }}U###rc||ko||kS)z~ Treat `self` and `other` as sets of strings and see if `self` is a proper subset of `other`. rr$s rispropersubsetzFSM.ispropersubset u}..rc,||S)z~ Treat `self` and `other` as sets of strings and see if `self` is a strict subset of `other`. )rdr$s rr&z FSM.__lt__s ""5)))rc0||z Szy Treat `self` and `other` as sets of strings and see if `self` is a superset of `other`. rIr$s r issupersetzFSM.issupersets  ##%%%rc,||Srh)rir$s r__ge__z FSM.__ge__&rLrc||ko||kS)z Treat `self` and `other` as sets of strings and see if `self` is a proper superset of `other`. rr$s rispropersupersetzFSM.ispropersuperset-rerc,||S)z Treat `self` and `other` as sets of strings and see if `self` is a strict superset of `other`. )rmr$s r__gt__z FSM.__gt__4s $$U+++rct|j|j|j|j|jdS)z For completeness only, since `set.copy()` also exists. FSM objects are immutable, so I can see only very odd reasons to need this. Trrrrr;r)rrrrrrr;rs rrzFSM.copy;sc ]''));##%%L;##%% "     rc |j}|D]w}||jvr$t|jvrt|t}||jvr|j||j|vst |j||j|}xt |j|j||j|jdS#t $rt|jcYSwxYw)ao Compute the Brzozowski derivative of this FSM with respect to the input string of symbols. If any of the symbols are not members of the alphabet, that's a KeyError. If you fall into oblivion, then the derivative is an FSM accepting no strings. Trq) rrrKeyErrorr;rrrrnull)rrrrts rderivez FSM.deriveIs 'LE ? ?..(DM99&v...*F))dmF.CtxPU.V.V'' f(=>{{H"&   ' ' ' && & & & 'sB)B,,C  C r()8rrrr.rD__annotations__rArrrBrrerQrrkrr"rrrrrrrr rrrrrboolr)rr5r9r;rBr^rJr)rNrPrSrUr]r[rrbrdr&rirkrmrorrurrrrrs_   NNN J J eT-.// 0000555_d#######@$S$$$$,$$$***)<)<).|sNNNj!_NNNrTrq)rrrbrGrs rrtrtpsV suu tNNx7MNNNOO     rc0t|dhddhidS)zn Return an FSM matching an empty string, "", only. This is very useful in many situations rTrq)rrs rrrs1 ss     rctjd|D\}dt|D}tt|ffd }tt|ffd }t ||||S)z Crawl several FSMs in parallel, mapping the states of a larger meta-FSM. To determine whether a state in the larger FSM is final, pass all of the finality statuses (e.g. [True, False, False] to `test`. cg|] }|j Srrrs rrzparallel..s+I+I+ISCL+I+I+Irc$i|] \}}||jSrr1)rKrzrs rrwzparallel..s >>>(1cq#+>>>rci}|D]W\}}||}||vr@|||jvr1||j||vr|j|||||<X|st|Sr(r")rr fsm_rangerrzfold_transitionrs rrzparallel..follows < :NG|| ae++&!% *;;;% +N;Q   rc8fd|D}|S)Nc<g|]\}}|vo||jvSrr)rKrzrrs rrz+parallel..final..s1SSSXa1:8%(cj"8SSSrr)rrrtests` rrzparallel..finals+SSSSSSStG}}r)rDrrrvr)rrrrrrrs ` @rr r s $>+I+ID+I+I+IJHj>>ioo>>>G38 $2H2H       %Yt__55 7E6 2 22rc|h}t}|rx|}|||||jD]8} |||}||vr||)#t$rY5wxYw|vdSdSr()rpoprrGr) rrrr unvisitedvisitedrrnews rr(r(s IeeG '  E e #0 ' 'J 'fUJ// g%%MM#&&& !     '''''s A88 BBc4|g}t}i}d}|t|kr||}||r||i||<|jD]u} ||| } || } n4#t $r't|} || YnwxYw| ||| <f#t$rYrwxYw|dz }|t|kt|tt|d||dS)a& Given the above conditions and instructions, crawl a new unknown FSM, mapping its states, final states and transitions. Return the new FSM. This is a pretty powerful procedure which could potentially go on forever if you supply an evil version of follow(). rr2Trq) rr9rrGindexr?r8rrr) rrrrrrr;rzrrrjs rrrslYF UUF C A c&kk//q  5<<  JJqMMMA"0 ' 'J 'veZ00 ( T**AA!(((F AMM$'''''(&'Az""!     Q/ c&kk//2 S[[!!     s$ C-B.B43B4 CCN)$r. _collectionsr collectionsr functoolsrtypingrrrr r r r r interegular.utilsr BaseExceptionrrrrQr@rrArBrDrrrrtrr r(rrrrrs@######$$$$$$KKKKKKKKKKKKKKKKKKKK''''''     m   6! "" 8E#/?*?$@A& -- Q5Q5Q5Q5Q5wsM)*Q5Q5Q5h     I   I 'I 'I 'I 'I 'I 'I 'I 'X$   333B'''......r