* @param onlysupersP
   * @param MV_returnarray
   * @return Cons
   */
  public static Cons findDirectSupersAndSubs(Description self, boolean onlysupersP, Object [] MV_returnarray) {
    Logic.finalizeObjects();
    if (self == null) {
      { Cons _return_temp = Stella.NIL;

        MV_returnarray[0] = Stella.NIL;
        MV_returnarray[1] = Stella.NIL;
        return (_return_temp);
      }
    }
    { Object old$Findsupersandsubsdescription$000 = Logic.$FINDSUPERSANDSUBSDESCRIPTION$.get();

      try {
        Native.setSpecial(Logic.$FINDSUPERSANDSUBSDESCRIPTION$, self);
        { Object old$Classificationsession$000 = Logic.$CLASSIFICATIONSESSION$.get();
          Object old$Context$000 = Stella.$CONTEXT$.get();

          try {
            Native.setSpecial(Logic.$CLASSIFICATIONSESSION$, Logic.getClassificationSession(Logic.KWD_DESCRIPTION));
            Native.setSpecial(Stella.$CONTEXT$, ((ClassificationSession)(Logic.$CLASSIFICATIONSESSION$.get())).classificationWorld);
            { boolean virginP = self.virginP();
              int oldcurrenttime = Logic.currentClassificationTime();
              Cons supers = Stella.NIL;
              Cons subs = Stella.NIL;
              Cons equivalents = Stella.NIL;

              if (virginP) {
                Description.introduceIntoClassificationSession(self);
              }
              LogicObject.upclassifyOneDescription(self);
              { NamedDescription renamed_Super = null;
                Cons iter000 = Description.allNamedDirectSuperdescriptions(self, false);

                for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                  renamed_Super = ((NamedDescription)(iter000.value));
                  LogicObject.upclassifyOneDescription(renamed_Super);
                }
              }
              supers = Description.allNamedDirectSuperdescriptions(self, true);
              if (!onlysupersP) {
                LogicObject.downclassifyOneDescription(self);
                subs = LogicObject.allDirectSubcollections(self, true).consify();
              }
              { LogicObject e = null;
                Cons iter001 = LogicObject.allEquivalentCollections(self, false);
                Cons collect000 = null;

                for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                  e = ((LogicObject)(iter001.value));
                  if (Description.namedDescriptionP(((Description)(e)))) {
                    if (collect000 == null) {
                      {
                        collect000 = Cons.cons(e, Stella.NIL);
                        if (equivalents == Stella.NIL) {
                          equivalents = collect000;
                        }
                        else {
                          Cons.addConsToEndOfConsList(equivalents, collect000);
                        }
                      }
                    }
                    else {
                      {
                        collect000.rest = Cons.cons(e, Stella.NIL);
                        collect000 = collect000.rest;
                      }
                    }
                  }
                }
              }
              if (virginP) {
                Description.evaporateVirgin(self);
                ((ClassificationSession)(Logic.$CLASSIFICATIONSESSION$.get())).introductionTimestampStack.pop();
              }
              { Cons _return_temp = supers;

                MV_returnarray[0] = subs;
                MV_returnarray[1] = equivalents;
                return (_return_temp);
              }
            }

          } finally {
            Stella.$CONTEXT$.set(old$Context$000);
            Logic.$CLASSIFICATIONSESSION$.set(old$Classificationsession$000);
          }
        }

      } finally {
        Logic.$FINDSUPERSANDSUBSDESCRIPTION$.set(old$Findsupersandsubsdescription$000);
      }
    }
  }