code: def _bin_update_items(self, items, replace_at_most_one,
                            replacements, leftovers):
          
          for key, values in items:
              # <values> is not a list or an empty list.
              like_list_not_str = self._quacks_like_a_list_but_not_str(values)
              if not like_list_not_str or (like_list_not_str and not values):
                  values = [values]
  
              for value in values:
                  # If the value is [], remove any existing leftovers with
                  # key <key> and set the list of values itself to [],
                  # which in turn will later delete <key> when [] is
                  # passed to omdict.setlist() in
                  # omdict._update_updateall().
                  if value == []:
                      replacements[key] = []
                      leftovers[:] = [l for l in leftovers if key != l[0]]
                      continue
  
                  # If there are existing items with key <key> that have
                  # yet to be marked for replacement, mark that item's
                  # value to be replaced by <value> by appending it to
                  # <replacements>.  TODO: Refactor for clarity
                  if (key in self and
                      (key not in replacements or
                       (key in replacements and
                        replacements[key] == []))):
                      replacements[key] = [value]
                  elif (key in self and not replace_at_most_one and
                        len(replacements[key]) < len(self.values(key))):
                      replacements[key].append(value)
                  else:
                      if replace_at_most_one:
                          replacements[key] = [value]
                      else:
                          leftovers.append((key, value))
docs: Subclassed from omdict._bin_update_items() to make update() and
          updateall() process lists of values as multiple values.
  
          <replacements and <leftovers> are modified directly, ala pass by
          reference.