docs: def reasoning_routine(self, groups, check, priority_flag=3,
                            _top_level=True):
          """
          print routine performed
          @param list groups: the Result groups
          @param str check: checker name
          @param int priority_flag: indicates the weight of the groups
          @param bool _top_level: indicates the level of the group so as to
                                  print out the appropriate header string
          """
  
          sort_fn = lambda x: x.weight
          groups_sorted = sorted(groups, key=sort_fn, reverse=True)
  
          # create dict of the groups -> {level: [reasons]}
          result = {key: [v for v in valuesiter if v.value[0] != v.value[1]]
                      for key, valuesiter in itertools.groupby(groups_sorted,
                                                               key=sort_fn)}
          priorities = self.checkers[check]._cc_display_headers
  
          def process_table(res, check):
              """Recursively calls reasoning_routine to parse out child reasons
              from the parent reasons.
              @param Result res: Result object
              @param str check: checker name"""
  
              issue = res.name
              if not res.children:
                  reasons = res.msgs
              else:
                  child_reasons = self.reasoning_routine(res.children,
                                                         check, _top_level=False)
                  # there shouldn't be messages if there are children
                  # is this a valid assumption?
                  reasons = child_reasons
  
              return issue, reasons
  
          # iterate in reverse to the min priority requested;
          # the higher the limit, the more lenient the output
          proc_strs = ""
          for level in range(3, priority_flag - 1, -1):
              level_name = priorities.get(level, level)
              # print headers
              proc_strs = []
  
              # skip any levels that aren't in the result
              if level not in result:
                  continue
  
              # skip any empty result levels
              if len(result[level]) > 0:
                  # only print priority headers at top level, i.e. non-child
                  # datasets
                  if _top_level:
                      width = 2 * self.col_width
                      print("\n")
                      print('{:^{width}}'.format(level_name, width=width))
                      print("-" * width)
  
                  data_issues = [process_table(res, check) for res in result[level]]
  
                  has_printed = False
                  for issue, reasons in data_issues:
                      # if this isn't the first printed issue, add a newline
                      # separating this and the previous level
                      if has_printed:
                          print("")
                      # join alphabetized reasons together
                      reason_str = "\n".join('* {}'.format(r) for r in sorted(reasons, key=lambda x: x[0]))
                      proc_str = "{}\n{}".format(issue, reason_str)
                      print(proc_str)
                      proc_strs.append(proc_str)
                      has_printed = True
          return "\n".join(proc_strs)