anchor.diff:        let freeVars = listDiff (List.ofSeq (body.GetFreeVars())) inputs
         let newVars = List.map (fun (x: Var) -> new Var(newVar(x.Name), x.Type)) freeVars
         let freeNewVars = List.zip freeVars newVars
  -      let convertedBody = (lambdaLift body).Substitute(fun v -> Option.map (fun (x, y) -> Expr.Var(y)) (List.tryFind (fun (x, y) -> x = v) freeNewVars))
  +      let convertedBody = (lambdaLift body).Substitute(fun v -> 
  +          Option.map (fun (x, y) -> Expr.Var(y)) (List.tryFind (fun (x, y) -> x = v) freeNewVars))
         let result = 
           let envVar = new Var(newVar "env", typeof<Environment>)
           let env = Expr.Var(envVar)
           let closuredBody = List.fold (fun acc (fcur: Var, ncur: Var) -> 
             let variableName = Expr.Value(fcur.Name)
             let envRefValue = <@@ envRef %%env %%variableName @@>
  -          let rhs = match (ncur.Type) with
  +          let rhs = 
  +            match (ncur.Type) with
               | tp when tp = typeof<Number> -> <@@ getNumber %%envRefValue @@>
               | tp when tp = typeof<Vector> -> <@@ getVector %%envRefValue @@>
               | tp when tp = typeof<Matrix> -> <@@ getMatrix %%envRefValue @@>
  
positive.code:     | ("Cos", "Operators") -> Some("cos", argList)
      | ("ToInt", "Operators") -> Some("(int)", argList)
      | ("GetArraySlice", "OperatorIntrinsics") -> 
        Some("array_slice", List.map (fun x -> match x with 
           | Patterns.NewUnionCase(_, [v]) -> v
           | _ -> x) argList)
      | (methodName, moduleName) when (List.exists (fun (x, y) -> x = moduleName && y = methodName) existingMethods) -> Some(sprintf "%s_%s" moduleName methodName, argList)
      | _ when not(Seq.isEmpty (op.GetCustomAttributes(typeof<CMirror>, true))) -> 
         let attr = Seq.head (op.GetCustomAttributes(typeof<CMirror>, true)) :?> CMirror
         Some(attr.Method, argList)
      | _ -> None 
    | _ -> None
  
  
negative.code: 
  
  let compileModule (moduleName: string) = 
    let methods = List.map (fun (x: System.Reflection.MethodInfo) -> x.Name) 
                    (List.filter (fun (x: System.Reflection.MethodInfo) -> 
                      x.DeclaringType.Name = moduleName) 
                      (List.ofArray (assembly.GetType(moduleName).GetMethods())))
    let generatedMethods = compileSeveral moduleName methods
    let header = """#include "runtime/fsharp.h"
  #include <stdio.h>
  