public void applyTransferFunction(Instr i) {
    // Rescue node, if any
    boolean scopeBindingHasEscaped = problem.getScope().bindingHasEscaped();

    Variable dst = null;
    boolean dirtied = false;
    boolean hitDFBarrier = false;
    if (i instanceof ResultInstr) {
      dst = ((ResultInstr) i).getResult();
    }

    if (i instanceof CopyInstr) {
      // Copies are easy
      Operand src = ((CopyInstr) i).getSource();
      Class srcType = getOperandType(tmpState, src);
      setOperandType(tmpState, dst, srcType);

      // If we have an unboxed type for 'src', we can leave this unboxed.
      //
      // FIXME: However, if 'src' is a constant, this could unnecessarily
      // leave 'src' unboxed and lead to a boxing instruction further down
      // at the use site of 'dst'. This indicates that leaving this unboxed
      // should ideally be done 'on-demand'. This indicates that this could
      // be a backward-flow algo OR that this algo should be run on a
      // dataflow graph / SSA graph.
      if (srcType == Float.class) {
        dirtied = true;
      }
    } else if (i instanceof CallBase) {
      // Process calls specially -- these are what we want to optimize!
      CallBase c = (CallBase) i;
      Operand o = c.getClosureArg(null);
      if (o == null) {
        MethAddr m = c.getMethodAddr();
        Operand r = c.getReceiver();
        Operand[] args = c.getCallArgs();
        if (args.length == 1 && m.resemblesALUOp()) {
          Operand a = args[0];
          Class receiverType = getOperandType(tmpState, r);
          Class argType = getOperandType(tmpState, a);
          // Optimistically assume that call is an ALU op
          if (receiverType == Float.class
              || (receiverType == Fixnum.class && argType == Float.class)) {
            setOperandType(tmpState, dst, Float.class);

            // If 'r' and 'a' are not already in unboxed forms at this point,
            // they will get unboxed after this, because we want to opt. this call
            if (r instanceof Variable) {
              tmpState.unboxedVars.add((Variable) r);
            }
            if (a instanceof Variable) {
              tmpState.unboxedVars.add((Variable) a);
            }
            dirtied = true;
          } else {
            if (receiverType == Fixnum.class && argType == Fixnum.class) {
              setOperandType(tmpState, dst, Fixnum.class);
            } else {
              setOperandType(tmpState, dst, Object.class);
            }

            if (c.targetRequiresCallersBinding()) {
              hitDFBarrier = true;
            }
          }
        } else {
          setOperandType(tmpState, dst, Object.class);
        }
      } else {
        if (o instanceof WrappedIRClosure) {
          // Fetch the nested unboxing-analysis problem, creating one if necessary
          IRClosure cl = ((WrappedIRClosure) o).getClosure();
          UnboxableOpsAnalysisProblem subProblem =
              (UnboxableOpsAnalysisProblem) cl.getDataFlowSolution(DataFlowConstants.UNBOXING);
          if (subProblem == null) {
            subProblem = new UnboxableOpsAnalysisProblem();
            subProblem.setup(cl);
            cl.setDataFlowSolution(DataFlowConstants.UNBOXING, subProblem);
          }

          UnboxableOpsAnalysisNode exitNode = (UnboxableOpsAnalysisNode) subProblem.getExitNode();
          UnboxableOpsAnalysisNode entryNode = (UnboxableOpsAnalysisNode) subProblem.getEntryNode();

          // Init it to MEET(state-on-entry, state-on-exit).
          // The meet is required to account for participation of the closure in a loop.
          // Ex: f = 0.0; n.times { f += 10; }
          entryNode.inState = new UnboxState();
          for (Variable v : tmpState.types.keySet()) {
            if (v instanceof LocalVariable) {
              entryNode.inState.types.put(v, tmpState.types.get(v));
            }
          }
          entryNode.inState.computeMEET(exitNode.outState);

          // Compute solution
          subProblem.compute_MOP_Solution();

          // Update types to MEET(new-state-on-exit, current-state)
          tmpState.computeMEETForTypes(exitNode.outState, true);

          // As for unboxed var state, since binding can escape in
          // arbitrary ways in the general case, assume the worst for now.
          // If we are guaranteed that the closure binding is not used
          // outside the closure itself, we can avoid worst-case behavior
          // and only clear vars that are modified in the closure.
          hitDFBarrier = true;
        } else {
          // Black hole -- cannot analyze
          hitDFBarrier = true;
        }
      }
    } else {
      // We dont know how to optimize this instruction.
      // So, we assume we dont know type of the result.
      // TOP/class --> BOTTOM
      setOperandType(tmpState, dst, Object.class);
    }

    if (dirtied) {
      tmpState.unboxedVars.add(dst);
      tmpState.unboxedDirtyVars.add(dst);
    } else {
      // Since the instruction didn't run in unboxed form,
      // dirty unboxed vars will have to get boxed here.
      updateUnboxedVarsInfo(i, tmpState, dst, hasExceptionsRescued(), hitDFBarrier);
    }
  }