anchor.diff:              let updatedProgram = 
                   parsedProgram
                   |> ParsedProgram.addMnemonic name (Const (serializeConst objVal, dataType))
  -            updatedProgram, None
  +            updatedProgram, predcessors
   
           | _ ->
               printfn "%A" expr
  
positive.code:                         template
                  in 
                  updatedProgram 
                  |> ParsedProgram.addMnemonic name (Output operation), (Some operation)
  
          match expr with
          | BasicPatterns.Sequential (expr1, expr2) ->
              let updatedProgram, depOpt = visitExpression None predcessors parsedProgram expr1
              let predcessors' = 
                  match depOpt with
                  | Some op -> predcessors |> Set.add op
                  | None -> predcessors
              visitExpression nameOpt predcessors' updatedProgram expr2
              
          | BasicPatterns.Let ((bindVar, bindExpr), bodyExpr) ->
  
negative.code:     let rec visitDeclarations program predcessors declarations = 
          match declarations with
          | [] ->
              program, predcessors
          | decl :: tail ->
              match decl with
              | Entity _ ->
                  failwith "Nested types or modules are not allowed"
  
              | InitAction expr ->
                  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, predcessors' = 
                          visitExpression (Some funcOrVal.FullName) predcessors program expression
                      visitDeclarations updatedProgram predcessors' tail
              
      let (|Module|) (x: FSharpEntity) = if x.IsFSharpModule then Some x else None
      
      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 ()
  