that means we need to avoid inheritIO
171141
private static boolean isInheritIOBroken() {
        if (!System.getProperty("os.name", "none").toLowerCase().contains("windows")) {
            return false;
        }
        String runtime = System.getProperty("java.runtime.version");
        if (!runtime.startsWith("1.7")) {
            return false;
        }
        String[] tokens = runtime.split("_");
        if (tokens.length < 2) {
            return true; // No idea actually, shouldn't happen
        }
        try {
            Integer build = Integer.valueOf(tokens[1].split("[^0-9]")[0]);
            if (build < 60) {
                return true;
            }
        } catch (Exception ex) {
            return true;
        }
        return false;
    }
1209959
function removeReferral(client) {
    if (! client) return;

    client.unbind();
    var indexOf = pendingReferrals.indexOf(client);
    if (indexOf >= 0) {
      pendingReferrals.splice(indexOf, 1);
    }
  }
321212
def removeextensibles(bunchdt, data, commdct, key, objname):
    """"""
    theobject = getobject(bunchdt, key, objname)
    if theobject == None:
        return theobject
    theidd = iddofobject(data, commdct, key)
    extensible_i = [
        i for i in range(len(theidd)) if 'begin-extensible' in theidd[i]]
    try:
        extensible_i = extensible_i[0]
    except IndexError:
        return theobject
    while True:
        try:
            popped = theobject.obj.pop(extensible_i)
        except IndexError:
            break
    return theobject
64505
def remove(self, child):
        """"""
        if not isinstance(child, AbstractElement):
            raise ValueError("Expected AbstractElement, got " + str(type(child)))
        if child.parent == self:
            child.parent = None
        self.data.remove(child)
        #delete from index
        if child.id and self.doc and child.id in self.doc.index:
            del self.doc.index[child.id]
224157
function () {
    var self = this;
    Meteor._noYieldsAllowed(function () {
      _.each(self._documents, function(collectionDocs, collectionName) {
        // Iterate over _.keys instead of the dictionary itself, since we'll be
        // mutating it.
        _.each(_.keys(collectionDocs), function (strId) {
          self.removed(collectionName, self._idFilter.idParse(strId));
        });
      });
    });
  }
1276348
def inherited(subclass)
      subclass._arguments = []
      subclass._description = ''
      subclass._abstract = false
      subclass._skip_options = false
      subclass._exe_name = @_exe_name
      subclass._default_priority = @_default_priority.to_f / 2
      subclass._priority = 0
      super
    end
384009
@SuppressWarnings("deprecation")
    public ResourceHandle withInheritanceType(InheritedValues.Type type) {
        Validate.notNull(type, "The inheritance type must not be null");
        if (inheritanceType == type) return this;
        ResourceHandle clone = clone();
        clone.setInheritanceType(type);
        return clone;
    }
371258
function () {
				delete nucleus.props;
				delete nucleus.needs;
				delete nucleus.providers;
				delete nucleus.listeners;
				while (q.length) {
					q.pop();
				}
				nucleus = props = needs = providers = listeners =
					q = q.pending = q.next = q.args = 0;
			}
503746
def remove(cls, resource_id, parent_id=None, grandparent_id=None,
               wait=True, timeout=None):
        """"""
        raise exception.NotSupported(feature="DELETE",
                                     context="VirtualSwitchManager")
829881
def inherit_type(self, type_cls: Type[TInherit]) \
            -> Union[TInherit, 'Publisher']:
        
        self._inherited_type = type_cls
        return self
586401
def _speak_normal_inherit(self, element):
        

        self._visit(element, self._speak_normal)

        element.normalize()
844296
function inherits (ctorA, ctorB) {
      function f() {}
      f.prototype = ctorB.prototype;
      ctorA.prototype = new f();
    }
308369
public void removeTangoArchiveListener(ITangoArchiveListener listener)
            throws DevFailed {
        event_listeners.remove(ITangoArchiveListener.class, listener);
        if (event_listeners.size() == 0)
            unsubscribe_event(event_identifier);
    }
596587
function() {

		if (this._property_changed_listener && (this._value_container.getValue() != this._property_container)) {

			// currently listening to the parent's old data source
			this._property_changed_listener && this._property_container.removePropertyListener(this._property_changed_listener);
			this._enumerable_changed_listener && this._property_container.removeListener(this._enumerable_changed_listener);
			this._property_changed_listener = null;
			this._enumerable_changed_listener = null;
			this._property_container = null;

		}

		this._queueForRefresh();

	}
270438
function destroyDescendant() {
  const instance = getInstance(this);
  if (instance) {
    const {
      selection, datum, destroy, index,
    } = instance;
    destroy(selection, datum, index);
  }
}
474185
def inherit_definition(definition, inherit)
      unless definition.parents.include?(inherit)
        definition.parents << inherit
      end
    end
24274
function freeTransferables(transferables) {
    if (!Array.isArray(transferables)) {
        return;
    }
    transferables.filter(t => t.parent && t.property).forEach(t => delete t.parent[t.property]);
}