/*
Documented, #extend
329299
@SuppressWarnings("unchecked")
    public static <K, V> Map<K, V> extend(final Map<K, V> destination, final Map<K, V> ... sources) {
        final Map<K, V> result = newLinkedHashMap();
        for (final Map.Entry<K, V> entry : destination.entrySet()) {
            result.put(entry.getKey(), entry.getValue());
        }
        for (final Map<K, V> source : sources) {
            for (final Map.Entry<K, V> entry : source.entrySet()) {
                result.put(entry.getKey(), entry.getValue());
            }
        }
        return result;
    }
1192408
function extend(a,b){
	var c={};
	for(var i in a){
		if(a.hasOwnProperty(i)){
			c[i]=a[i];
		}
	}
	for(var i in b){
		if(b.hasOwnProperty(i)){
			c[i]=b[i];
		}
	}
	return c
}
444308
function extend() {
  var result = {};
  var objs = Array.prototype.slice.call(arguments,0);
  objs.forEach(function(props, index){
    for(var prop in props) {
      if(props.hasOwnProperty(prop)) {
        result[prop] = props[prop]
      }
    }
  });
  return result;
}
294081
function _extend (target, source, deep) {
  for (let key in source) {
    if (deep) {
      if (isPlainObject(source[key])) {
        !isPlainObject(target[key]) && (target[key] = {})
      } else if (Array.isArray(source[key])) {
        !Array.isArray(target[key]) && (target[key] = [])
      } else {
        source[key] !== undefined && (target[key] = source[key])
        continue
      }
      _extend(target[key], source[key], deep)
    } else if (source[key] !== undefined) {
      target[key] = source[key]
    }
  }
}
968303
function extend(child, parent) {
        for (var property in parent) {
            if (typeof child[property] == 'undefined') {
                child[property] = parent[property];
            }
        }
        return child;
    }
833122
function extend(targetObj, sourceObject) {
        for (var key in sourceObject) {
            if (sourceObject.hasOwnProperty(key)) {
                targetObj[key] = sourceObject[key];
            }
        }
    }
55064
function extend() {
      var defaults = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

      var extended = {};
      var prop = void 0;

      for (prop in defaults) {
        if (Object.prototype.hasOwnProperty.call(defaults, prop)) {
          extended[prop] = defaults[prop];
        }
      }

      for (prop in options) {
        if (Object.prototype.hasOwnProperty.call(options, prop)) {
          extended[prop] = options[prop];
        }
      }

      return extended;
    }
945040
def extend(self, other):
        """"""
        index = len(self)
        length = 0
        for length, element in enumerate(other, 1):
            super(ObservableList, self).append(element)
        if length:
            self._notify_add_at(index, length)
389788
function extend( to ){
	bmoor.loop( arguments, function(cpy){
		if ( cpy !== to ) {
			if ( to && to.extend ){
				to.extend( cpy );
			}else{
				bmoor.iterate( cpy, function(value, key){
					to[key] = value;
				});
			}
			
		}
	});

	return to;
}
826295
function extend(target, source) {
  let key;
  for (key in source) {
    if (isPlainObject(source[key]) || isArray(source[key])) {
      if (isPlainObject(source[key]) && !isPlainObject(target[key])) {
        target[key] = {};
      }
      if (isArray(source[key]) && !isArray(target[key])) {
        target[key] = [];
      }
      extend(target[key], source[key]);
    } else if (source[key] !== undefined) {
      target[key] = source[key];
    }
  }
}
524450
private void extendTail(int count) {
        if (terminated || count < 1) {
            return;
        }

        while (--count >= 0) {
            // create a copy of the last slot and make it the last one
            final Slot inserted = slots.insertSlotAt(slots.size(), slots.getLastSlot());
            inserted.setValue(null);
            inserted.withTags(TAG_EXTENSION);
        }
    }
1242536
function extend ( fromObj, toObj ) {
        for ( var key in toObj ) {
            fromObj[key] = toObj[key];
        }
    
        return fromObj;
    }
273816
function extend(constructor, superConstructor, methods){
  util.inherits(constructor, superConstructor);

  for (var i in methods){
    constructor.prototype[i] = methods[i];
  }
}
1064201
@Override
  public Context addExtension(Context moreSpecific) throws KbTypeException, CreateException {
    return wrapped().addExtension(moreSpecific);
  }
299957
private ExtendElement readExtend(Location location, String documentation) {
    String name = reader.readName();

    reader.require('{');
    ImmutableList.Builder<FieldElement> fields = ImmutableList.builder();
    while (true) {
      String nestedDocumentation = reader.readDocumentation();
      if (reader.peekChar('}')) break;

      Object declared = readDeclaration(nestedDocumentation, Context.EXTEND);
      if (declared instanceof FieldElement) {
        fields.add((FieldElement) declared);
      }
    }
    return new ExtendElement(location, name, documentation, fields.build());
  }
1148696
function extend(object, subject, ignoredKeys) {
    function copier(key, value) {
      if ( !ignoredKeys || !ignoredKeys.hasOwnProperty(key)) {    // no copy ignored keys
        object[key] = value;                                      // do copy
        if (iClass) { oPrototype[key] = value; }                  // class? copy to prototype as well
      }
    }

    if (isArray(subject)) {
      for (var len = subject.length; --len >= 0;) { extend(object, subject[len], ignoredKeys); }
    } else {
      ignoredKeys = ignoredKeys || { constructor: 1, $super: 1, prototype: 1, $superb: 1 };

      var iClass     = isClass(object),
          isSubClass = isClass(subject),
          oPrototype = object.prototype, supez, key, proto;

      // copy static properties and prototype.* to object
      if (isMap(subject)) { for (key in subject) copier(key, subject[key]); }

      if (isSubClass) {
        proto = subject.prototype;
        for (key in proto) { copier(key, proto[key]); }
      }

      // prototype properties
      if (iClass && isSubClass) { extend(oPrototype, subject.prototype, ignoredKeys); }
    }
  }
537859
public void addExtendedInformation(String key, Object value) {
        if (extendedInformation == null) {
            extendedInformation = new HashMap<>();
        }
        extendedInformation.put(key, value);
    }