public static void modularInduceDecisionRules(Symbol relationName, Symbol className, List modules) {
    relationName = ((Symbol)(relationName.permanentify()));
    className = ((Symbol)(className.permanentify()));
    Logic.clearTrainingExamples();
    Logic.clearCases();
    { Surrogate renamed_Class = Logic.getDescription(className).surrogateValueInverse;
      Surrogate relation = Logic.getDescription(relationName).surrogateValueInverse;
      List ilist = List.newList();
      DecisionTree tree = null;
      Module home = ((Module)(Stella.$MODULE$.get()));
      int num = ilist.length();
      Vector instanceVec = Vector.newVector(modules.length());
      Vector instances = null;

      if (!Logic.$ALLOW_RECURSIVE_DECISION_NODES$) {
        Logic.$TABOO_OPERATORS$.insertNew(relation);
      }
      System.out.println("Building Classification Rule");
      { Module module = null;
        Cons iter000 = modules.theConsList;
        int j = Stella.NULL_INTEGER;
        int iter001 = 0;

        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest, iter001 = iter001 + 1) {
          module = ((Module)(iter000.value));
          j = iter001;
          module.changeModule();
          ilist = Logic.allClassInstances(renamed_Class).listify();
          num = ilist.length();
          instances = Vector.newVector(num);
          { Stella_Object instance = null;
            Cons iter002 = ilist.theConsList;
            int i = Stella.NULL_INTEGER;
            int iter003 = 0;

            for (;!(iter002 == Stella.NIL); iter002 = iter002.rest, iter003 = iter003 + 1) {
              instance = iter002.value;
              i = iter003;
              (instances.theArray)[i] = (((LogicObject)(instance)));
            }
          }
          (instanceVec.theArray)[j] = instances;
          Logic.generateClassificationRule(instances, relationName, className, false);
        }
      }
      home.changeModule();
      Logic.buildClassificationRule(relationName, className);
      System.out.println("Generating Training Examples");
      { Module module = null;
        Cons iter004 = modules.theConsList;
        Vector vec = null;
        Vector vector000 = instanceVec;
        int index000 = 0;
        int length000 = vector000.length();

        for (;(!(iter004 == Stella.NIL)) &&
                  (index000 < length000); iter004 = iter004.rest, index000 = index000 + 1) {
          module = ((Module)(iter004.value));
          vec = ((Vector)((vector000.theArray)[index000]));
          module.changeModule();
          Logic.generateClassificationTrainingExamples(vec, relation, true);
        }
      }
      System.out.println("Inducing Decision Tree");
      tree = Logic.induceDecisionTree(Logic.$TRAINING_EXAMPLES$);
      tree.concept = relationName;
      if (((TrainingExample)(Logic.$TRAINING_EXAMPLES$.first())).module != null) {
        ((TrainingExample)(Logic.$TRAINING_EXAMPLES$.first())).module.changeModule();
      }
    }
  }