code: func ParsePointsWithPrecision(buf []byte, defaultTime time.Time, precision string) ([]Point, error) {
  	points := make([]Point, 0, bytes.Count(buf, []byte{'\n'})+1)
  	var (
  		pos    int
  		block  []byte
  		failed []string
  	)
  	for pos < len(buf) {
  		pos, block = scanLine(buf, pos)
  		pos++
  
  		if len(block) == 0 {
  			continue
  		}
  
  		// lines which start with '#' are comments
  		start := skipWhitespace(block, 0)
  
  		// If line is all whitespace, just skip it
  		if start >= len(block) {
  			continue
  		}
  
  		if block[start] == '#' {
  			continue
  		}
  
  		// strip the newline if one is present
  		if block[len(block)-1] == '\n' {
  			block = block[:len(block)-1]
  		}
  
  		pt, err := parsePoint(block[start:], defaultTime, precision)
  		if err != nil {
  			failed = append(failed, fmt.Sprintf("unable to parse '%s': %v", string(block[start:]), err))
  		} else {
  			points = append(points, pt)
  		}
  
  	}
  	if len(failed) > 0 {
  		return points, fmt.Errorf("%s", strings.Join(failed, "\n"))
  	}
  	return points, nil
  
  }
docs: // ParsePointsWithPrecision is similar to ParsePoints, but allows the
  // caller to provide a precision for time.
  //
  // NOTE: to minimize heap allocations, the returned Points will refer to subslices of buf.
  // This can have the unintended effect preventing buf from being garbage collected.