public static Iterator allMatchingPropositions(Proposition self) {
    { Stella_Object backlinkedargument = null;
      boolean nomatchingpropositionsP = false;

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

        backlinkedargument = Proposition.selectArgumentWithBacklinks(self, caller_MV_returnarray);
        nomatchingpropositionsP = ((boolean)(((BooleanWrapper)(caller_MV_returnarray[0])).wrapperValue));
      }
      if (nomatchingpropositionsP) {
        return (Logic.EMPTY_PROPOSITIONS_ITERATOR);
      }
      if (backlinkedargument == null) {
        if (Logic.$CYC_KLUDGES_ENABLEDp$) {
          { boolean testValue000 = false;

            { boolean foundP000 = false;

              { Stella_Object arg = null;
                Vector vector000 = self.arguments;
                int index000 = 0;
                int length000 = vector000.length();

                loop000 : for (;index000 < length000; index000 = index000 + 1) {
                  arg = (vector000.theArray)[index000];
                  if (Logic.argumentBoundTo(arg) != null) {
                    foundP000 = true;
                    break loop000;
                  }
                }
              }
              testValue000 = foundP000;
            }
            if (testValue000) {
              testValue000 = NamedDescription.dynamicallyEstimateExtensionSize(Logic.getDescription(self.operator)) > 500;
            }
            if (testValue000) {
              return (Logic.EMPTY_PROPOSITIONS_ITERATOR);
            }
          }
        }
        return (Proposition.allMatchingExtensionMembers(self, true));
      }
      { Cons patternargs = Stella.NIL;
        Stella_Object binding = null;

        { Stella_Object arg = null;
          Vector vector001 = self.arguments;
          int index001 = 0;
          int length001 = vector001.length();
          Cons collect000 = null;

          for (;index001 < length001; index001 = index001 + 1) {
            arg = (vector001.theArray)[index001];
            binding = Logic.argumentBoundTo(arg);
            if ((binding != null) &&
                (Stella_Object.isaP(binding, Logic.SGT_LOGIC_PROPOSITION) &&
                 (!Proposition.allArgumentsBoundP(((Proposition)(binding)))))) {
              binding = null;
            }
            if (collect000 == null) {
              {
                collect000 = Cons.cons(Logic.valueOf(binding), Stella.NIL);
                if (patternargs == Stella.NIL) {
                  patternargs = collect000;
                }
                else {
                  Cons.addConsToEndOfConsList(patternargs, collect000);
                }
              }
            }
            else {
              {
                collect000.rest = Cons.cons(Logic.valueOf(binding), Stella.NIL);
                collect000 = collect000.rest;
              }
            }
          }
        }
        if (patternargs.rest == Stella.NIL) {
          return (Logic.allTrueDependentPropositions(backlinkedargument, ((Surrogate)(self.operator)), true));
        }
        else {
          { Cons pattern = Cons.cons(Logic.KWD_RELATION, Cons.cons(((Stella.NIL == null) ? Stella.NIL : Stella.NIL), Cons.cons(self.operator, patternargs)));

            { SpecializingPropositionsIterator self001 = SpecializingPropositionsIterator.newSpecializingPropositionsIterator();

              self001.selectionPattern = pattern;
              self001.propositionCursor = Logic.selectPropositions(pattern).allocateIterator();
              { SpecializingPropositionsIterator value000 = self001;

                return (value000);
              }
            }
          }
        }
      }
    }
  }