docs: private IsNullConditionDecision getDecision(BasicBlock basicBlock, IsNullValueFrame lastFrame)
              throws DataflowAnalysisException {
  
          assert lastFrame != null;
  
          final InstructionHandle lastInSourceHandle = basicBlock.getLastInstruction();
          if (lastInSourceHandle == null) {
              return null; // doesn't end in null comparison
          }
  
          final short lastInSourceOpcode = lastInSourceHandle.getInstruction().getOpcode();
          if (lastInSourceOpcode == Const.IFEQ || lastInSourceOpcode == Const.IFNE) {
              // check for instanceof check
              InstructionHandle prev = lastInSourceHandle.getPrev();
              if (prev == null) {
                  return null;
              }
              short secondToLastOpcode = prev.getInstruction().getOpcode();
              // System.out.println("Second last opcode: " +
              // Const.Const.getOpcodeName(secondToLastOpcode));
              if (secondToLastOpcode != Const.INSTANCEOF) {
                  return null;
              }
              if (instanceOfFrame == null) {
                  return null;
              }
              IsNullValue tos = instanceOfFrame.getTopValue();
              boolean isNotInstanceOf = (lastInSourceOpcode != Const.IFNE);
              Location atInstanceOf = new Location(prev, basicBlock);
              ValueNumberFrame instanceOfVnaFrame = vnaDataflow.getFactAtLocation(atInstanceOf);
  
              // Initially, assume neither branch is feasible.
              IsNullValue ifcmpDecision = null;
              IsNullValue fallThroughDecision = null;
  
              if (tos.isDefinitelyNull()) {
                  // Predetermined comparison - one branch is infeasible
                  if (isNotInstanceOf) {
                      ifcmpDecision = tos;
                  } else {
                      // ifnonnull
                      fallThroughDecision = tos;
                  }
              } else if (tos.isDefinitelyNotNull()) {
                  return null;
              } else {
                  // As far as we know, both branches feasible
                  ifcmpDecision = isNotInstanceOf ? tos : IsNullValue.pathSensitiveNonNullValue();
                  fallThroughDecision = isNotInstanceOf ? IsNullValue.pathSensitiveNonNullValue() : tos;
              }
              if (DEBUG) {
                  System.out.println("Checking..." + tos + " -> " + ifcmpDecision + " or " + fallThroughDecision);
              }
              return new IsNullConditionDecision(instanceOfVnaFrame.getTopValue(), ifcmpDecision, fallThroughDecision);
          }
  
          if (!nullComparisonInstructionSet.get(lastInSourceOpcode)) {
              return null; // doesn't end in null comparison
          }
  
          Location atIf = new Location(lastInSourceHandle, basicBlock);
          ValueNumberFrame prevVnaFrame = vnaDataflow.getFactAtLocation(atIf);
  
          switch (lastInSourceOpcode) {
  
          case Const.IFNULL:
          case Const.IFNONNULL: {
              IsNullValue tos = lastFrame.getTopValue();
              boolean ifnull = (lastInSourceOpcode == Const.IFNULL);
              ValueNumber prevTopValue = prevVnaFrame.getTopValue();
  
              return handleIfNull(tos, prevTopValue, ifnull);
          }
          case Const.IF_ACMPEQ:
          case Const.IF_ACMPNE: {
              IsNullValue tos = lastFrame.getStackValue(0);
              IsNullValue nextToTos = lastFrame.getStackValue(1);
  
              boolean tosNull = tos.isDefinitelyNull();
              boolean nextToTosNull = nextToTos.isDefinitelyNull();
  
              boolean cmpeq = (lastInSourceOpcode == Const.IF_ACMPEQ);
  
              // Initially, assume neither branch is feasible.
              IsNullValue ifcmpDecision = null;
              IsNullValue fallThroughDecision = null;
              ValueNumber value;
  
              if (tosNull && nextToTosNull) {
                  // Redundant comparison: both values are null, only one branch
                  // is feasible
                  value = null; // no value will be replaced - just want to
                  // indicate that one of the branches is infeasible
                  if (cmpeq) {
                      ifcmpDecision = IsNullValue.pathSensitiveNullValue();
                  } else {
                      // cmpne
                      fallThroughDecision = IsNullValue.pathSensitiveNullValue();
                  }
              } else if (tosNull || nextToTosNull) {
                  if (tosNull) {
                      return handleIfNull(nextToTos, prevVnaFrame.getStackValue(1), cmpeq);
                  }
  
                  assert nextToTosNull;
                  return handleIfNull(tos, prevVnaFrame.getStackValue(0), cmpeq);
  
              } else if (tos.isDefinitelyNotNull() && !nextToTos.isDefinitelyNotNull()) {
                  // learn that nextToTos is definitely non null on one branch
                  value = prevVnaFrame.getStackValue(1);
                  if (cmpeq) {
                      ifcmpDecision = tos;
                      fallThroughDecision = nextToTos;
                  } else {
                      fallThroughDecision = tos;
                      ifcmpDecision = nextToTos;
                  }
              } else if (!tos.isDefinitelyNotNull() && nextToTos.isDefinitelyNotNull()) {
                  // learn that tos is definitely non null on one branch
                  value = prevVnaFrame.getStackValue(0);
                  if (cmpeq) {
                      ifcmpDecision = nextToTos;
                      fallThroughDecision = tos;
                  } else {
                      fallThroughDecision = nextToTos;
                      ifcmpDecision = tos;
                  }
              } else {
                  // No information gained
                  return null;
              }
  
              return new IsNullConditionDecision(value, ifcmpDecision, fallThroughDecision);
          }
          default:
              throw new IllegalStateException();
          }
  
      }