anchor.diff:                                          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 _
  -                                            | GetArray _
                                               | AddressOf _ 
                                               | AddressSet _
                                               | FieldSet _
                                               | PropertySet _
                                               | WriteOutputs _ ->
                                                   false
  +
  +
  +
   
                                               | Call(None, mi, args) ->
                                                   if state.isSideEffect mi then false
  
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:                 | Let(v,e,b) ->
                      let b, bh = processExpression b
                      let e, eh = processExpression e
                      b, bh + { finalize = Some (fun f -> Expr.Let(v, e, f)) } + eh
  
  
                  | TryFinally _ -> failwith ""
  