code: def parse_qsl(qs, keep_blank_values=False, strict_parsing=False,
                encoding='utf-8', errors='replace'):
      
      qs, _coerce_result = _coerce_args(qs)
      pairs = [s2 for s1 in qs.split('&') for s2 in s1.split(';')]
      r = []
      for name_value in pairs:
          if not name_value and not strict_parsing:
              continue
          nv = name_value.split('=', 1)
          if len(nv) != 2:
              if strict_parsing:
                  raise ValueError("bad query field: %r" % (name_value,))
              # Handle case of a control-name with no equal sign
              if keep_blank_values:
                  nv.append('')
              else:
                  continue
          if len(nv[1]) or keep_blank_values:
              name = nv[0].replace('+', ' ')
              name = unquote(name, encoding=encoding, errors=errors)
              name = _coerce_result(name)
              value = nv[1].replace('+', ' ')
              value = unquote(value, encoding=encoding, errors=errors)
              value = _coerce_result(value)
              r.append((name, value))
      return r
docs: Parse a query given as a string argument.
  
      Arguments:
  
      qs: percent-encoded query string to be parsed
  
      keep_blank_values: flag indicating whether blank values in
          percent-encoded queries should be treated as blank strings.  A
          true value indicates that blanks should be retained as blank
          strings.  The default false value indicates that blank values
          are to be ignored and treated as if they were  not included.
  
      strict_parsing: flag indicating what to do with parsing errors. If
          false (the default), errors are silently ignored. If true,
          errors raise a ValueError exception.
  
      encoding and errors: specify how to decode percent-encoded sequences
          into Unicode characters, as accepted by the bytes.decode() method.
  
      Returns a list, as G-d intended.