anchor.diff:      HighFirstOffset = get_data_point_offset(Higher, LowerStart, HighInterval),
   
       HigherSeconds = Higher#archive_header.seconds,
  -    HigherPoints = LowerSeconds div HigherSeconds,
  -    HigherSize = HigherPoints * ?POINT_SIZE,
  +    HigherPointsPerLower = LowerSeconds div HigherSeconds,
  +    HigherSize = HigherPointsPerLower * ?POINT_SIZE,
       RelativeFirstOffset = HighFirstOffset - HighOffset,
       RelativeLastOffset = mod(RelativeFirstOffset + HigherSize, Higher#archive_header.size),
       HigherLastOffset = RelativeLastOffset + HighOffset,
  
positive.code:             Position = get_data_point_offset(Archive, TimeStamp, BaseInterval),
  
              % write data point based on initial data point
              {ok, _} = file:position(IO, {bof, Position}),
              Interval = interval_start(Archive, TimeStamp),
              file:write(IO, data_point(Interval, Value)),
  
              propagate_lower_archives(IO, Header, Interval, Archive, LowerArchives)
      end.
  
negative.code: 
      {ok, Series} =
      if
          % the amount of higher points that make up one lower point (HigherPointsPerLower)
          % do fit into the higher archive (starting from the current interval/timestamp).
          % this means we can read all required points straight up
          HighFirstOffset < HigherLastOffset ->
              file:read(IO, HigherLastOffset - HighFirstOffset);
          % otherwise we are now basically at the end of the higher archive so that we
          % cannot read the required aggregate points (HigherPointsPerLower) without exceeding
          % the archive's size.
          % that's why we read until the end of the archive first, followed by the
          % remaining number of required aggregate points from the beginning of the archive
  