docs: def count_diffs(align, feats, inseq, locus, cutoff,
                  verbose=False, verbosity=0):
      """
      count_diffs - Counts the number of mismatches, gaps, and insertions and then determines if those are within an acceptable range.
  
      :param align: The alignment
      :type align: ``List``
      :param feats: Dictonary of the features
      :type feats: ``dict``
      :param locus: The gene locus associated with the sequence.
      :type locus: ``str``
      :param inseq: The input sequence
      :type inseq: ``str``
      :param cutoff: The alignment cutoff
      :type cutoff: ``float``
      :param verbose: Flag for running in verbose mode.
      :type verbose: ``bool``
      :param verbosity: Numerical value to indicate how verbose the output will be in verbose mode.
      :type verbosity: ``int``
      :rtype: ``List``
      """
  
      nfeats = len(feats.keys())
      mm = 0
      insr = 0
      dels = 0
      gaps = 0
      match = 0
      lastb = ''
      l = len(align[0]) if len(align[0]) > len(align[1]) else len(align[1])
  
      # Counting gaps, mismatches and insertions
      for i in range(0, l):
          if align[0][i] == "-" or align[1][i] == "-":
              if align[0][i] == "-":
                  insr += 1
                  if lastb != '-':
                      gaps += 1
                  lastb = "-"
              if align[1][i] == "-":
                  dels += 1
                  if lastb != '-':
                      gaps += 1
                  lastb = "-"
          else:
              lastb = ''
              if align[0][i] != align[1][i]:
                  mm += 1
              else:
                  match += 1
  
      gper = gaps / nfeats
      delper = dels / l
      iper = insr / l
      mmper = mm / l
      mper = match / l
      mper2 = match / len(inseq)
  
      logger = logging.getLogger("Logger." + __name__)
  
      if verbose and verbosity > 0:
          logger.info("Features algined = " + ",".join(list(feats.keys())))
          logger.info('{:<22}{:<6d}'.format("Number of feats: ", nfeats))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of gaps: ", gaps, gper))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of deletions: ", dels, delper))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of insertions: ", insr, iper))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of mismatches: ", mm, mmper))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of matches: ", match, mper))
          logger.info('{:<22}{:<6d}{:<1.2f}'.format("Number of matches: ", match, mper2))
      indel = iper + delper
  
      # ** HARD CODED LOGIC ** #
      if len(inseq) > 6000 and mmper < .10 and mper2 > .80:
          if verbose:
              logger.info("Alignment coverage high enough to complete annotation 11")
          return insr, dels
      else:
          # TODO: These numbers need to be fine tuned
          indel_mm = indel + mper2
          if (indel > 0.5 or mmper > 0.05) and mper2 < cutoff and indel_mm != 1:
              if verbose:
                  logger.info("Alignment coverage NOT high enough to return annotation")
              return Annotation(complete_annotation=False)
          else:
              if verbose:
                  logger.info("Alignment coverage high enough to complete annotation")
              return insr, dels