anchor.diff:          codeArea.codeLength + gridArea.codeLength);
     }
   
  -  /**
  -      Recover the nearest matching code to a specified location.
  -      Given a short Open Location Code of between four and seven characters,
  -      this recovers the nearest matching full code to the specified location.
  -      The number of characters that will be prepended to the short code, depends
  -      on the length of the short code and whether it starts with the separator.
  -      If it starts with the separator, four characters will be prepended. If it
  -      does not, the characters that will be prepended to the short code, where S
  -      is the supplied short code and R are the computed characters, are as
  -      follows:
  -      SSSS    -> RRRR.RRSSSS
  -      SSSSS   -> RRRR.RRSSSSS
  -      SSSSSS  -> RRRR.SSSSSS
  -      SSSSSSS -> RRRR.SSSSSSS
  -      Note that short codes with an odd number of characters will have their
  -      last character decoded using the grid refinement algorithm.
  -      Args:
  -      shortCode: A valid short OLC character sequence.
  -      referenceLatitude: The latitude (in signed decimal degrees) to use to
  -      find the nearest matching full code.
  -      referenceLongitude: The longitude (in signed decimal degrees) to use
  -      to find the nearest matching full code.
  -      Returns:
  -      The nearest full Open Location Code to the reference location that matches
  -      the short code. Note that the returned code may not have the same
  -      computed characters as the reference location. This is because it returns
  -      the nearest match, not necessarily the match within the same cell. If the
  -      passed code was not a valid short code, but was a valid full code, it is
  -      returned unchanged.
  -   */
  +  /// Recover the nearest matching code to a specified location.
  +  ///
  +  /// Given a short Open Location Code of between four and seven characters,
  +  /// this recovers the nearest matching full code to the specified location.
  +  /// The number of characters that will be prepended to the short code, depends
  +  /// on the length of the short code and whether it starts with the separator.
  +  /// If it starts with the separator, four characters will be prepended. If it
  +  /// does not, the characters that will be prepended to the short code, where S
  +  /// is the supplied short code and R are the computed characters, are as
  +  /// follows:
  +  ///
  +  /// * SSSS    -> RRRR.RRSSSS
  +  /// * SSSSS   -> RRRR.RRSSSSS
  +  /// * SSSSSS  -> RRRR.SSSSSS
  +  /// * SSSSSSS -> RRRR.SSSSSSS
  +  ///
  +  /// Note that short codes with an odd number of characters will have their
  +  /// last character decoded using the grid refinement algorithm.
  +  ///
  +  /// Args:
  +  ///
  +  /// * [shortCode]: A valid short OLC character sequence.
  +  /// * [referenceLatitude]: The latitude (in signed decimal degrees) to use to
  +  /// find the nearest matching full code.
  +  /// * [referenceLongitude]: The longitude (in signed decimal degrees) to use
  +  ///  to find the nearest matching full code.
  +  ///
  +  /// It returns the nearest full Open Location Code to the reference location
  +  /// that matches the [shortCode]. Note that the returned code may not have the
  +  /// same computed characters as the reference location (provided by
  +  /// [referenceLatitude] and [referenceLongitude]). This is because it returns
  +  /// the nearest match, not necessarily the match within the same cell. If the
  +  /// passed code was not a valid short code, but was a valid full code, it is
  +  /// returned unchanged.
     String recoverNearest(
         String shortCode, double referenceLatitude, double referenceLongitude) {
       if (!isShort(shortCode)) {
  
positive.code:     return code;
    }
  
    /**
        Decodes an Open Location Code into the location coordinates.
        Returns a CodeArea object that includes the coordinates of the bounding
        box - the lower left, center and upper right.
        Args:
        code: The Open Location Code to decode.
        Returns:
        A CodeArea object that provides the latitude and longitude of two of the
        corners of the area, the center, and the length of the original code.
     */
    CodeArea decode(String code) {
      if (!isFull(code)) {
        throw new ArgumentError(
  
negative.code:         codeLength: codeArea.codeLength);
    }
  
    /// Remove characters from the start of an OLC [code].
    ///
    /// This uses a reference location to determine how many initial characters
    /// can be removed from the OLC code. The number of characters that can be
    /// removed depends on the distance between the code center and the reference
    /// location.
    /// The minimum number of characters that will be removed is four. If more
    /// than four characters can be removed, the additional characters will be
    /// replaced with the padding character. At most eight characters will be
    /// removed.
    /// The reference location must be within 50% of the maximum range. This
    /// ensures that the shortened code will be able to be recovered using
    /// slightly different locations.
    ///
    /// It returns either the original code, if the reference location was not
    /// close enough, or the .
    String shorten(String code, double latitude, double longitude) {
      if (!isFull(code)) {
        throw new ArgumentError(
  