code: def a85decode(
      b, *, foldspaces=False, adobe=False, ignorechars=b" \t\n\r\v"
  ):
      """Decode the Ascii85 encoded bytes-like object or ASCII string b.
  
      foldspaces is a flag that specifies whether the 'y' short sequence should be
      accepted as shorthand for 4 consecutive spaces (ASCII 0x20). This feature is
      not supported by the "standard" Adobe encoding.
  
      adobe controls whether the input sequence is in Adobe Ascii85 format (i.e.
      is framed with <~ and ~>).
  
      ignorechars should be a byte string containing characters to ignore from the
      input. This should only contain whitespace characters, and by default
      contains all whitespace characters in ASCII.
  
      The result is returned as a bytes object.
      """
      b = _bytes_from_decode_data(b)
      if adobe:
          if not b.endswith(_A85END):
              raise ValueError(
                  "Ascii85 encoded byte sequences must end "
                  "with {!r}".format(_A85END)
              )
          if b.startswith(_A85START):
              b = b[2:-2]  # Strip off start/end markers
          else:
              b = b[:-2]
      #
      # We have to go through this stepwise, so as to ignore spaces and handle
      # special short sequences
      #
      packI = struct.Struct("!I").pack
      decoded = []
      decoded_append = decoded.append
      curr = []
      curr_append = curr.append
      curr_clear = curr.clear
      for x in b + b"u" * 4:
          if b"!"[0] <= x <= b"u"[0]:
              curr_append(x)
              if len(curr) == 5:
                  acc = 0
                  for x in curr:
                      acc = 85 * acc + (x - 33)
                  try:
                      decoded_append(packI(acc))
                  except struct.error:
                      raise ValueError("Ascii85 overflow") from None
                  curr_clear()
          elif x == b"z"[0]:
              if curr:
                  raise ValueError("z inside Ascii85 5-tuple")
              decoded_append(b"\0\0\0\0")
          elif foldspaces and x == b"y"[0]:
              if curr:
                  raise ValueError("y inside Ascii85 5-tuple")
              decoded_append(b"\x20\x20\x20\x20")
          elif x in ignorechars:
              # Skip whitespace
              continue
          else:
              raise ValueError("Non-Ascii85 digit found: %c" % x)
  
      result = b"".join(decoded)
      padding = 4 - len(curr)
      if padding:
          # Throw away the extra padding
          result = result[:-padding]
      return result
  
imports: import re
  import struct
  import binascii
label_desc: Use image node_id 18 for calling a global function with example usage: a85decode(b) and returns: result