code: def process_sums(self):
          
  
          # sums that should be deactivated (but not removed completely)
          to_deactivate = set([])
  
          for l in self.core_sums:
              if self.wght[l] == self.minw:
                  # marking variable as being a part of the core
                  # so that next time it is not used as an assump
                  self.garbage.add(l)
              else:
                  # do not remove this variable from assumps
                  # since it has a remaining non-zero weight
                  self.wght[l] -= self.minw
  
                  # deactivate this assumption and put at a lower level
                  if self.wght[l] < self.blop[self.levl]:
                      self.wstr[self.wght[l]].append(l)
                      to_deactivate.add(l)
  
              # increase bound for the sum
              t, b = self.update_sum(l)
  
              # updating bounds and weights
              if b < len(t.rhs):
                  lnew = -t.rhs[b]
                  if lnew in self.garbage:
                      self.garbage.remove(lnew)
                      self.wght[lnew] = 0
  
                  if lnew not in self.wght:
                      self.set_bound(t, b)
                  else:
                      self.wght[lnew] += self.minw
  
              # put this assumption to relaxation vars
              self.rels.append(-l)
  
          # deactivating unnecessary sums
          self.sums = list(filter(lambda x: x not in to_deactivate, self.sums))
docs: A redefined version of :func:`RC2.process_sums`. The only
              modification affects the clauses whose weight after
              splitting becomes less than the weight of the current
              optimization level. Such clauses are deactivated and to be
              reactivated at a later stage.