anchor.diff:                  | Let(v,e,b) ->
                       let b, bh = processExpression b
                       let e, eh = processExpression e
  -                    b, bh + eh + { finalize = Some (fun f -> Expr.Let(v, e, f)) } 
  +                    b, bh + { finalize = Some (fun f -> Expr.Let(v, e, f)) } + eh
   
   
                   | TryFinally _ -> failwith ""
  
positive.code:                         Some ()
                      | _ -> 
                          None
              let letValuePattern =
                  State.get |> State.map (fun s ->
                      match s.variables, s.trivial, s.inputs with
                          | (false | true), true, true ->
                              (|TrivialOrInput|_|)
  
                          | (false | true), true, false ->
                              (|Trivial|_|)
  
                          | true, false, false ->
                              (|OnlyVar|_|)
  
                          | false, false, true ->
                              (|OnlyInputs|_|)
  
                          | true, false, true ->
                              (|InputOrVar|_|)
  
                          | false, false, false ->
                              fun _ -> None
                  )
  
  
  
negative.code:                                         false
                                      else
                                          match e with
                                              | ReadInput(_,_,None) -> true
                                              | ReadInput(_,_,Some idx) -> canInline idx
                                          
                                              | GetArray(e,i) ->
                                                  let res = canInline e && canInline i
                                                  res
                                              | RefOf _
                                              | VarSet _ 
                                              | SetArray _
                                              | AddressOf _ 
                                              | AddressSet _
                                              | FieldSet _
                                              | PropertySet _
                                              | WriteOutputs _ ->
                                                  false
  
  
  
  
                                              | Call(None, mi, args) ->
                                                  if state.isSideEffect mi then false
  