anchor.diff:  // Additional data structures used by checking recursive bindings
   //------------------------------------------------------------------------- 
   
  -[<RequireQualifiedAccess>]
  -type MutRecShape<'TypeData, 'LetsData, 'ModuleData,'OpenData> = 
  -    | Tycon of 'TypeData
  -    | Lets of 'LetsData
  -    | Module of 'ModuleData * MutRecShape<'TypeData, 'LetsData, 'ModuleData,'OpenData> list
  -    | Open of 'OpenData
  -
  -module MutRecShapes = 
  -   let rec map f1 f2 f3 x = 
  -       x |> List.map (function 
  -           | MutRecShape.Open a -> MutRecShape.Open a
  -           | MutRecShape.Tycon a -> MutRecShape.Tycon (f1 a)
  -           | MutRecShape.Lets b -> MutRecShape.Lets (f2 b)
  -           | MutRecShape.Module (c,d) -> MutRecShape.Module (f3 c, map f1 f2 f3 d))
  -
  -
  -   let mapTycons f1 xs = map f1 id id xs
  -   let mapTyconsAndLets f1 f2 xs = map f1 f2 id xs
  -   let mapLets f2 xs = map id f2 id xs
  -   let mapModules f1 xs = map id id f1 xs
  -
  -   let rec mapWithEnv f1 f2 (env: 'Env) x = 
  -       x |> List.map (function 
  -           | MutRecShape.Open a -> MutRecShape.Open a
  -           | MutRecShape.Tycon a -> MutRecShape.Tycon (f1 env a)
  -           | MutRecShape.Lets b -> MutRecShape.Lets (f2 env b)
  -           | MutRecShape.Module ((c, env2),d) -> MutRecShape.Module ((c,env2), mapWithEnv f1 f2 env2 d))
  -
  -   let mapTyconsWithEnv f1 env xs = mapWithEnv f1 (fun _env x -> x) env xs
  -
  -   let rec mapWithParent parent f1 f2 f3 xs = 
  -       xs |> List.map (function 
  -           | MutRecShape.Open a -> MutRecShape.Open a
  -           | MutRecShape.Tycon a -> MutRecShape.Tycon (f2 parent a)
  -           | MutRecShape.Lets b -> MutRecShape.Lets (f3 parent b)
  -           | MutRecShape.Module (c,d) -> 
  -               let c2, parent2 = f1 parent c
  -               MutRecShape.Module (c2, mapWithParent parent2 f1 f2 f3 d))
  -
  -   let rec computeEnvs f1 f2 (env: 'Env) xs = 
  -       let env = f2 env xs
  -       env, 
  -       xs |> List.map (function 
  -           | MutRecShape.Open a -> MutRecShape.Open a
  -           | MutRecShape.Tycon a -> MutRecShape.Tycon a
  -           | MutRecShape.Lets b -> MutRecShape.Lets b
  -           | MutRecShape.Module (c,ds) -> 
  -               let env2 = f1 env c
  -               let env3, ds2 = computeEnvs f1 f2 env2 ds
  -               MutRecShape.Module ((c,env3), ds2))
  -
  -   let rec extendEnvs f1 (env: 'Env) xs = 
  -       let env = f1 env xs
  -       env, 
  -       xs |> List.map (function 
  -           | MutRecShape.Module ((c,env),ds) -> 
  -               let env2, ds2 = extendEnvs f1 env ds
  -               MutRecShape.Module ((c,env2), ds2)
  -           | x -> x)
  -
  -   let dropEnvs xs = xs |> mapModules fst
  -
  -   let rec expandTycons f1 env xs = 
  -       let preBinds, postBinds = 
  -           xs |> List.map (fun elem -> 
  -               match elem with 
  -               | MutRecShape.Tycon a -> f1 env a
  -               | _ -> [], [])
  -            |> List.unzip
  -       [MutRecShape.Lets (List.concat preBinds)] @ 
  -       (xs |> List.map (fun elem -> 
  -           match elem with 
  -           | MutRecShape.Module ((c,env2),d) -> MutRecShape.Module ((c,env2), expandTycons f1 env2 d)
  -           | _ -> elem)) @
  -       [MutRecShape.Lets (List.concat postBinds)] 
  -
  -   let rec mapFoldWithEnv f1 z env xs = 
  -       (z,xs) ||> List.mapFold (fun z x ->
  -           match x with
  -           | MutRecShape.Module ((c,env2),ds) -> let ds2,z = mapFoldWithEnv f1 z env2 ds in MutRecShape.Module ((c, env2), ds2),z
  -           | _ -> let x2,z = f1 z env x in x2, z)
  -
  -
  -   let rec collectTycons x = 
  -       x |> List.collect (function 
  -           | MutRecShape.Tycon a -> [a]
  -           | MutRecShape.Module (_,d) -> collectTycons d
  -           | _ -> [])
  -
  -   let topTycons x = 
  -       x |> List.choose (function MutRecShape.Tycon a -> Some a | _ -> None)
  -
  -   let rec iter f1 f2 f3 f4 x = 
  -       x |> List.iter (function 
  -           | MutRecShape.Tycon a -> f1 a
  -           | MutRecShape.Lets b -> f2 b
  -           | MutRecShape.Module (c,d) -> f3 c; iter f1 f2 f3 f4 d
  -           | MutRecShape.Open a -> f4 a)
  -
  -   let iterTycons f1 x = iter f1 ignore ignore ignore  x
  -   let iterModules f1 x = iter ignore ignore f1 ignore  x
  -
  -   let rec iterWithEnv f1 f2 f3 env x = 
  -       x |> List.iter (function 
  -           | MutRecShape.Tycon a -> f1 env a
  -           | MutRecShape.Lets b -> f2 env b
  -           | MutRecShape.Module ((_,env),d) -> iterWithEnv f1 f2 f3 env d
  -           | MutRecShape.Open a -> f3 env a)
  -
  -   let iterTyconsWithEnv f1 env xs = iterWithEnv f1 (fun _env _x -> ()) (fun _env _x -> ()) env xs
   
   type RecDefnBindingInfo = RecDefnBindingInfo of ContainerInfo * NewSlotsOK * DeclKind * SynBinding
   
  
positive.code:       Binding: Tast.Binding }
  
  
  let EliminateInitializationGraphs g mustHaveArity denv (fixupsAndBindingsWithoutLaziness : PreInitializationGraphEliminationBinding list) bindsm =
      // BEGIN INITIALIZATION GRAPHS 
      // Check for safety and determine if we need to insert lazy thunks 
      let fixupsl =  fixupsAndBindingsWithoutLaziness |> List.map (fun b -> b.FixupPoints)
      let bindsWithoutLaziness =  fixupsAndBindingsWithoutLaziness |> List.map (fun b -> b.Binding)
      let rvs = bindsWithoutLaziness |> List.map (fun (TBind(v,_,_)) -> mkLocalValRef v) 
  
      // The output of the analysis
      let outOfOrder = ref false
  
negative.code: 
          and CheckExprOp st op m = 
              match op with 
              | TOp.LValueOp (_,lvr) -> CheckValRef (strict st) lvr m
              | _ -> ()
            
          and CheckValRef st (v: ValRef) m = 
              match st with 
              | MaybeLazy -> 
                  if recursiveVals.TryFind v.Deref |> Option.isSome then 
                      warning (RecursiveUseCheckedAtRuntime (denv,v,m)) 
                      if not !reportedEager then 
                        (warning (LetRecCheckedAtRuntime m); reportedEager := true)
                      runtimeChecks := true
  
              | Top | DefinitelyStrict ->
                  if recursiveVals.TryFind v.Deref |> Option.isSome then 
                      if availIfInOrder.TryFind v.Deref |> Option.isNone then 
                          warning (LetRecEvaluatedOutOfOrder (denv,boundv,v,m)) 
                          outOfOrder := true
                          if not !reportedEager then 
                            (warning (LetRecCheckedAtRuntime m); reportedEager := true)
                      definiteDependencies := (boundv,v) :: !definiteDependencies
              | InnerTop -> 
                  if recursiveVals.TryFind v.Deref |> Option.isSome then 
                      directRecursiveData := true
              | DefinitelyLazy -> () 
          and checkDelayed st b = 
  