docs: def correct_scaffolds(scaffolds, corrector):
      """Unfinished
      """
  
      new_scaffolds = {}
  
      def are_overlapping(bin1, bin2):
          """Check for overlapping regions between two regions - necessary
          requirement before potentially merging
          """
  
          if bin2 is None:
              return False
  
          init1, _, start1, end1, _ = bin1
          init2, _, start2, end2, _ = bin2
  
          if init1 != init2:
              return False
          else:
              return (start2 <= start1 <= end2) or (start1 <= start2 <= end1)
  
      def merge_bins(bin1, bin2, ignore_ori=True):
          """Painstakingly check for every edge case in order to properly merge
          two overlapping bins.
          """
          init1, _, start1, end1, ori1 = bin1
          init2, _, start2, end2, ori2 = bin2
  
          assert init1 == init2
          start = min(start1, start2)
          end = max(end1, end2)
          if ignore_ori:
              ori = ori1
          else:
              len1 = end1 - start1
              len2 = end2 - start2
              if len2 > len1:
                  ori = ori2
              else:
                  ori = ori1
  
          new_bin = [init1, -3, start, end, ori]
          return new_bin
  
      corrector_bins = copy.deepcopy(corrector)
  
      for name, scaffold in scaffolds.items():
          new_scaffold = []
  
          for _, blocks in itertools.groupby(scaffold, operator.itemgetter(0)):
              merged_bin = None
              while "Reading blocks":
                  try:
                      my_bin = next(blocks)
                      if are_overlapping(my_bin, merged_bin):
                          merged_bin = merge_bins(my_bin, merged_bin)
                          continue
                      else:
                          if merged_bin is not None:
                              new_scaffold.append(merged_bin)
                          merged_bin = my_bin
                          i = 0
                          for correct_bin in corrector_bins:
                              if are_overlapping(my_bin, correct_bin):
                                  merged_bin = merge_bins(my_bin, correct_bin)
                                  corrector_bins.pop(i)
                                  i -= 1
                              i += 1
                  except StopIteration:
                      if merged_bin is not None:
                          new_scaffold.append(merged_bin)
                      break
  
          new_scaffolds[name] = new_scaffold
  
      return new_scaffolds