docs: private void markSubroutineWalkDFS(final BitSet sub, int index,
              final BitSet anyvisited) {
          while (true) {
              AbstractInsnNode node = instructions.get(index);
  
              // don't visit a node twice
              if (sub.get(index)) {
                  return;
              }
              sub.set(index);
  
              // check for those nodes already visited by another subroutine
              if (anyvisited.get(index)) {
                  dualCitizens.set(index);
                  if (LOGGING) {
                      log("Instruction #" + index + " is dual citizen.");
                  }
              }
              anyvisited.set(index);
  
              if (node.getType() == AbstractInsnNode.JUMP_INSN
                      && node.getOpcode() != JSR) {
                  // we do not follow recursively called subroutines here; but any
                  // other sort of branch we do follow
                  JumpInsnNode jnode = (JumpInsnNode) node;
                  int destidx = instructions.indexOf(jnode.label);
                  markSubroutineWalkDFS(sub, destidx, anyvisited);
              }
              if (node.getType() == AbstractInsnNode.TABLESWITCH_INSN) {
                  TableSwitchInsnNode tsnode = (TableSwitchInsnNode) node;
                  int destidx = instructions.indexOf(tsnode.dflt);
                  markSubroutineWalkDFS(sub, destidx, anyvisited);
                  for (int i = tsnode.labels.size() - 1; i >= 0; --i) {
                      LabelNode l = tsnode.labels.get(i);
                      destidx = instructions.indexOf(l);
                      markSubroutineWalkDFS(sub, destidx, anyvisited);
                  }
              }
              if (node.getType() == AbstractInsnNode.LOOKUPSWITCH_INSN) {
                  LookupSwitchInsnNode lsnode = (LookupSwitchInsnNode) node;
                  int destidx = instructions.indexOf(lsnode.dflt);
                  markSubroutineWalkDFS(sub, destidx, anyvisited);
                  for (int i = lsnode.labels.size() - 1; i >= 0; --i) {
                      LabelNode l = lsnode.labels.get(i);
                      destidx = instructions.indexOf(l);
                      markSubroutineWalkDFS(sub, destidx, anyvisited);
                  }
              }
  
              // check to see if this opcode falls through to the next instruction
              // or not; if not, return.
              switch (instructions.get(index).getOpcode()) {
              case GOTO:
              case RET:
              case TABLESWITCH:
              case LOOKUPSWITCH:
              case IRETURN:
              case LRETURN:
              case FRETURN:
              case DRETURN:
              case ARETURN:
              case RETURN:
              case ATHROW:
                  /*
                   * note: this either returns from this subroutine, or a parent
                   * subroutine which invoked it
                   */
                  return;
              }
  
              // Use tail recursion here in the form of an outer while loop to
              // avoid our stack growing needlessly:
              index++;
  
              // We implicitly assumed above that execution can always fall
              // through to the next instruction after a JSR. But a subroutine may
              // never return, in which case the code after the JSR is unreachable
              // and can be anything. In particular, it can seem to fall off the
              // end of the method, so we must handle this case here (we could
              // instead detect whether execution can return or not from a JSR,
              // but this is more complicated).
              if (index >= instructions.size()) {
                  return;
              }
          }
      }