anchor.diff:              |> Seq.sortBy (fun (KeyValue(targetIdx, _)) -> targetIdx)
               |> List.ofSeq
   
  -        GenPostponedAndQueueTargets cenv cgbuf queue sortedTargetInfos stackAtTargets sequel
  +        GenPostponedDecisionTreeTargets cenv cgbuf sortedTargetInfos stackAtTargets sequel contf
               
       | (inplabOpt, eenv, tree) :: rest ->
           match tree with
           | TDSuccess(es, targetIdx) ->
               let targetInfos, genTargetInfoOpt = GenDecisionTreeSuccess cenv cgbuf inplabOpt stackAtTargets eenv es targetIdx targets repeatSP targetInfos sequel
               match genTargetInfoOpt with
  -            | Some _ ->
  -                queue.Enqueue(fun () -> GenDecisionTreesAndQueueTargets cenv cgbuf queue targetInfos rest stackAtTargets targets repeatSP sequel)
  -                genTargetInfoOpt
  +            | Some (eenvAtTarget, spExprAtTarget, exprAtTarget, sequelAtTarget) ->
  +                GenLinearExpr cenv cgbuf eenvAtTarget spExprAtTarget exprAtTarget sequelAtTarget true (fun Fake ->
  +                    GenDecisionTreesAndTargets cenv cgbuf targetInfos rest stackAtTargets targets repeatSP sequel contf
  +                )
               | _ ->
  -                GenDecisionTreesAndQueueTargets cenv cgbuf queue targetInfos rest stackAtTargets targets repeatSP sequel
  +                GenDecisionTreesAndTargets cenv cgbuf targetInfos rest stackAtTargets targets repeatSP sequel contf
           | _ ->
               let newDecisions = GenDecisionTreeAndTargetsInner cenv cgbuf inplabOpt stackAtTargets eenv tree targets repeatSP targetInfos sequel
  -            GenDecisionTreesAndQueueTargets cenv cgbuf queue targetInfos (newDecisions @ rest) stackAtTargets targets repeatSP sequel
  +            GenDecisionTreesAndTargets cenv cgbuf targetInfos (newDecisions @ rest) stackAtTargets targets repeatSP sequel contf
   
   // Accumulate the decision graph as we go
  -and GenDecisionTreeAndTargets cenv cgbuf stackAtTargets eenv tree targets repeatSP sequel : (Queue<unit -> (IlxGenEnv * EmitSequencePointState * Expr * sequel) option>) =
  -    let queue = Queue()
  -    queue.Enqueue (fun () -> GenDecisionTreesAndQueueTargets cenv cgbuf queue (IntMap.empty()) [(None, eenv, tree)] stackAtTargets targets repeatSP sequel)
  -    queue
  +and GenDecisionTreeAndTargets cenv cgbuf stackAtTargets eenv tree targets repeatSP sequel contf =
  +    GenDecisionTreesAndTargets cenv cgbuf (IntMap.empty()) [(None, eenv, tree)] stackAtTargets targets repeatSP sequel contf
   
   and TryFindTargetInfo targetInfos n =
       match IntMap.tryFind n targetInfos with
  
positive.code:         // go to the join point
          Br afterJoin, afterJoin, stackAfterJoin, sequel
  
  and GenPostponedAndQueueTargets cenv cgbuf (queue: Queue<_>) targetInfos stackAtTargets sequel =
      match targetInfos with
      | [] -> None
      | (KeyValue(_, (targetInfo, isTargetPostponed))) :: rest ->
          if isTargetPostponed then 
              queue.Enqueue(fun () -> GenPostponedAndQueueTargets cenv cgbuf queue rest stackAtTargets sequel)
              Some(GenDecisionTreeTarget cenv cgbuf stackAtTargets targetInfo sequel)
          else
              GenPostponedAndQueueTargets cenv cgbuf queue rest stackAtTargets sequel
  
  and GenDecisionTreesAndQueueTargets cenv cgbuf (queue: Queue<_>) targetInfos decisions stackAtTargets targets repeatSP sequel =
      match decisions with
      | [] -> 
          let sortedTargetInfos = 
  
negative.code:     GenAllocUnionCaseCore cenv cgbuf eenv (c,tyargs,args.Length,m)
      GenSequel cenv eenv.cloc cgbuf sequel
  
  and GenLinearExpr cenv cgbuf eenv sp expr sequel canProcessSequencePoint (contf: FakeUnit -> FakeUnit) =
      let expr = stripExpr expr
      match expr with 
  