anchor.diff:  
   /// Gets a Target from the Target dictionary
   let getTarget x = 
  -  match TargetDict.TryGetValue x with
  -  | true, target -> target
  -  | _  -> failwithf "Target \"%s\" is not defined." x   
  +    match TargetDict.TryGetValue x with
  +    | true, target -> target
  +    | _  -> failwithf "Target \"%s\" is not defined." x   
       
  -/// Do nothing -  fun () -> ()   
  +/// Do nothing - fun () -> ()   
   let DoNothing = (fun () -> ())
   
   /// Adds the dependency to the list of dependencies
   let dependency targetName dependentTargetName =
  -  let target,dependentTarget = getTarget targetName,getTarget dependentTargetName
  -  let rec checkDependencies dependentTarget =
  -    dependentTarget.Dependencies |> List.iter (fun dep ->
  -      if dep = targetName then 
  -        failwithf "Cyclic dependency between %s and %s" targetName dependentTarget.Name
  -      checkDependencies (getTarget dep))
  +    let target,dependentTarget = getTarget targetName,getTarget dependentTargetName
  +    let rec checkDependencies dependentTarget =
  +      dependentTarget.Dependencies |> List.iter (fun dep ->
  +        if dep = targetName then 
  +            failwithf "Cyclic dependency between %s and %s" targetName dependentTarget.Name
  +        checkDependencies (getTarget dep))
         
  -  checkDependencies dependentTarget
  +    checkDependencies dependentTarget
       
  -  TargetDict.[targetName] <- 
  -    {target with 
  -       Dependencies = target.Dependencies @ [dependentTargetName]}
  +    TargetDict.[targetName] <- 
  +      {target with Dependencies = target.Dependencies @ [dependentTargetName]}
     
   /// Adds the dependencies to the list of dependencies  
   let Dependencies targetName = List.iter (dependency targetName)
  
positive.code:   
  /// Creates a target from template
  let targetFromTemplate template name parameters =    
    TargetDict.Add(name,
      {Name = name; 
       Dependencies = [];
       Function = fun () ->
         // Don't run function now
         template.Function parameters })
  
    name <== template.Dependencies
    
  /// Creates a TargetTemplate with dependencies
  let TargetTemplateWithDependecies dependencies body =
    { Name = String.Empty;
      Dependencies = dependencies;
      Function = body}     
        |> targetFromTemplate
  
  /// Creates a TargetTemplate      
  let TargetTemplate body = TargetTemplateWithDependecies [] body 
  
negative.code: open System.Collections.Generic
  
  type TargetTemplate<'a> =
      { Name: string;
        Dependencies: string list;
        Function : 'a -> unit}
     
  type Target = TargetTemplate<unit>
     
  /// TargetDictionary  
  let TargetDict = new Dictionary<_,_>()
  
  /// Final Targets - stores final target and if it is activated
  let FinalTargets = new Dictionary<_,_>()
  
  /// The executed targets
  