(136 . 6)(136 . 9)
      -- Carry/Borrow Flag set by certain arithmetical Ops:
      Flag          : WBool        := 0;
      
      -- 'Cutout'-segregated Carry/Borrow Flag:
      CO_Flag       : WBool        := 0;
      
      -- Odometer:
      Ticks         : Natural      := 0;
      
(144 . 11)(147 . 11)
      CommLevel     : Natural      := 0;
      CondLevel     : Natural      := 0;
      
      -- Whether we are currently inside a Proposed Subroutine Name:
      SubNameMode   : Boolean      := False;
      -- The possible Modes of the reader:
      type Modes is (Normal, SubName, SubBody, PrefixOp);
      
      -- Whether we are currently inside a Proposed Subroutine Body:
      SubBodyMode   : Boolean      := False;
      -- Currently-active reader Mode:
      Mode          : Modes        := Normal;
      
      -- Current levels of nestable Blocks when reading a Subroutine Body:
      SubQuoteLevel : Natural      := 0;
(164 . 9)(167 . 8)
      Cutout_Armed  : Boolean      := False;
      Cutout        : Cutouts;
      
      -- Prefixed Operators
      -- Prefix for Prefixed Operators
      PrevC         : Character    := ' ';
      HavePrefix    : Boolean      := False;
      
      -- Current Verdict. We run while 'Mu', Tape remains, and Ticks under max.
      Verdict       : Peh_Verdicts := Mu;
(245 . 10)(247 . 14)
      end Zap_Registers;

      
      -- Zero the Overflow Flag:
      -- Zero the currently-active Overflow Flag:
      procedure Zap_Flag is
      begin
         Flag := 0;
         if Use_CO_Registers then
            CO_Flag := 0;
         else
            Flag    := 0;
         end if;
      end Zap_Flag;
      
      
(483 . 12)(489 . 18)
         end if;
         Write_Newline;
         
         -- Print Overflow-Flag, Ticks and IP:
         Write_String("Flag  :" & WBool'Image(Flag));
         -- Print active Overflow-Flag, then Ticks and IP:
         
         if Use_CO_Registers then
            Write_String("Flag (CO) :" & WBool'Image(CO_Flag));
         else
            Write_String("Flag      :" & WBool'Image(Flag));
         end if;
         
         Write_Newline;
         Write_String("Ticks :" & Natural'Image(Ticks));
         Write_String("Ticks     :" & Natural'Image(Ticks));
         Write_Newline;
         Write_String("IP    :" & Tape_Positions'Image(IP));
         Write_String("IP        :" & Tape_Positions'Image(IP));
         Write_Newline;
      end Print_Trace;
      
(843 . 7)(855 . 13)
                               Y          => Stack(SP),
                               Difference => Stack(SP - 1),
                               Underflow  => F);
               Flag := FFA_Word_NZeroP(F);
               
               -- If we are in the Cutout, write the CO_Flag instead of Flag:
               if Use_CO_Registers then
                  CO_Flag := FFA_Word_NZeroP(F);
               else
                  Flag    := FFA_Word_NZeroP(F);
               end if;
               Drop;
               
               -- Add
(853 . 7)(871 . 13)
                          Y        => Stack(SP),
                          Sum      => Stack(SP - 1),
                          Overflow => F);
               Flag := FFA_Word_NZeroP(F);
               
               -- If we are in the Cutout, write the CO_Flag instead of Flag:
               if Use_CO_Registers then
                  CO_Flag := FFA_Word_NZeroP(F);
               else
                  Flag    := FFA_Word_NZeroP(F);
               end if;
               Drop;
               
               -- Divide and give Quotient and Remainder
(980 . 7)(1004 . 12)
               -- Put the Overflow flag on the stack
            when 'O' =>
               Push;
               FFA_WBool_To_FZ(Flag, Stack(SP));
               -- If we are in the Cutout, read CO_Flag instead of Flag:
               if Use_CO_Registers then
                  FFA_WBool_To_FZ(CO_Flag, Stack(SP));
               else
                  FFA_WBool_To_FZ(Flag,    Stack(SP));
               end if;
               
               -- Print the FZ on the top of the stack
            when '#' =>
(1040 . 7)(1069 . 8)
              |
              '$' -- Pop top of Stack into the following Register...
              =>
               HavePrefix := True;
               -- Set the Prefixed Op Mode. Next Symbol is treated as prefixed:
               Mode := PrefixOp;
               
               -----------
               -- Loops --
(1083 . 7)(1113 . 7)
               -- Save the NEXT IP as the first Symbol of the proposed Name:
               Proposed_Sub.Name.L := Next_IP_On_Tape;
               -- Enter the Name mode:
               SubNameMode         := True;
               Mode                := SubName;
               -- We will remain in Name mode until we see a @ or ! .
               
               -- '!' invokes a previously-defined Subroutine:
(1201 . 7)(1231 . 7)
                  when 'D' =>
                     Zap_Data_Stack;
                     
                  -- ... Overflow Flag:
                  -- ... Overflow Flag (if in Cutout, zaps CO_Flag) :
                  when 'F' =>
                     Zap_Flag;
                     
(1401 . 7)(1431 . 138)
      
      ------------------------------------------------------------------------
      
      -- Process a Symbol
      -- Process a character in a proposed Subroutine Name:
      procedure SubName_Symbol(C : in Character) is
      begin
         case C is
            -- Attempt to INVOKE the named Subroutine:
            when '!' =>
               -- Detect attempt to invoke a Sub with no Name:
               if IP = Proposed_Sub.Name.L then
                  E("Attempted to invoke a nameless Subroutine!");
               end if;
               -- Exit the Sub Name mode and enter Normal mode:
               Mode := Normal;
               -- Attempt to invoke the subroutine:
               Invoke_Named_Subroutine(Proposed_Sub.Name);
               
               -- Attempt to read a body for a Subroutine Definition:
            when '@' =>
               -- Detect attempt to define a Sub with no Name:
               if IP = Proposed_Sub.Name.L then
                  E("Attempted to define a nameless Subroutine!");
               end if;
               -- Save NEXT IP as the beginning of the proposed Body:
               Proposed_Sub.Payload.L := Next_IP_On_Tape;
               -- Exit the Name mode and enter Sub Body mode:
               Mode                   := SubBody;
               
               -- Any permissible Symbol in a Subroutine Name:
            when '0' .. '9' | 'A' .. 'Z' | 'a' .. 'z' | '-' | '_'  =>
               -- Save IP as the potential end of the proposed Sub Name:
               Proposed_Sub.Name.R    := IP;
               
            when others =>
               E("Symbol '" & C & "' is prohibited in a Subroutine Name !");
         end case;
      end SubName_Symbol;
      
      ------------------------------------------------------------------------
      
      -- Process a character in a proposed Subroutine Body:
      procedure SubBody_Symbol(C : in Character) is
         
         -- Name of Proposed Subroutine (for eggogs) :
         Name : String
           := String(Tape(Proposed_Sub.Name.L .. Proposed_Sub.Name.R));
         
      begin
         case C is
            -- Subroutine Terminator:
            when ';' =>
               -- Only takes effect if NOT in a Comment or Quote Block:
               if SubCommLevel = 0 and SubQuoteLevel = 0 then
                  if SubCondLevel /= 0 then
                     E("Conditional Return in Subroutine: '"
                         & Name & "' is Prohibited!" &
                         " (Please check for unbalanced '{'.)'");
                  end if;
                  -- Now, Sub-Comm, Quote, and Cond levels are 0.
                  -- The ';' becomes last Symbol of the new Sub's Body.
                  -- Test for attempt to define a Sub with a null Body:
                  if IP = Proposed_Sub.Payload.L then
                     E("Null Body in Subroutine: '" & Name 
                         & "' is prohibited!");
                  end if;
                  -- Intern this new Sub definition:
                  Proposed_Sub.Payload.R := IP;
                  -- Exit the Sub Body mode and enter Normal mode:
                  Mode                   := Normal;
                  -- Attempt to intern the Proposed Subroutine:
                  Intern_Subroutine(Proposed_Sub);
               end if;
               
               -- Begin-Comment inside a Subroutine Body:
            when '(' =>
               SubCommLevel := SubCommLevel + 1;
               
               -- End-Comment inside a Subroutine Body:
            when ')' =>
               -- If cannot drop Sub Comment level:
               if SubCommLevel = 0 then
                  E("Unbalanced ')' in Body of Subroutine: '"
                      & Name & "' !");
               end if;
               SubCommLevel := SubCommLevel - 1;
               
               -- Begin-Quote inside a Subroutine Body:
            when '[' =>
               -- Ignore if Commented:
               if SubCommLevel = 0 then
                  SubQuoteLevel := SubQuoteLevel + 1;
               end if;
               
               -- End-Quote inside a Subroutine Body:
            when ']' =>
               -- Ignore if Commented:
               if SubCommLevel = 0 then
                  -- If cannot drop Sub Quote level:
                  if SubQuoteLevel = 0 then
                     E("Unbalanced ']' in Body of Subroutine: '"
                         & Name & "' !");
                  end if;
                  SubQuoteLevel := SubQuoteLevel - 1;
               end if;
               
               -- Begin-Conditional inside a Subroutine Body:
            when '{' =>
               -- Ignore if Commented or Quoted:
               if SubCommLevel = 0 and SubQuoteLevel = 0 then
                  SubCondLevel := SubCondLevel + 1;
               end if;
               
               -- End-Conditional inside a Subroutine Body:
            when '}' =>
               -- Ignore if Commented or Quoted:
               if SubCommLevel = 0 and SubQuoteLevel = 0 then
                  -- If cannot drop Sub Conditional level:
                  if SubCondLevel = 0 then
                     E("Unbalanced '}' in Body of Subroutine: '"
                         & Name & "' !");
                  end if;
                  SubCondLevel := SubCondLevel - 1;
               end if;
               
               -- All other Symbols have no special effect in Sub Body :
            when others =>
               null; -- Stay in Body mode until we see the ';'.
         end case;
      end SubBody_Symbol;
      
      
      ------------------------------------------------------------------------
      
      -- All Peh Symbols begin their processing here :
      procedure Op(C : in Character) is
      begin
         
(1454 . 151)(1615 . 42)
                  null; -- Other symbols have no effect on the level
            end case;
            
            --- ... in a proposed Subroutine Name:
         elsif SubNameMode then
            case C is
         else
            --- ... we are not inside a 'Block' :
            
            case Mode is
               
               -- Attempt to INVOKE the named Subroutine:
               when '!' =>
                  -- Detect attempt to invoke a Sub with no Name:
                  if IP = Proposed_Sub.Name.L then
                     E("Attempted to invoke a nameless Subroutine!");
                  end if;
                  -- Exit the Name mode:
                  SubNameMode := False;
                  -- Attempt to invoke the subroutine:
                  Invoke_Named_Subroutine(Proposed_Sub.Name);
               --- ... a character in a proposed Subroutine Name:
               when SubName =>
                  SubName_Symbol(C);
                  
               -- Attempt to read a body for a Subroutine Definition:
               when '@' =>
                  -- Detect attempt to define a Sub with no Name:
                  if IP = Proposed_Sub.Name.L then
                     E("Attempted to define a nameless Subroutine!");
                  end if;
                  -- Save the NEXT IP as the beginning of the proposed Body:
                  Proposed_Sub.Payload.L := Next_IP_On_Tape;
                  -- Exit the Name mode:
                  SubNameMode            := False;
                  -- Enter Sub Body mode:
                  SubBodyMode            := True;
               --- ... a character in a proposed Subroutine Body:
               when SubBody =>
                  SubBody_Symbol(C);
                  
               -- Any permissible Symbol in a Subroutine Name:
               when '0' .. '9' | 'A' .. 'Z' | 'a' .. 'z' | '-' | '_'  =>
                  -- Save IP as the potential end of the proposed Sub Name:
                  Proposed_Sub.Name.R := IP;
               --- ... the second character of a Prefixed Op:
               when PrefixOp =>
                  -- Drop prefix-op hammer, until another prefix-op cocks it:
                  Mode := Normal;
            
                  -- Dispatch this op, where prefix is the preceding character
                  Op_Prefixed(Prefix => PrevC, O => C);
                  
               -- This is a Normal Op...
               when Normal =>
                  -- ... so proceed with the normal rules:
                  Op_Normal(C);
                  
                  -- Save the current Symbol as a possible prefix:
                  PrevC := C;
                  
               when others =>
                  E("Symbol '" & C & "' is prohibited in a Subroutine Name !");
            end case;
            
            --- ... in a proposed Subroutine Body:
         elsif SubBodyMode then
            declare
               -- Name of Proposed Subroutine (for eggogs) :
               Name : String
                 := String(Tape(Proposed_Sub.Name.L .. Proposed_Sub.Name.R));
            begin
               case C is
                  -- Subroutine Terminator:
                  when ';' =>
                     -- Only takes effect if NOT in a Comment or Quote Block:
                     if SubCommLevel = 0 and SubQuoteLevel = 0 then
                        if SubCondLevel /= 0 then
                           E("Conditional Return in Subroutine: '"
                               & Name & "' is Prohibited!" &
                               " (Please check for unbalanced '{'.)'");
                        end if;
                        -- Now, Sub-Comm, Quote, and Cond levels are 0.
                        -- The ';' becomes last Symbol of the new Sub's Body.
                        -- Test for attempt to define a Sub with a null Body:
                        if IP = Proposed_Sub.Payload.L then
                           E("Null Body in Subroutine: '" & Name 
                               & "' is prohibited!");
                        end if;
                        -- Exit Body mode, and intern this new Sub definition:
                        Proposed_Sub.Payload.R := IP;
                        -- Exit the Sub Body mode:
                        SubBodyMode            := False;
                        -- Attempt to intern the Proposed Subroutine:
                        Intern_Subroutine(Proposed_Sub);
                     end if;
                     
                     -- Begin-Comment inside a Subroutine Body:
                  when '(' =>
                     SubCommLevel := SubCommLevel + 1;
                     
                     -- End-Comment inside a Subroutine Body:
                  when ')' =>
                     -- If cannot drop Sub Comment level:
                     if SubCommLevel = 0 then
                        E("Unbalanced ')' in Body of Subroutine: '"
                            & Name & "' !");
                     end if;
                     SubCommLevel := SubCommLevel - 1;
                     
                     -- Begin-Quote inside a Subroutine Body:
                  when '[' =>
                     -- Ignore if Commented:
                     if SubCommLevel = 0 then
                        SubQuoteLevel := SubQuoteLevel + 1;
                     end if;
                     
                     -- End-Quote inside a Subroutine Body:
                  when ']' =>
                     -- Ignore if Commented:
                     if SubCommLevel = 0 then
                        -- If cannot drop Sub Quote level:
                        if SubQuoteLevel = 0 then
                           E("Unbalanced ']' in Body of Subroutine: '"
                               & Name & "' !");
                        end if;
                        SubQuoteLevel := SubQuoteLevel - 1;
                     end if;
                     
                     -- Begin-Conditional inside a Subroutine Body:
                  when '{' =>
                     -- Ignore if Commented or Quoted:
                     if SubCommLevel = 0 and SubQuoteLevel = 0 then
                        SubCondLevel := SubCondLevel + 1;
                     end if;
                     
                     -- End-Conditional inside a Subroutine Body:
                  when '}' =>
                     -- Ignore if Commented or Quoted:
                     if SubCommLevel = 0 and SubQuoteLevel = 0 then
                        -- If cannot drop Sub Conditional level:
                        if SubCondLevel = 0 then
                           E("Unbalanced '}' in Body of Subroutine: '"
                               & Name & "' !");
                        end if;
                        SubCondLevel := SubCondLevel - 1;
                     end if;
                     
                     -- All other Symbols have no special effect in Sub Body :
                  when others =>
                     null; -- Stay in Body mode until we see the ';'.
               end case;
            end;
            --- ... if in a prefixed op:
         elsif HavePrefix then
            
            -- Drop the prefix-op hammer, until another prefix-op cocks it
            HavePrefix := False;
            
            -- Dispatch this op, where prefix is the preceding character
            Op_Prefixed(Prefix => PrevC, O => C);
            
         else
            -- This is a Normal Op, so proceed with the normal rules.
            Op_Normal(C);
            
         end if;
         
         -- In all cases, save the current Symbol as possible prefix:
         PrevC := C;
         
      end Op;
      
      ------------------------------------------------------------------------
      
      -----------------------------
      -- Start of Tape Execution --
      -----------------------------
(1652 . 23)(1704 . 33)
      -- At this point, the Tape has halted.
      
      ------------------------------------------------------------------
      -- The following types of Unclosed Blocks trigger a Eggog Verdict:
      -- Termination in a Mode other than 'Normal' triggers a Eggog Verdict:
      
      -- Unclosed Subroutine Name at Tape's End:
      if SubNameMode then
         E("The Subroutine Name at IP:"
             & Tape_Positions'Image(Proposed_Sub.Name.L)
             & " is Unterminated!");
      end if;
      
      -- Unclosed Subroutine Body at Tape's End:
      if SubBodyMode then
         E("The Body of Subroutine: '" 
             & String(Tape(Proposed_Sub.Name.L .. Proposed_Sub.Name.R)) 
             & "' is Unterminated!");
      end if;
      case Mode is
         
         -- Unclosed Subroutine Name at Tape's End:
         when SubName =>
            E("The Subroutine Name at IP:"
                & Tape_Positions'Image(Proposed_Sub.Name.L)
                & " is Unterminated!");
            
         -- Unclosed Subroutine Body at Tape's End:
         when SubBody =>
            E("The Body of Subroutine: '" 
                & String(Tape(Proposed_Sub.Name.L .. Proposed_Sub.Name.R)) 
                & "' is Unterminated!");
            
         -- Incomplete Prefix Op at Tape's End:
         when PrefixOp =>
            E("Prefix Op: '" & PrevC & "' is Unterminated at End of Tape!");
            
         -- This is the expected Mode at Tape's End:
         when Normal =>
            null;
            
      end case;
      
      -- Unclosed Cutout:
      -- Unclosed Cutout triggers a Eggog Verdict:
      if Cutout_Begun and not Cutout_Armed then
         E("The Cutout declaration 'LC' at IP:"
             & Tape_Positions'Image(Cutout.L) & " is Unterminated!");