úÎYøUúD      !"#$%&'()*+,-./0123456789:;<=>?@ABCNone"The default backend for . Concrete syntax for 1#L', indexed by backend representation in  the typed tagless style  ( -http://okmij.org/ftp/tagless-final/index.html).  Append a 1 to the end of the given .  Append a # to the end of the given . Return a fresh  to be used in a call to  or  . Return a fresh / that has not been used so far in the program. Place a 0 at the given point in the program. Note that a  particular $ may be used only once per program.  Unconditional jump to the given . Case analysis; pops a # from the front of the  scrutinized ), if non-empty. Note that in the default B backend, new labels are automatically created and placed for the  branches of the  . A 1#L program is a D of  s. !Abstract syntax for a variant of 1#, 1#L with labels and . gotos instead of forward and backward jumps. Label representation. A  consists of a , a program counter, and a  E+ from registers to the words they contain. A 1# program is a D of s. "Abstract syntax for the primitive 1# instructions. Register identifiers. !A wrapper around a list of # s with an F instance,  so that literal strings of 1s, #s, and whitespace can be used  instead of lists of %s and $es. This requires the  -XOverloadedStrings flag.  loop :: Word  loop = "1### 11####" #Typed representation of the 1# letters. & Convert a ! back into a G. ' Convert an  to concrete syntax. ( Convert a  to concrete syntax. )Parse a ! into a  ; returns H if an invalid  instruction is found. *Performs the single  indicated by the program  counter, if available. Returns ' Left mach' if a step cannot be  performed, and ' Right mach' with an updated  otherwise. +Given a 0 and the initial state of the registers, return # the final state of the registers. ,Wrapper around + that parses the given ! into a  8, and then runs it in the given register state. Returns 1 the value in register 1 once the program halts. Returns H when either the given ! fails to parse, or D if the machine halts abnormally with an invalid program counter or , values in registers other than register 1. - Convert a 1#  into a semantically-equivalent 1#L   ). May fail with an error if the original  is  non-tidy3, that is it contains forward or backward jumps to & instructions outside of the program. . Convert a 1#L   into a semantically-equivalent 1#   . May fail with an error if the   contains A duplicate labels, jumps to undefined labels. An error will also  occur if the  - contains a goto that would translate into a = jump of 0 instructions, as this is impossible to express in 1#. /AConvenience function to create a fresh label and place it at the  current position. 0 Compiles an  program into an  , with an initial  fresh register. 1 Given an 1 program and an initial register state, and then 1 runs it in the given register state. May return H if the ( program does not halt cleanly, as with +. 2 Given an 1 program and an initial register state, and then 1 runs it in the given register state. May return H if the ( program does not halt cleanly, as with +. 3 Encodes an I type into a ! of backwards-binary  digits using 1s and #s for 1s and 0s, respectively. Note - that the representation of zero is a single # rather than the  empty !. 4 Decodes a !+ containing backwards-binary digits into a J " type. Fails with an error if the ! is empty. 58A combinator to cleanly implement looping structures in  code. -Takes a function that expects two arguments, continue and  break). The body of the function is a block of  code that  gets repeated whenever continue is run. If break is run, 4 control jumps to the instruction after the call to 5. 9 The  to scrutinize.  Run if the  is empty. Run if the front of the  is a 1. Run if the front of the  is a #.  !"#$%&'()*+,-./012345KLM6  !"#$%&'()*+,-./0123456#%$!"& '()*+,  -. 0125/34   !"#%$&'()*+,-./012345KLM Safe-Infered6CYields the successor of the backwards-binary number in register 1. : *Language.TRM> decodeBB <$> phi succBB [(1, encodeBB 0)]  Just 1 < *Language.TRM> decodeBB <$> phi succBB [(1, encodeBB 119)]  Just 120 7EYields the sum of two backwards-binary numbers in registers 1 and 2. K *Language.TRM> decodeBB <$> phi plusBB [(1, encodeBB 2), (2, encodeBB 3)]  Just 5 N *Language.TRM> decodeBB <$> phi plusBB [(1, encodeBB 100), (2, encodeBB 20)]  Just 120 <;Compares the contents of the given registers for equality,  leaving a 1/ in the first register if they are, or nothing @ otherwise. The contents of both registers are destroyed in the  process. >/Add the two argument registers using primitive - recursion, leaving the result in the first. ] *Language.TRM.Programs> decodeBB <$> runL (addBB 1 2) [(1, encodeBB 100), (2, encodeBB 20)]  Just 120 6789 to clear. :Source .  Destination . ;Source .  Destination . <= to increment. >?@ABC6789:;<=>?@ABC6789:;<=>?@BAC6789:;<=>?@ABC Safe-InferedD  !"#$%&'()*+,-./0123456789:;<=>?@ABCN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPNQRNSTNUVNWXYZ[\text-register-machine-0.4.0Language.TRM.BaseLanguage.TRM.Programs Language.TRMLCompLCunLC LSymanticssnocOnesnocHash freshLabelfreshReglabelgotocondLProgram LInstructionLLabelLGotoLCase LSnocHashLSnocOneLabelMachineMprogrampcregsProgram InstructionCaseBackwardForwardSnocHashSnocOneRegisterRWordWLetterHashOne wordToStringinstructionToStringprogramToString parseProgramsteprunphitoLabeledProgramfromLabeledProgramfreshLabelHerecompileLrunLrunL'encodeBBdecodeBBdo_succBB'plusBB'compare'clearmovecopycomparesuccBBaddBBmultBBexptBB unaryToBBdouble bbToUnary vector-0.9.1 Data.VectorVectorcontainers-0.4.2.1Data.MapMapbase Data.StringIsStringGHC.BaseString Data.MaybeNothingGHC.RealIntegralGHC.NumNum$fLSymanticsLComp $fShowWord$fIsStringWord