anchor.diff:  
               psp |> ParseState.``Match and Advance`` (this.``s-indent(n)`` psp) (this.``ns-l-block-map-entry``)
               |>  function
  -                |   Value(ck, cv, prs)  ->  ``ns-l-compact-mapping`` prs ((ck,cv) :: acc)
  +                |   Value((ck, cv), prs)  ->  ``ns-l-compact-mapping`` prs ((ck,cv) :: acc)
                   |   NoResult            ->  contentOrNone NoResult psp
                   |   ErrorResult e       ->  psp |> ParseState.AddErrorMessageList e |> contentOrNone (ErrorResult e)
           match (this.``ns-l-block-map-entry`` ps) with
  -        |   Value(ck, cv, prs) -> ``ns-l-compact-mapping`` prs [(ck,cv)]
  +        |   Value((ck, cv), prs) -> ``ns-l-compact-mapping`` prs [(ck,cv)]
           |   NoResult   -> NoResult
           |   ErrorResult e -> ErrorResult e
           |> ParseState.TrackParseLocationSR ps
  
positive.code:         |> this.logResultSR
  
      //  [188]   http://www.yaml.org/spec/1.2/spec.html#ns-l-block-map-entry(n)
      member this.``ns-l-block-map-entry`` (ps:ParseState) : ParseFuncMappedResult = 
          logger "ns-l-block-map-entry" ps
          (ps |> ParseState.OneOf) {
              either (this.``c-l-block-map-explicit-entry``)
              either (this.``ns-l-block-map-implicit-entry``)
              ifneither (NoResult)
          }
          |> ParseState.PreserveErrorsMR ps
          |> ParseState.TrackParseLocationMR ps
          |> ParseState.AddSuccessMR "ns-l-block-map-entry" ps
          |> this.logResultMR
  
      //  [189]   http://www.yaml.org/spec/1.2/spec.html#c-l-block-map-explicit-entry(n)
      member this.``c-l-block-map-explicit-entry`` (ps:ParseState) : ParseFuncMappedResult=
          logger "c-l-block-map-explicit-entry" ps
          match (this.``c-l-block-map-explicit-key`` ps) with
          |   Value(ck, prs1) ->
              let noResult prs1 =
                  prs1 |> ParseState.``Match and Advance`` (this.``e-node``) (fun prs2 -> Value(ck, this.ResolvedNullNode prs2, prs2))
                  |>  function
                      |   ErrorResult _
                      |   NoResult    ->  raise (ParseException "Cannot identify mapping value")
                      |   v           ->  v
              match (this.``l-block-map-explicit-value`` prs1) with
              |   Value (cv, prs1) -> Value(ck, cv, prs1)
              |   NoResult  -> prs1 |> noResult
              |   ErrorResult e -> prs1 |> ParseState.AddErrorMessageList e |> noResult
          |   NoResult -> NoResult
          |   ErrorResult e -> ErrorResult e
          |> ParseState.TrackParseLocationMR ps
          |> ParseState.AddSuccessMR "c-l-block-map-explicit-entry" ps
          |> this.logResultMR
  
      //  [190]   http://www.yaml.org/spec/1.2/spec.html#c-l-block-map-explicit-key(n)
      member this.``c-l-block-map-explicit-key`` ps : ParseFuncSingleResult =
          logger "c-l-block-map-explicit-key" ps
          ps |> ParseState.``Match and Advance`` (RGP "\\?") (fun prs ->
              this.``s-l+block-indented`` (prs |> ParseState.SetStyleContext ``Block-out``)
  
negative.code:             fun (any,prs) -> 
                  printfn "/%s l:%d i:%d c:%A &a:%d e:%d w:%d" str (prs.Location.Line) (prs.n) (prs.c) (prs.Anchors.Count) (prs.Messages.Error.Length) (prs.Messages.Warn.Length) 
                  any, asc (prs, str, ps))
  
      let SetRestString s (ps:ParseState) = ps.SetRestString s
  
  