anchor.diff:  
     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 =
  
positive.code:                 ))
                  stack.Push(CompileTarget expr)
              | LetRecursive (varAndExprList, body) ->
                  stack.Push(Compiling (fun _ ->
                    varEnv := (!varEnv) |> Seq.skip varAndExprList.Length |> Seq.toList
                  ))
                  stack.Push(CompileTarget body)
                  for var, expr in varAndExprList do
                    let local = gen.DeclareLocal(var.Name, var.Type)
  
negative.code:             | TryFinally _ as tryFinallyExpr ->
                  stack.Push(CompileTarget (Expr.Application(Expr.Lambda(Var("unitVar", typeof<unit>), tryFinallyExpr), <@ () @>)))
              | Let (var, expr, body) ->
                  let assumptionOpt = tryPopAssumption stack
                  pushTearDown assumptionOpt (fun _ -> varEnv := (!varEnv).Tail) stack
                  stack.Push(CompileTarget body)
                  let local = gen.DeclareLocal(var.Name, var.Type)
                  stack.Push(Compiling (fun gen -> gen.Emit(ILOpCode.stloc local var.Name)))
  