public static Cons walkSetfTree(Cons tree, Object [] MV_returnarray) {
    { Cons place = null;

      if (Stella_Object.consP(tree.rest.value)) {
        place = ((Cons)(tree.rest.value));
      }
      if (!((place != null) &&
          (Stella_Object.symbolP(place.value) &&
           (place.length() >= (((place.value == Stella.SYM_STELLA_SLOT_VALUE) ? 3 : 2)))))) {
        { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

          try {
            Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
            Stella.signalTranslationError();
            if (!(Stella.suppressWarningsP())) {
              Stella.printErrorContext(">> ERROR: ", Stella.STANDARD_ERROR);
              {
                Stella.STANDARD_ERROR.nativeStream.println();
                Stella.STANDARD_ERROR.nativeStream.println(" Illegal place argument in 'setf' expression: `" + Stella_Object.deUglifyParseTree(tree) + "'.");
              }
;
            }

          } finally {
            Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
          }
        }
        return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
      }
      if (Cons.badArgumentCountP(tree, 2)) {
        return (Stella_Object.walkDontCallMeTree(tree, Stella.SGT_STELLA_VOID, MV_returnarray));
      }
      { Stella_Object objectref = null;
        StandardObject objecttype = null;

        { Object [] caller_MV_returnarray = new Object[1];

          objectref = Stella_Object.walkATree(place.rest.value, caller_MV_returnarray);
          objecttype = ((StandardObject)(caller_MV_returnarray[0]));
        }
        objectref = Stella_Object.coerceATree(objectref, objecttype, objecttype, new Object[1]);
        { Stella_Class objectclass = StandardObject.typeSpecToClass(objecttype);
          Stella_Object slotname = place.value;
          Slot slot = Stella_Class.lookupSlot(objectclass, ((Symbol)(slotname)));
          StandardObject slottype = null;
          Cons otherplacearguments = place.rest.rest;
          Cons otree = Stella.NIL;

          if (slot != null) {
            slottype = slot.computeReturnTypeSpec(objecttype);
          }
          { Stella_Object valueref = null;
            StandardObject valuetypespec = null;

            { Object [] caller_MV_returnarray = new Object[1];

              valueref = Stella_Object.walkExpressionTree(tree.rest.rest.value, slottype, Stella.SYM_STELLA_SETF, true, caller_MV_returnarray);
              valuetypespec = ((StandardObject)(caller_MV_returnarray[0]));
            }
            if (Stella_Object.proceduralExpressionP(valueref)) {
              tree.thirdSetter(valueref);
              { Cons ootree = null;
                StandardObject otypespec = null;

                { Object [] caller_MV_returnarray = new Object[1];

                  ootree = Cons.transformProceduralExpression(tree, ((Cons)(valueref)), valuetypespec, caller_MV_returnarray);
                  otypespec = ((StandardObject)(caller_MV_returnarray[0]));
                }
                { Cons _return_temp = ootree;

                  MV_returnarray[0] = otypespec;
                  return (_return_temp);
                }
              }
            }
            if (slotname == Stella.SYM_STELLA_SLOT_VALUE) {
              return (Cons.walkAConsTree(Cons.list$(Cons.cons(Stella.SYM_STELLA_SLOT_VALUE_SETTER, Cons.cons(objectref, Cons.cons(Cons.cons(valueref, otherplacearguments.concatenate(Stella.NIL, Stella.NIL)), Stella.NIL)))), MV_returnarray));
            }
            if (Surrogate.subtypeOfStorageSlotP(Stella_Object.safePrimaryType(slot))) {
              { StorageSlot slot000 = ((StorageSlot)(slot));

                if ((slot000.writer() != null) ||
                    (Stella_Class.lookupSlot(objectclass, Symbol.yieldSetterMethodName(((Symbol)(slotname)))) != null)) {
                  return (Cons.walkAConsTree(Cons.cons(((slot000.writer() != null) ? slot000.writer() : Symbol.yieldSetterMethodName(((Symbol)(slotname)))), Cons.cons(objectref, Cons.cons(valueref, otherplacearguments.concatenate(Stella.NIL, Stella.NIL)))), MV_returnarray));
                }
                if (StorageSlot.systemDefinedSlotWriterP(slot000)) {
                  { Stella_Object value000 = null;
                    StandardObject value001 = null;

                    { Object [] caller_MV_returnarray = new Object[1];

                      value000 = Slot.sysTreeIfNeeded(slot000, Cons.list$(Cons.cons(Stella.SYM_STELLA_SYS_CALL_METHOD, Cons.cons(slot000.slotOwner, Cons.cons(Cons.cons(Symbol.yieldSetterMethodName(((Symbol)(slotname))), Cons.cons(objectref, Cons.cons(Stella_Object.walkExpressionTree(valueref, slottype, Stella.SYM_STELLA_SETF, false, new Object[1]), Stella.NIL))), Stella.NIL)))), objecttype, slottype, caller_MV_returnarray);
                      value001 = ((StandardObject)(caller_MV_returnarray[0]));
                    }
                    { Cons _return_temp = ((Cons)(value000));

                      MV_returnarray[0] = value001;
                      return (_return_temp);
                    }
                  }
                }
                otree = StorageSlot.yieldSlotValueSetterTree(slot000, objectref, objecttype, valueref, slottype, null, new Object[1]);
                if (Stella_Object.proceduralExpressionP(otree)) {
                  { Cons _return_temp = otree;

                    MV_returnarray[0] = slottype;
                    return (_return_temp);
                  }
                }
                else {
                  { Stella_Object value002 = null;
                    StandardObject value003 = null;

                    { Object [] caller_MV_returnarray = new Object[1];

                      value002 = Slot.sysTreeIfNeeded(slot000, otree, objecttype, slottype, caller_MV_returnarray);
                      value003 = ((StandardObject)(caller_MV_returnarray[0]));
                    }
                    { Cons _return_temp = ((Cons)(value002));

                      MV_returnarray[0] = value003;
                      return (_return_temp);
                    }
                  }
                }
              }
            }
            else {
              return (Cons.walkAConsTree(Cons.cons(Symbol.yieldSetterMethodName(((Symbol)(slotname))), Cons.cons(objectref, Cons.cons(valueref, otherplacearguments.concatenate(Stella.NIL, Stella.NIL)))), MV_returnarray));
            }
          }
        }
      }
    }
  }