def recv(self, atom, args):
        if atom is PRINT_1:
            item = resolution(args[0])
            self._print(item)
            return NullObject

        if atom is PRINTLN_1:
            item = resolution(args[0])
            self.println(item)
            return NullObject

        if atom is LNPRINT_1:
            item = resolution(args[0])
            self.lnPrint(item)
            return NullObject

        if atom is QUOTE_1:
            item = resolution(args[0])
            if isinstance(item, CharObject) or isinstance(item, StrObject):
                self.ub.append(item.toQuote())
            else:
                self.objPrint(item)
            return NullObject

        if atom is INDENT_1:
            return self.indent(args[0])

        raise Refused(self, atom, args)

def auditedBy(auditor, specimen):
    """
    Whether an auditor has audited a specimen.
    """
    from typhon.objects.refs import resolution
    from typhon.objects.constants import wrapBool
    return wrapBool(resolution(specimen).auditedBy(auditor))

def promoteToBigInt(o):
    from typhon.objects.refs import resolution
    i = resolution(o)
    if isinstance(i, BigInt):
        return i.bi
    if isinstance(i, IntObject):
        return rbigint.fromint(i.getInt())
    raise WrongType(u"Not promotable to big integer!")

def unwrapList(o, ej=None):
    from typhon.objects.refs import resolution
    l = resolution(o)
    if isinstance(l, ConstList):
        return l.objs
    if isinstance(l, FlexList):
        return l.strategy.fetch_all(l)
    throwStr(ej, u"Not a list!")

 def checkSlot(self):
     if self.committed:
         return True
     self.resolutionBox = resolution(self.resolutionBox)
     if isResolved(self.resolutionBox):
         self.commit()
         return True
     return False

def unwrapBool(o):
    from typhon.objects.refs import resolution
    b = resolution(o)
    if b is TrueObject:
        return True
    if b is FalseObject:
        return False
    raise userError(u"Not a boolean!")

def unwrapSet(o):
    from typhon.objects.refs import resolution
    m = resolution(o)
    if isinstance(m, ConstSet):
        return m.objectSet
    if isinstance(m, FlexSet):
        return m.objectSet
    raise WrongType(u"Not a set!")

def unwrapMap(o):
    from typhon.objects.refs import resolution
    m = resolution(o)
    if isinstance(m, ConstMap):
        return m.objectMap
    if isinstance(m, FlexMap):
        return m.objectMap
    raise WrongType(u"Not a map!")

    def takeTurn(self):
        from typhon.objects.exceptions import sealException
        from typhon.objects.refs import Promise, resolution

        with self._pendingLock:
            resolver, target, atom, args, namedArgs = self._pending.pop(0)

        # Set up our Miranda FAIL.
        if namedArgs.extractStringKey(u"FAIL", None) is None:
            if resolver is not None:
                FAIL = resolver.makeSmasher()
            else:
                from typhon.objects.ejectors import theThrower
                FAIL = theThrower
            namedArgs = namedArgs.withStringKey(u"FAIL", FAIL)

        # If the target is a promise, then we should send to it instead of
        # calling. Try to resolve it as much as possible first, though.
        target = resolution(target)

        # self.log(u"Taking turn: %s<-%s(%s) (resolver: %s)" %
        #          (target.toQuote(), atom.verb,
        #           u", ".join([arg.toQuote() for arg in args]),
        #           u"yes" if resolver is not None else u"no"))
        try:
            if isinstance(target, Promise):
                if resolver is None:
                    target.sendOnly(atom, args, namedArgs)
                else:
                    result = target.send(atom, args, namedArgs)
                    # The resolver may have already been invoked, so we'll use
                    # .resolveRace/1 instead of .resolve/1. ~ C.
                    resolver.resolveRace(result)
            else:
                result = target.callAtom(atom, args, namedArgs)
                if resolver is not None:
                    # Same logic as above.
                    resolver.resolveRace(result)
        except UserException as ue:
            if resolver is not None:
                resolver.smash(sealException(ue))
            else:
                self.log(u"Uncaught user exception while taking turn"
                         u" (and no resolver): %s" %
                         ue.formatError().decode("utf-8"),
                         tags=["serious"])
        except VatCheckpointed:
            self.log(u"Ran out of checkpoints while taking turn",
                     tags=["serious"])
            if resolver is not None:
                resolver.smash(sealException(userError(u"Vat ran out of checkpoints")))
        except Ejecting:
            self.log(u"Ejector tried to escape vat turn boundary",
                     tags=["serious"])
            if resolver is not None:
                resolver.smash(sealException(userError(u"Ejector tried to escape from vat")))

    def __init__(self, ref):
        self.ref = resolution(ref)
        self.fringe = []

        # Compute a "sameYet" hash, which represents a snapshot of how this
        # key's traversal had resolved at the time of key creation.
        snapHash = samenessHash(self.ref, HASH_DEPTH, self.fringe)
        for f in self.fringe:
            snapHash ^= f.fringeHash()
        self.snapHash = snapHash

def promoteToDouble(o):
    from typhon.objects.refs import resolution
    n = resolution(o)
    if isinstance(n, IntObject):
        return float(n.getInt())
    if isinstance(n, DoubleObject):
        return n.getDouble()
    if isinstance(n, BigInt):
        return n.bi.tofloat()
    raise WrongType(u"Failed to promote to double")

def unwrapInt(o):
    from typhon.objects.refs import resolution
    i = resolution(o)
    if isinstance(i, IntObject):
        return i.getInt()
    if isinstance(i, BigInt):
        try:
            return i.bi.toint()
        except OverflowError:
            pass
    raise WrongType(u"Not an integer!")

 def coerce(self, specimen, ej):
     specimen = resolution(specimen)
     val = self.subCoerce(specimen)
     if val is None:
         newspec = specimen.call(u"_conformTo", [self])
         val = self.subCoerce(newspec)
         if val is None:
             throw(ej, StrObject(u"%s does not conform to %s" % (specimen.toQuote(), self.toQuote())))
         else:
             return val
     else:
         return val

def isInt(obj):
    from typhon.objects.refs import resolution
    obj = resolution(obj)
    if isinstance(obj, IntObject):
        return True
    if isinstance(obj, BigInt):
        try:
            obj.bi.toint()
            return True
        except OverflowError:
            return False
    return False

 def objPrint(self, item):
     item = resolution(item)
     if isinstance(item, Promise):
         self.ub.append(u"<promise>")
         return
     elif item in self.context:
         self.ub.append(u"<**CYCLE**>")
         return
     self.context[item] = None
     try:
         item.call(u"_printOn", [self])
     except UserException, e:
         self.ub.append(u"<** %s throws %s when printed**>" % (item.toString(), e.error()))

    def sendOnly(self, target, verb, args, namedArgs):
        """
        Send a message to an object.

        The message will be delivered on some subsequent turn.
        """

        namedArgs = resolution(namedArgs)
        if not isinstance(namedArgs, ConstMap):
            raise WrongType(u"namedArgs must be a ConstMap")
        # Signed, sealed, delivered, I'm yours.
        sendAtom = getAtom(verb, len(args))
        vat = currentVat.get()
        vat.sendOnly(target, sendAtom, args, namedArgs)

def samenessFringe(original, path, fringe, sofar=None):
    """
    Walk an object graph, building up the fringe.

    Returns whether the graph is settled.
    """

    # Resolve the object.
    o = resolution(original)
    # Handle primitive cases first.
    if o in (NullObject, TrueObject, FalseObject):
        return True

    if (isinstance(o, CharObject) or isinstance(o, DoubleObject) or
        isinstance(o, IntObject) or isinstance(o, BigInt) or
        isinstance(o, StrObject) or isinstance(o, BytesObject) or
        isinstance(o, TraversalKey)):
        return True

    if isinstance(o, ConstMap) and o.empty():
        return True

    if sofar is None:
        sofar = {}
    elif o in sofar:
        return True

    if isinstance(o, ConstList):
        sofar[o] = None
        return listFringe(o, fringe, path, sofar)

    if selfless in o.auditorStamps():
        if transparentStamp in o.auditorStamps():
            sofar[o] = None
            return samenessFringe(o.call(u"_uncall", []), path, fringe, sofar)
        if semitransparentStamp in o.auditorStamps():
            sofar[o] = None
            p = o.call(u"_uncall", [])
            if not isinstance(p, SealedPortrayal):
                userError(u'Semitransparent portrayal was not a SealedPortrayal!')
            return samenessFringe(p, path, fringe, sofar)

    if isResolved(o):
        return True

    # Welp, it's unsettled.
    if fringe is not None:
        fringe.append(FringeNode(o, path))
    return False

    def callWithMessage(self, target, message):
        """
        Pass a message of `[verb :Str, args :List, namedArgs :Map]` to an
        object.
        """

        if len(message) != 3:
            raise userError(
                u"callWithPair/2 requires a [verb, args, namedArgs] triple")
        verb = unwrapStr(message[0])
        args = unwrapList(message[1])
        namedArgs = resolution(message[2])
        if not isinstance(namedArgs, ConstMap):
            raise WrongType(u"namedArgs must be a ConstMap")
        return target.call(verb, args, namedArgs)

def nearGuard(specimen, ej):
    """
    A guard over references to near values.

    This guard admits any near value, as well as any resolved reference to any
    near value.

    This guard is unretractable.
    """

    specimen = resolution(specimen)
    if isinstance(specimen, Promise):
        msg = u"Specimen is in non-near state %s" % specimen.state().repr
        throw(ej, StrObject(msg))
    return specimen

def samenessFringe(original, path, fringe, sofar=None):
    """
    Walk an object graph, building up the fringe.

    Returns whether the graph is settled.
    """

    # Resolve the object.
    o = resolution(original)
    # Handle primitive cases first.
    if o is NullObject:
        return True

    if (
        isinstance(o, BoolObject)
        or isinstance(o, CharObject)
        or isinstance(o, DoubleObject)
        or isinstance(o, IntObject)
        or isinstance(o, BigInt)
        or isinstance(o, StrObject)
        or isinstance(o, TraversalKey)
    ):
        return True

    if isinstance(o, ConstMap) and len(o.objectMap) == 0:
        return True

    if sofar is None:
        sofar = {}
    elif o in sofar:
        return True

    if isinstance(o, ConstList):
        sofar[o] = None
        return listFringe(o, fringe, path, sofar)

    if selfless in o.auditorStamps():
        if transparentStamp in o.auditorStamps():
            return samenessFringe(o.call(u"_uncall", []), path, fringe, sofar)
        # XXX Semitransparent support goes here

    if isResolved(o):
        return True

    # Welp, it's unsettled.
    if fringe is not None:
        fringe.append(FringeNode(o, path))
    return False