public static Cons yieldInCursorClausesForArgumentList(Stella_Object collectiontree, StandardObject collectiontype, Symbol keyvar, Symbol valuevar, Object [] MV_returnarray) {
    if (keyvar != null) {
      { 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 key variable specified for `" + Stella_Object.deUglifyParseTree(collectiontype) + "'.");
            }
;
          }

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

        MV_returnarray[0] = Stella.NIL;
        MV_returnarray[1] = Stella.NIL;
        MV_returnarray[2] = Stella.SYM_STELLA_FALSE;
        return (_return_temp);
      }
    }
    if (!MethodSlot.passVariableArgumentsAsListP(((MethodSlot)(Stella.$METHODBEINGWALKED$.get())))) {
      { ParametricTypeSpecifier self000 = ParametricTypeSpecifier.newParametricTypeSpecifier();

        self000.specifierBaseType = Stella.SGT_STELLA_ARGUMENT_LIST_ITERATOR;
        self000.specifierParameterTypes = List.list(Cons.cons(StandardObject.extractParameterType(collectiontype, Stella.SYM_STELLA_ANY_VALUE, new Object[1]), Stella.NIL));
        { ParametricTypeSpecifier iteratortype = self000;

          return (Stella_Object.yieldInCursorClausesForGeneralCollection(Stella_Object.sysTree(Cons.list$(Cons.cons(Stella.SYM_STELLA_SYS_CALL_METHOD, Cons.cons(Stella.SGT_STELLA_ARGUMENT_LIST_ITERATOR, Cons.cons(Stella.SYM_STELLA_ALLOCATE_ITERATOR, Cons.cons(Stella_Object.walkWithoutTypeTree(collectiontree), Cons.cons(Stella.NIL, Stella.NIL)))))), iteratortype, new Object[1]), iteratortype, keyvar, valuevar, MV_returnarray));
        }
      }
    }
    { StandardObject listifiedtype = MethodSlot.yieldListifiedVariableArgumentsType(((MethodSlot)(Stella.$METHODBEINGWALKED$.get())));
      StandardObject elementtype = StandardObject.extractParameterType(collectiontype, Stella.SYM_STELLA_ANY_VALUE, new Object[1]);

      { Cons iteratorclauses = null;
        Cons valueclauses = null;
        Cons bumpclauses = null;
        Stella_Object continuationtest = null;

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

          iteratorclauses = Stella_Object.yieldInCursorClausesForGeneralCollection(Stella_Object.sysTree(collectiontree, listifiedtype, new Object[1]), listifiedtype, keyvar, valuevar, caller_MV_returnarray);
          valueclauses = ((Cons)(caller_MV_returnarray[0]));
          bumpclauses = ((Cons)(caller_MV_returnarray[1]));
          continuationtest = ((Stella_Object)(caller_MV_returnarray[2]));
        }
        if (StandardObject.subTypeSpecOfP(elementtype, Stella.SGT_STELLA_LITERAL)) {
          { Cons clause = null;
            Cons iter000 = ((Cons)(iteratorclauses));

            loop000 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
              clause = ((Cons)(iter000.value));
              if (clause.value == valuevar) {
                clause.secondSetter(elementtype);
                break loop000;
              }
            }
          }
        }
        { Cons _return_temp = iteratorclauses;

          MV_returnarray[0] = valueclauses;
          MV_returnarray[1] = bumpclauses;
          MV_returnarray[2] = continuationtest;
          return (_return_temp);
        }
      }
    }
  }