docs: def pretty_deref_const(self, index):
          """
          A string representation of the end-value of a constant.  This will
          deref the constant index, and if it is a compound type, will
          continue dereferencing until it can compose the full value
          (eg: a CONST_Methodref will be composed of its class, name,
          and value derefenced constants)
          """
  
          t, v = self.consts[index]
  
          if t == CONST_String:
              result = self.deref_const(v)
  
          elif t in (CONST_Utf8,
                     CONST_Integer, CONST_Float,
                     CONST_Long, CONST_Double):
              result = v
  
          elif t == CONST_Class:
              result = _pretty_class(self.deref_const(v))
  
          elif t == CONST_Fieldref:
              cn = self.deref_const(v[0])
              cn = _pretty_class(cn)
  
              n, t = self.deref_const(v[1])
  
              result = "%s.%s:%s" % (cn, n, _pretty_type(t))
  
          elif t in (CONST_Methodref,
                     CONST_InterfaceMethodref):
  
              cn = self.deref_const(v[0])
              cn = _pretty_class(cn)
  
              n, t = self.deref_const(v[1])
  
              args, ret = tuple(_pretty_typeseq(t))
  
              result = "%s.%s%s:%s" % (cn, n, args, ret)
  
          elif t == CONST_NameAndType:
              a, b = (self.deref_const(i) for i in v)
              b = "".join(_pretty_typeseq(b))
              result = "%s:%s" % (a, b)
  
          elif t == CONST_ModuleId:
              a, b = (self.deref_const(i) for i in v)
              result = "%s@%s" % (a, b)
  
          elif not t:
              # the skipped-type, meaning the prior index was a
              # two-slotter.
              result = ""
  
          else:
              raise Unimplemented("No pretty for const type %r" % t)
  
          return result