public static Cons yieldNewArgumentsTree(Cons keywordsandvalues, StandardObject classtype, Symbol selfvariable, Object [] MV_returnarray) {
    if ((((keywordsandvalues.length()) % 2) == 1)) {
      { 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(" Odd number of arguments in 'new' expression: `" + Stella_Object.deUglifyParseTree(keywordsandvalues) + "'.");
            }
;
          }

        } finally {
          Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
        }
      }
      { Cons _return_temp = Stella.NIL;

        MV_returnarray[0] = Stella.NIL;
        return (_return_temp);
      }
    }
    { Stella_Class renamed_Class = StandardObject.typeSpecToClass(classtype);

      { PropertyList self000 = PropertyList.newPropertyList();

        self000.thePlist = keywordsandvalues;
        { PropertyList plist = self000;
          Cons otherassignments = Stella.NIL;
          Cons requiredvalues = null;
          Symbol slotname = null;
          Slot slot = null;

          { PropertyListIterator it = ((PropertyListIterator)(plist.allocateIterator()));

            while (it.nextP()) {
              if (!Stella_Object.keywordP(it.key)) {
                { Object old$PrintreadablyP$001 = 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 slot keyword `" + it.key + "' in NEW expression.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$001);
                  }
                }
                { Cons _return_temp = Stella.NIL;

                  MV_returnarray[0] = Stella.NIL;
                  return (_return_temp);
                }
              }
              slotname = Symbol.internSymbolInModule(((Keyword)(it.key)).symbolName, renamed_Class.homeModule(), false);
              slot = Stella_Class.lookupSlot(renamed_Class, slotname);
              if (slot == null) {
                { Object old$PrintreadablyP$002 = 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(" No such slot `" + Stella_Object.deUglifyParseTree(slotname) + "' on the class `" + Stella_Class.className(renamed_Class) + "'.");
                      }
;
                    }

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$002);
                  }
                }
                { Cons _return_temp = Stella.NIL;

                  MV_returnarray[0] = Stella.NIL;
                  return (_return_temp);
                }
              }
              it.keySetter(slot);
            }
          }
          requiredvalues = StandardObject.extractRequiredArgumentValues(classtype, plist);
          { Slot slot000 = null;
            Stella_Object valueref = null;
            Cons iter000 = ((PropertyList)(plist)).thePlist;
            Cons collect000 = null;

            for (;!(iter000 == Stella.NIL); iter000 = iter000.rest.rest) {
              slot000 = ((Slot)(iter000.value));
              valueref = iter000.rest.value;
              if (!Stella_Object.storageSlotP(slot000)) {
                { MethodSlot method = ((MethodSlot)(slot000));

                  if (((Symbol)(KeyValueList.dynamicSlotValue(method.dynamicSlots, Stella.SYM_STELLA_STORAGE_SLOT, null))) != null) {
                    slot000 = Stella_Class.lookupSlot(renamed_Class, ((Symbol)(KeyValueList.dynamicSlotValue(method.dynamicSlots, Stella.SYM_STELLA_STORAGE_SLOT, null))));
                  }
                }
              }
              if (collect000 == null) {
                {
                  collect000 = Cons.cons(Cons.list$(Cons.cons(Stella.SYM_STELLA_SETF, Cons.cons(Cons.cons(slot000.slotName, Cons.cons(selfvariable, Stella.NIL)), Cons.cons(valueref, Cons.cons(Stella.NIL, Stella.NIL))))), Stella.NIL);
                  if (otherassignments == Stella.NIL) {
                    otherassignments = collect000;
                  }
                  else {
                    Cons.addConsToEndOfConsList(otherassignments, collect000);
                  }
                }
              }
              else {
                {
                  collect000.rest = Cons.cons(Cons.list$(Cons.cons(Stella.SYM_STELLA_SETF, Cons.cons(Cons.cons(slot000.slotName, Cons.cons(selfvariable, Stella.NIL)), Cons.cons(valueref, Cons.cons(Stella.NIL, Stella.NIL))))), Stella.NIL);
                  collect000 = collect000.rest;
                }
              }
            }
          }
          { Cons _return_temp = requiredvalues;

            MV_returnarray[0] = otherassignments;
            return (_return_temp);
          }
        }
      }
    }
  }