anchor.diff:      let rec visitDeclarations program predcessors declarations = 
           match declarations with
           | [] ->
  -            program
  -        | _ ->
  -            let decl, tail = List.head declarations, List.tail declarations
  +            program, predcessors
  +        | decl :: tail ->
               match decl with
               | Entity _ ->
                   failwith "Nested types or modules are not allowed"
   
               | InitAction expr ->
  -                let updatedProgram, depOpt = visitExpression None predcessors program expr
  -                let predcessors' = 
  -                    match depOpt with
  -                    | Some op -> predcessors |> Set.add op
  -                    | None -> predcessors
  +                let updatedProgram, predcessors' = visitExpression None predcessors program expr
                   visitDeclarations updatedProgram predcessors' tail
   
               | MemberOrFunctionOrValue (funcOrVal, _, expression) ->
                   if (|Function|) funcOrVal then
                       "Functions declaration" |> notSupported
                   else
  -                    let updatedProgram, _ = 
  +                    let updatedProgram, predcessors' = 
                           visitExpression (Some funcOrVal.FullName) predcessors program expression
  -                    visitDeclarations updatedProgram predcessors tail
  +                    visitDeclarations updatedProgram predcessors' tail
               
       let (|Module|) (x: FSharpEntity) = if x.IsFSharpModule then Some x else None
       
  -    let parseProgramTree (implFile: FSharpImplementationFileContents) =
  -        match implFile.Declarations with
  -        | [Entity(Module _, subdecls)] ->
  -            do printfn "%A" subdecls
  -            visitDeclarations ParsedProgram.empty Set.empty subdecls
  -        | [_] -> 
  -            failwith "Top-level declaration can be module only"
  -        | [] ->
  -            failwith "Empty file"
  -        | _ ->
  -            failwith "Too many declarations"
  +    let parseProgramTree (implFiles: FSharpImplementationFileContents seq) =
  +        let program, _ = 
  +            implFiles
  +            |> Seq.fold (fun (program, predcessors) implFile ->
  +                            match implFile.Declarations with
  +                            | [Entity(Module _, subdecls)] ->
  +                                do printfn "%A" subdecls
  +                                visitDeclarations program predcessors subdecls
  +                            | [_] -> 
  +                                failwith "Top-level declaration can be module only"
  +                            | [] ->
  +                                failwith "Empty file"
  +                            | _ ->
  +                                failwith "Too many declarations")
  +                        (ParsedProgram.empty, Set.empty)
  +        in program        
           
       let parse optSources source = 
           let targetName = tempFileName ()
  
positive.code:                     |> ParsedProgram.addMnemonic name (Output copyOp)
                  | None ->
                      parsedProgram
              updatedProgram, None
  
          | BasicPatterns.Const (objVal, fsType) ->
              let dataType = typeToModel fsType
  
negative.code:                 |> List.exactlyOne
              let errors = ParsingError.ofFSharpErrorInfos checkResults.Errors
              let graph = 
                  parseProgramTree [targetFile]
                  |> ParsedProgram.toComputationGraph
              graph, errors
  
  