if (root.getStaticScope().getModule() == null) { // If an eval this may already be setup.

            root.getStaticScope().setModule(runtime.getObject());

        }

        RubyModule metaclass = self.getMetaClass();

        InterpretedIRMethod method = new InterpretedIRMethod(rootMethod, metaclass);

        IRubyObject rv =  method.call(runtime.getCurrentContext(), self, metaclass, "", new IRubyObject[]{});

        if (c != null) {

            System.out.println("\nGraph:\n" + c.getGraph().toString());

            System.out.println("\nInstructions:\n" + c.toStringInstrs());

        } else if (s instanceof IRMethod) {

        }

    }

    public void run(IRScope s) {

        if (s instanceof IRMethod) {

           CFG       c  = ((IRMethod)s).getCFG();

           IRModule m  = s.getNearestModule();

           for (BasicBlock b: c.getNodes()) {

               for (Instr i: b.getInstrs()) {

                   if (i instanceof CallInstr) {

                       CallInstr call = (CallInstr)i;

                       MethAddr addr = call.getMethodAddr();

    public void run(IRScope s) {

        if (!(s instanceof IRMethod)) return;

        //        if (m.requiresBinding()) {

        BindingStorePlacementProblem fsp = new BindingStorePlacementProblem();

        fsp.setup(c);

        fsp.compute_MOP_Solution();

        fsp.addStoreAndBindingAllocInstructions();

                    }

                    // Check if we can optimize this call based on the receiving method and receiver type

                    // Use the simplified receiver!

                    if (rm != null) {

                        if (rc != null) { // TODO: I am fairly sure I am wallpapering

                            if (rc.isCoreClass("Fixnum")) {

                                Operand[] args = call.getOperands();

                                if (args[2].isConstant()) {

                                    addMethodGuard(rm, deoptLabel, versionMap, instrs);

                                }

                            } else if (rc.isCoreClass("Float")) {

                                Operand[] args = call.getOperands();

                                if (args[2].isConstant()) {

                                    addMethodGuard(rm, deoptLabel, versionMap, instrs);

                                }

                            } else if (rc.isCoreClass("Array")) {

                                Operand[] args = call.getOperands();

                                    addMethodGuard(rm, deoptLabel, versionMap, instrs);

                                    val = ((Array) r).fetchCompileTimeArrayElement(((Fixnum) args[2]).value.intValue(), false);

                                }

                            }

                        }

    // Can this call lead to ruby code getting modified? 

    // If we don't know what method we are calling, we assume it can (pessimistic, but safe!)

    // If we do know the target method, we ask the method itself whether it modifies ruby code

    public boolean canModifyCode() {

    }

        }

         **/

        Operand r = getReceiver();

        // If we don't know the method we are dispatching to, or if we know that the method can capture the callers frame,

        // we are in deep doo-doo.  We will need to store all variables in the call frame.

        //

        // SSS FIXME:

        // This is a "static" check and at some point during the execution, the caller's code could change and capture the binding at that point!

        // We need to set a compilation flag that records this dependency on the caller, so that this method can be recompiled whenever

        // the caller changes.

    }

                  count = new Integer(1);

               } else {

                  count = new Integer(count + 1);

                  if ((count > 50) && (m instanceof InterpretedIRMethod) && (_profile.size() == 1)) {

                     _profile.remove(m); // remove it because the interpreter might ignore this hint

                     throw new org.jruby.interpreter.InlineMethodHint(inlineableMethod);

                  }

               }

               _profile.put(m, count);

        method().invokeVirtual(Type.getType(Object.class), Method.getMethod("Object " + call.getMethodAddr() + " ()"));

    }

    public void emitDEF_INST_METH(DefineInstanceMethodInstr instr) {

        adapter.loadThis();

        adapter.loadArgs();

        adapter.returnValue();

        adapter.endMethod();

    }

        adapter.endMethod();

    }

    public void emitDEF_CLS_METH(DefineClassMethodInstr instr) {

        adapter.returnValue();

        adapter.endMethod();

    }