anchor.diff:    ///
     /// The keys must all be instances of [K] and the values to [V].
     /// The [other] map itself can have any type.
  +  /// Example:
  +  /// ```dart
  +  /// final baseMap = <num, Object>{1: 'A', 2: 'B', 3: 'C'};
  +  /// final fromBaseMap = LinkedHashMap<int, String>.from(baseMap);
  +  /// print(fromBaseMap); // {1: A, 2: B, 3: C}
  +  /// ```
     factory LinkedHashMap.from(Map<dynamic, dynamic> other) {
       LinkedHashMap<K, V> result = LinkedHashMap<K, V>();
       other.forEach((dynamic k, dynamic v) {
  
positive.code:   /// overwrites the previous value.
    ///
    /// It is an error if the two [Iterable]s don't have the same length.
    factory LinkedHashMap.fromIterables(Iterable<K> keys, Iterable<V> values) {
      LinkedHashMap<K, V> map = LinkedHashMap<K, V>();
      MapBase._fillMapWithIterables(map, keys, values);
  
negative.code: /// but removing the key and adding it again
  /// will make it be last in the iteration order.
  ///
  /// **Notice:**
  /// Do not modify a map (add or remove keys) while an operation
  /// is being performed on that map, for example in functions
  /// called during a [forEach] or [putIfAbsent] call,
  /// or while iterating the map ([keys], [values] or [entries]).
  ///
  /// The keys of a `LinkedHashMap` must have consistent [Object.==]
  /// and [Object.hashCode] implementations. This means that the `==` operator
  /// must define a stable equivalence relation on the keys (reflexive,
  /// symmetric, transitive, and consistent over time), and that `hashCode`
  /// must be the same for objects that are considered equal by `==`.
  ///
  /// Example:
  ///
  /// ```dart
  /// final planetsByDiameter = {0.949: 'Venus'}; // A new LinkedHashMap
  /// ```
  /// To add data to a map, use [operator[]=], [addAll] or [addEntries].
  /// ```
  /// planetsByDiameter[1] = 'Earth';
  /// planetsByDiameter.addAll({0.532: 'Mars', 11.209: 'Jupiter'});
  /// ```
  /// To check if the map is empty, use [isEmpty] or [isNotEmpty].
  /// To find the number of map entries, use [length].
  /// ```
  /// print(planetsByDiameter.isEmpty); // false
  /// print(planetsByDiameter.length); // 4
  /// print(planetsByDiameter);
  /// // {0.949: Venus, 1.0: Earth, 0.532: Mars, 11.209: Jupiter}
  /// ```
  /// The [forEach] method calls a function for each key/value entry of the map.
  /// ```
  /// planetsByDiameter.forEach((key, value) {
  ///   print('$key \t $value');
  ///   // 0.949    Venus
  ///   // 1.0      Earth
  ///   // 0.532    Mars
  ///   // 11.209   Jupiter
  /// });
  /// ```
  /// To check whether the map has an entry with a specific key, use [containsKey].
  /// ```
  /// final keyOneExists = planetsByDiameter.containsKey(1); // true
  /// final keyFiveExists = planetsByDiameter.containsKey(5); // false
  /// ```
  /// To check whether the map has an entry with a specific value,
  /// use [containsValue].
  /// ```
  /// final earthExists = planetsByDiameter.containsValue('Earth'); // true
  /// final saturnExists =  planetsByDiameter.containsValue('Saturn'); // false
  /// ```
  /// To remove an entry with a specific key, use [remove].
  /// ```
  /// final removedValue = planetsByDiameter.remove(1);
  /// print(removedValue); // Earth
  /// print(planetsByDiameter); // {0.949: Venus, 0.532: Mars, 11.209: Jupiter}
  /// ```
  /// To remove multiple entries at the same time, based on their keys and values,
  /// use [removeWhere].
  /// ```
  /// planetsByDiameter.removeWhere((key, value) => key == 0.949);
  /// print(planetsByDiameter); // {0.532: Mars, 11.209: Jupiter}
  /// ```
  /// To conditionally add or modify a value for a specific key, depending on
  /// whether there already is an entry with that key,
  /// use [putIfAbsent] or [update].
  /// ```
  /// planetsByDiameter.update(0.949, (v) => 'Venus', ifAbsent: () => 'Venus');
  /// planetsByDiameter.putIfAbsent(0.532, () => "Another Mars if needed");
  /// print(planetsByDiameter); // {0.532: Mars, 11.209: Jupiter, 0.949: Venus}
  /// ```
  /// To update the values of all keys, based on the existing key and value,
  /// use [updateAll].
  /// ```
  /// planetsByDiameter.updateAll((key, value) => 'X');
  /// print(planetsByDiameter); // {0.532: X, 11.209: X, 0.949: X}
  /// ```
  /// To remove all entries and empty the map, use [clear].
  /// ```
  /// planetsByDiameter.clear();
  /// print(planetsByDiameter); // {}
  /// print(planetsByDiameter.isEmpty); // true
  /// ```
  /// **See also:**
  /// * [Map], the general interface of key/value pair collections.
  /// * [HashMap] is unordered (the order of iteration is not guaranteed).
  /// * [SplayTreeMap] iterates the keys in sorted order.
  abstract class LinkedHashMap<K, V> implements Map<K, V> {
    /// Creates an insertion-ordered hash-table based [Map].
    ///
  