public static void generateCaseRuleWoSlot(Vector cases, Symbol className, Symbol slotName) {
    { int numCases = cases.length();
      Surrogate kind = Logic.getDescription(className).surrogateValueInverse;
      List caseNames = List.newList();
      Surrogate slot = Logic.getDescription(slotName).surrogateValueInverse;
      Vector slotValues = Vector.newVector(numCases);

      Logic.clearCases();
      { LogicObject renamed_Case = null;
        Vector vector000 = cases;
        int index000 = 0;
        int length000 = vector000.length();
        Cons collect000 = null;

        for (;index000 < length000; index000 = index000 + 1) {
          renamed_Case = ((LogicObject)((vector000.theArray)[index000]));
          if (collect000 == null) {
            {
              collect000 = Cons.cons(Logic.objectName(renamed_Case), Stella.NIL);
              if (caseNames.theConsList == Stella.NIL) {
                caseNames.theConsList = collect000;
              }
              else {
                Cons.addConsToEndOfConsList(caseNames.theConsList, collect000);
              }
            }
          }
          else {
            {
              collect000.rest = Cons.cons(Logic.objectName(renamed_Case), Stella.NIL);
              collect000 = collect000.rest;
            }
          }
        }
      }
      { LogicObject renamed_Case = null;
        Vector vector001 = cases;
        int index001 = 0;
        int length001 = vector001.length();
        Symbol caseName = null;
        Cons iter000 = caseNames.theConsList;
        int i = Stella.NULL_INTEGER;
        int iter001 = 0;

        for (;(index001 < length001) &&
                  (!(iter000 == Stella.NIL)); 
              index001 = index001 + 1,
              iter000 = iter000.rest,
              iter001 = iter001 + 1) {
          renamed_Case = ((LogicObject)((vector001.theArray)[index001]));
          caseName = ((Symbol)(iter000.value));
          i = iter001;
          { Stella_Object val = LogicObject.getSlotValue(renamed_Case, slot);

            (slotValues.theArray)[i] = val;
            Logic.smartUpdateProposition(Cons.cons(slotName, Cons.cons(caseName, Cons.cons(val, Stella.NIL))), Logic.KWD_RETRACT_TRUE);
          }
        }
      }
      { OutputFileStream fptr = OutputFileStream.newOutputFileStream("current-cases.ste");

        fptr.nativeStream.println("(in-package \"STELLA\")");
        { int i = Stella.NULL_INTEGER;
          int iter002 = 0;
          int upperBound000 = numCases - 1;
          Symbol caseName = null;
          Cons iter003 = caseNames.theConsList;

          for (;(iter002 <= upperBound000) &&
                    (!(iter003 == Stella.NIL)); iter002 = iter002 + 1, iter003 = iter003.rest) {
            i = iter002;
            caseName = ((Symbol)(iter003.value));
            LogicObject.buildCaseFromInstance(((LogicObject)((cases.theArray)[i])), kind);
            fptr.nativeStream.println("(add-case " + caseName + ")");
          }
        }
      }
      Logic.buildCaseRule(kind);
      { Stella_Object val = null;
        Vector vector002 = slotValues;
        int index002 = 0;
        int length002 = vector002.length();
        Symbol caseName = null;
        Cons iter004 = caseNames.theConsList;

        for (;(index002 < length002) &&
                  (!(iter004 == Stella.NIL)); index002 = index002 + 1, iter004 = iter004.rest) {
          val = (vector002.theArray)[index002];
          caseName = ((Symbol)(iter004.value));
          Logic.smartUpdateProposition(Cons.cons(slotName, Cons.cons(caseName, Cons.cons(val, Stella.NIL))), Logic.KWD_ASSERT_TRUE);
        }
      }
    }
  }