anchor.diff:                  ))
                   stack.Push(CompileTarget expr)
               | LetRecursive (varAndExprList, body) ->
  -                stack.Push(Compiling (fun _ ->
  -                  varEnv := (!varEnv) |> Seq.skip varAndExprList.Length |> Seq.toList
  -                ))
  +                let assumptionOpt = tryPopAssumption stack
  +                pushTearDown assumptionOpt (fun _ -> varEnv := !varEnv |> Seq.skip varAndExprList.Length |> Seq.toList) stack
                   stack.Push(CompileTarget body)
                   for var, expr in varAndExprList do
                     let local = gen.DeclareLocal(var.Name, var.Type)
  
positive.code:             | TryFinally _ as tryFinallyExpr ->
                  stack.Push(CompileTarget (Expr.Application(Expr.Lambda(Var("unitVar", typeof<unit>), tryFinallyExpr), <@ () @>)))
              | Let (var, expr, body) ->
                  stack.Push(Compiling (fun _ ->
                    varEnv := (!varEnv).Tail
                  ))
                  stack.Push(CompileTarget body)
                  let local = gen.DeclareLocal(var.Name, var.Type)
                  stack.Push(Compiling (fun gen -> gen.Emit(ILOpCode.stloc local var.Name)))
  
negative.code: 
    type ICompiledType<'T> =
      abstract member ExecuteCompiledCode: unit -> 'T
  
    let private tryPopAssumption (stack: CompileStack) =
      if stack.Count <> 0 then
        match stack.Pop() with
        | Assumption _ as assumption -> Some assumption
        | other -> stack.Push(other); None
      else
        None
  
    let private pushTearDown assumptionOpt f (stack: CompileStack) =
      match assumptionOpt with
      | Some a ->
          stack.Push(Compiling f)
          stack.Push(a)
      | None ->
          stack.Push(Compiling f)
  
    let compile (expr: Expr<'T>) : 'T =
      let asm =
  