public static SequenceIndex unfilteredDependentPropositions(Stella_Object self, Surrogate relation) {
    if (Surrogate.subtypeOfP(Stella_Object.safePrimaryType(self), Logic.SGT_LOGIC_PROPOSITION)) {
      { Proposition self000 = ((Proposition)(self));

        if (relation == null) {
          return (self000.dependentPropositions);
        }
        else {
          { SequenceIndex dependents = Logic.createSequenceIndex(Logic.KWD_NON_PAGING, null);

            { Proposition prop = null;
              Iterator iter000 = self000.dependentPropositions.allocateIterator();

              while (iter000.nextP()) {
                prop = ((Proposition)(iter000.value));
                if (((Surrogate)(prop.operator)) == relation) {
                  dependents.push(prop);
                }
              }
            }
            return (dependents);
          }
        }
      }
    }
    else {
      { BacklinksIndex index = Logic.getBacklinksIndex(self);
        SequenceIndex allpropositionsindex = null;

        if (index == null) {
          return (Logic.NIL_NON_PAGING_INDEX);
        }
        allpropositionsindex = index.dependentPropositionsList;
        if (relation == null) {
          return (allpropositionsindex);
        }
        { HashTable table = index.predicatePropositionsTable;
          SequenceIndex list = ((table == null) ? allpropositionsindex : ((SequenceIndex)(table.lookup(relation))));

          if (list == null) {
            list = index.dependentIsaPropositionsList;
          }
          if (list == null) {
            return (Logic.NIL_NON_PAGING_INDEX);
          }
          if ((list == allpropositionsindex) &&
              Stella_Object.isaP(list, Logic.SGT_LOGIC_PAGING_INDEX)) {
            { ObjectStore store = ((PagingIndex)(list)).store;
              SequenceIndex paginglist = ((store != null) ? Logic.createSequenceIndex(store, Cons.cons(Logic.KWD_RELATION, Cons.cons(((Stella.NIL == null) ? Stella.NIL : Stella.NIL), Cons.cons(relation, Cons.cons(self, Stella.NIL))))) : ((SequenceIndex)(null)));

              if (paginglist != null) {
                { Cons value000 = Stella.NIL;

                  { Proposition prop = null;
                    Cons iter001 = ((Cons)(list.theSequence));
                    Cons collect000 = null;

                    for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                      prop = ((Proposition)(iter001.value));
                      if (prop.operator == relation) {
                        if (collect000 == null) {
                          {
                            collect000 = Cons.cons(prop, Stella.NIL);
                            if (value000 == Stella.NIL) {
                              value000 = collect000;
                            }
                            else {
                              Cons.addConsToEndOfConsList(value000, collect000);
                            }
                          }
                        }
                        else {
                          {
                            collect000.rest = Cons.cons(prop, Stella.NIL);
                            collect000 = collect000.rest;
                          }
                        }
                      }
                    }
                  }
                  paginglist.theSequence = value000;
                }
                list = paginglist;
              }
            }
          }
          return (list);
        }
      }
    }
  }