here is too specialized.
426569
private boolean equivFields(JSField one, JSField two) {
    if (one instanceof JSDynamic) {
      return two instanceof JSDynamic;
    }
    else if (one instanceof JSEnum) {
      return two instanceof JSEnum;
    }
    else if (one instanceof JSPrimitive) {
      return (two instanceof JSPrimitive)
        && ((JSPrimitive)one).getTypeCode() == ((JSPrimitive)two).getTypeCode();
    }
    else if (one instanceof JSVariant) {
      // we assume without checking that JSVariants in this context must be boxed
      return (two instanceof JSVariant)
        && ((JSVariant)one).getBoxed().getID() == ((JSVariant)two).getBoxed().getID();
    }
    else
      return false;
  }
1140943
function() {
  var fn = this.__superFunction;
  var self = this;
  var bound = function _super() {
    if (this && this !== self) {
      throw new Error('_super cannot change `this` use _super.unbound');
    }
    return fn && fn.apply(self, arguments);
  };
  return _.extend(bound, { unbound: fn });
}
983271
def _may_override(self, implem, other):
        """"""
        if isinstance(other, ImplementationProperty):
            # Overriding another custom implementation for the same transition
            # and field
            return (other.transition == implem.transition and other.field_name == self.state_field)

        elif isinstance(other, TransitionWrapper):
            # Overriding the definition that led to adding the current
            # ImplementationProperty.
            return (
                other.trname == implem.transition.name
                and (not other.field or other.field == self.state_field)
                and other.func == implem.implementation)

        return False
594979
def subset?(other)
      raise(ISO8601::Errors::TypeError, "The parameter must be an instance of #{self.class}") \
        unless other.is_a?(self.class)

      other.include?(first) && other.include?(last)
    end
1076504
function() {
          // TODO: remove unshifting 
          expected.unshift(actual)
          this.result = matcher.match.apply(this, expected)
          this.passed = negate ? !this.result : this.result
          if (!this.passed) this.message = matcher.message.call(this, actual, expected, negate, matcher.name)
          return this
        }
807098
function() {
			if (this.parent) {
				var ix = this.parent.children.indexOf(this);
				if (~ix) {
					this.parent.children.splice(ix, 1);
				}
			}
			
			return this;
		}
772927
def extend(self, other):
		
		for key, value in other.iteritems():
			if key not in self:
				self[key] = _shallowcopy(value)
			else:
				self[key].extend(value)
807625
function(id, deps, factory, _special) {
    define(id, deps, factory, _special || USED_AS_TRANSPORT);
  }
894563
function () {
                        //noinspection JSReferencingMutableVariableFromClosure
                        res.push({
                            combine: 1,
                            path: prefix + currentComboUrls.join(comboSep) + suffix,
                            mods: currentComboMods
                        });
                    }
345815
def dispatch(self, *args, **kwargs):
        """"""
        return super(AnimalMonthArchive, self).dispatch(*args, **kwargs)
529548
def extend(self, other: Operation) -> None:
        """"""
        if isinstance(other, Circuit):
            self.elements.extend(other.elements)
        else:
            self.elements.extend([other])
104126
def /(other)
      if other.is_a?(InternalComplex) or other.is_a?(Complex)
        self * other.conj / other.abs2
      elsif InternalComplex.generic? other
        InternalComplex.new @real / other, @imag / other
      else
        x, y = other.coerce self
        x / y
      end
    end
484086
public static <A, B> These<A, B> b(B b) {
        return new _B<>(b);
    }
1240689
function (op, other) {
        return new(tree.Dimension)
                  (tree.operate(op, this.value, other.value),
                  this.unit || other.unit);
    }
53172
function Thenable(then, thenable) {
			Pending.call(this);
			tasks.enqueue(new AssimilateTask(then, thenable, this));
		}
245727
function specialRequire(name, fromDir) {
	if (!fromDir) fromDir = process.cwd();
	var paths = Module._nodeModulePaths(fromDir);
	var path = Module._findPath(name, paths);
	return path ? require(path) : require(name);
}
1328324
@Override
    public void preInitialize() {
        synchronized (this) {
            if (isSpecializing() && !preInitialized) {
                preInitialized = true;
                preSpecialize();
                specialize();
                checkSpecialization();
                postSpecialize();
            }
        }
    }