// the analysis.

                    IRClosure cl = ((WrappedIRClosure) o).getClosure();

                    // If the call is a dataflow barrier, we have to spill everything here

                    // - If all variables have to be spilled, then those variables will no longer be dirty after the call site

                    // - If a variable is used in the closure (FIXME: Strictly only those vars that are live at the call site --

                    //   but we dont have this info!), it has to be spilt. So, these variables are no longer dirty after the call site.

                    // - If a variable is (re)defined in the closure, it will always be loaded after the call. So, we have to always

                            newDirtyVars.remove(v);

                        }

                    }

                    dirtyVars = newDirtyVars;

                    dirtyVars.clear();

                } else {

                    // All variables not local to the current scope have to be always spilled because of

                    // multi-threading scenarios where some other scope could load this variable concurrently.

                    //

                    // Add before call -- hence instrs.previous & instrs.next

                    instrs.previous();

                    // If the call is a dataflow barrier, we have to spill everything here

                    // Unless we have to spill everything, spill only those dirty variables that are:

                    // - used in the closure (FIXME: Strictly only those vars that are live at the call site -- but we dont have this info!)

                    Set<LocalVariable> newDirtyVars = new HashSet<LocalVariable>(dirtyVars);

                    for (LocalVariable v : dirtyVars) {

                        }

                    }

                    dirtyVars = newDirtyVars;

                    instrs.next();

                    // Add before call -- hence instrs.previous & instrs.next

                    instrs.previous();

                    for (LocalVariable v : dirtyVars) {

                        addedStores = true;

                        instrs.add(new StoreLocalVarInstr(getLocalVarReplacement(v, scope, varRenameMap), scope, v));

                    reqdLoads = newReqdLoads;

                }

                // In this case, we are going to blindly load everything -- so, at the call site, pending loads dont carry over!

                    reqdLoads.clear();

                } else {

                    // All variables not defined in the current scope have to be always loaded

                    // because of multi-threading scenarios where some other scope

                    // could update this variable concurrently.

                    reqdLoads = newReqdLoads;

                }

                // In this case, we are going to blindly load everything

                    it.next();

                    for (LocalVariable v: reqdLoads) {

                        it.add(new LoadLocalVarInstr(scope, getLocalVarReplacement(v, scope, varRenameMap), v));

                        it.previous();

                    }

                    markAllVariablesLive(lvp, living, liveOnEntryAfter);

                }

                // If this is a dataflow barrier -- mark all local vars but %self and %block live

                    // System.out.println(".. call is a data flow barrier ..");

                    // Mark all non-self, non-block local variables live if 'c' is a dataflow barrier!

                    for (Variable x: lvp.getNonSelfLocalVars()) {

                        if (!x.isImplicitBlockArg()) living.set(lvp.getDFVar(x).getId());

                    }

                    IRClosure cl = ((WrappedIRClosure)o).getClosure();

                    LiveVariablesProblem cl_lvp = (LiveVariablesProblem)cl.getDataFlowSolution(lvp.getName());

                    // Collect variables live on entry and merge that info into the current problem.

                    markAllVariablesLive(lvp, living, cl_lvp.getVarsLiveOnScopeEntry());

                    // Mark all non-self, non-block local variables live if 'c' is a dataflow barrier!

                    for (Variable x: lvp.getNonSelfLocalVars()) {

                        if (!x.isImplicitBlockArg()) living.set(lvp.getDFVar(x).getId());

                    }

                } else if (c.canRaiseException()) {

                this.usesZSuper = true;

            } else if (i instanceof CallBase) {

                CallBase call = (CallBase) i;

                if (call.canBeEval()) {

                    this.usesEval = true;

                    // If this method receives a closure arg, and this call is an eval that has more than 1 argument,