//

        // JRUBY-5686: do this before executing so first time sets cref module

        getLambdaBody().getStaticScope().determineModule();

        // ENEBO: Now can live nil be passed as block reference?

        return RubyProc.newProc(context.runtime,

                (Block) (body == null ? context.runtime.getIRManager().getNil() : operands[0]).retrieve(context, self, currDynScope, temp),

                Block.Type.LAMBDA, position);

    }

                    // In this first pass, the current scope and the call's closure are considered

                    // independent of each other which means any variable that is used by the variable

                    // will get spilled into the binding.  This is clearly conservative, but simplifies

                    // the analysis.

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

                    boolean spillAllVars = scopeBindingHasEscaped || call.targetRequiresCallersBinding();

                    // - 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

                    //   spill it before the call in the scenario that the closure never gets executed! So, it won't be dirty after

                    //   the call site.

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

                    for (LocalVariable v : dirtyVars) {

                            newDirtyVars.remove(v);

                        }

                    }

                    dirtyVars = newDirtyVars;

                } else if (scopeBindingHasEscaped || call.targetRequiresCallersBinding()) { // Call has no closure && it requires stores

            if (i instanceof CallBase) {

                CallBase call = (CallBase) i;

                Operand o = call.getClosureArg(null);

                if (o != null && o instanceof WrappedIRClosure) {

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

                    instrs.previous();

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

                    boolean spillAllVars = scopeBindingHasEscaped || call.targetRequiresCallersBinding();

                    // 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) {

                        // We have to spill the var that is defined in the closure as well because the load var pass

                        // will attempt to load the var always.  So, if the call doesn't actually call the closure,

                        // we'll be in trouble in that scenario!

                            addedStores = true;

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

                            newDirtyVars.remove(v);

                        }

                    }

            if (i instanceof CallBase) {

                CallBase call = (CallBase) i;

                Operand o = call.getClosureArg(null);

                if (o != null && o instanceof WrappedIRClosure) {

                    // Variables defined in the closure do not need to be loaded anymore at

                    // program points before the call, because they will be loaded after the

                    // call completes to fetch the latest value.

                    //

                    // Allocate a new hash-set and modify it to get around ConcurrentModificationException on reqdLoads

                    Set<LocalVariable> newReqdLoads = new HashSet<LocalVariable>(reqdLoads);

                    for (LocalVariable v: reqdLoads) {

                    }

                    reqdLoads = newReqdLoads;

                }

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

            if (i instanceof CallBase) {

                CallBase call = (CallBase) i;

                Operand o = call.getClosureArg(null);

                if (o != null && o instanceof WrappedIRClosure) {

                    // Only those variables that are defined in the closure, and are in the required loads set

                    // will need to be loaded from the binding after the call!  Rest can wait ..

                    //

                    // Allocate a new hash-set and modify it to get around ConcurrentModificationException on reqdLoads

                    Set<LocalVariable> newReqdLoads = new HashSet<LocalVariable>(reqdLoads);

                    it.next();

                    for (LocalVariable v : reqdLoads) {

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

                            it.previous();

                            newReqdLoads.remove(v);

                        }

                    }

                CallBase c = (CallBase) i;

                Operand  o = c.getClosureArg(null);

                // System.out.println("Processing closure: " + o + "-------");

                if (o != null && o instanceof WrappedIRClosure) {

                    if (cl_lvp == null) {

                        cl_lvp = new LiveVariablesProblem(cl, lvp.getNonSelfLocalVars());

                    }

                    // Collect live local variables at this point.

                    Set<LocalVariable> liveVars = new HashSet<LocalVariable>();

                    for (int j = 0; j < living.size(); j++) {

            if (i instanceof CallBase) {

                CallBase c = (CallBase) i;

                Operand  o = c.getClosureArg(null);

                if (o != null && o instanceof WrappedIRClosure) {

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

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

                } else if (scopeBindingHasEscaped || c.targetRequiresCallersBinding()) {

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

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

        if (!(scope instanceof IRScriptBody)) file.encode(scope.getLexicalParent());

        if (scope instanceof IRClosure) {

        }

        persistStaticScope(file, scope.getStaticScope());

        persistLocalVariables(scope, file);

        file.endEncodingScopeHeader(scope);

                // In this first pass, the current scope and the call's closure are considered

                // independent of each other which means any variable that is used by the variable

                // will get spilled into the binding.  This is clearly conservative, but simplifies

                // the analysis.

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

                boolean spillAllVars = scopeBindingHasEscaped;

                // - 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

                //   spill it before the call in the scenario that the closure never gets executed! So, it won't be dirty after

                //   the call site.

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

                for (LocalVariable v : dirtyVars) {

                        newDirtyVars.remove(v);

                    }

                }

                dirtyVars = newDirtyVars;

            } else if (scopeBindingHasEscaped) { // Call has no closure && it requires stores

            // Process closure accepting instrs specially -- these are the sites of binding stores!

            if (i instanceof ClosureAcceptingInstr) {

                Operand o = ((ClosureAcceptingInstr)i).getClosureArg();

                if (o != null && o instanceof WrappedIRClosure) {

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

                    instrs.previous();

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

                    boolean spillAllVars = scopeBindingHasEscaped;

                    // 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) {

                        // We have to spill the var that is defined in the closure as well because the load var pass

                        // will attempt to load the var always.  So, if the call doesn't actually call the closure,

                        // we'll be in trouble in that scenario!

                            addedStores = true;

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

                            newDirtyVars.remove(v);

                        }

                    }