public static SequenceIndex unfilteredDependentImpliesPropositions(Stella_Object self) {
    { Surrogate testValue000 = Stella_Object.safePrimaryType(self);

      if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_LOGIC_OBJECT)) {
        { LogicObject self000 = ((LogicObject)(self));

          { BacklinksIndex index = Logic.getBacklinksIndex(self000);

            if (index == null) {
              return (Logic.NIL_NON_PAGING_INDEX);
            }
            else {
              { HashTable table = index.predicatePropositionsTable;
                SequenceIndex list = null;

                if (table != null) {
                  list = ((SequenceIndex)(table.lookup(Logic.SGT_PL_KERNEL_KB_SUBSET_OF)));
                  if (list == null) {
                    list = Logic.NIL_NON_PAGING_INDEX;
                  }
                }
                if (list == null) {
                  list = index.dependentPropositionsList;
                  if (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(Logic.SGT_PL_KERNEL_KB_SUBSET_OF, Cons.cons(self000, Stella.NIL))))) : ((SequenceIndex)(null)));

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

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

                            for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                              prop = ((Proposition)(iter000.value));
                              if (prop.operator == Logic.SGT_PL_KERNEL_KB_SUBSET_OF) {
                                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);
              }
            }
          }
        }
      }
      else if (Surrogate.subtypeOfP(testValue000, Logic.SGT_STELLA_THING)) {
        { Thing self000 = ((Thing)(self));

          { BacklinksIndex index = Logic.getBacklinksIndex(self000);

            if (index == null) {
              return (Logic.NIL_NON_PAGING_INDEX);
            }
            else {
              { HashTable table = index.predicatePropositionsTable;
                SequenceIndex list = null;

                if (table != null) {
                  list = ((SequenceIndex)(table.lookup(Logic.SGT_PL_KERNEL_KB_SUBSET_OF)));
                  if (list == null) {
                    list = Logic.NIL_NON_PAGING_INDEX;
                  }
                }
                if (list == null) {
                  list = index.dependentPropositionsList;
                  if (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(Logic.SGT_PL_KERNEL_KB_SUBSET_OF, Cons.cons(self000, Stella.NIL))))) : ((SequenceIndex)(null)));

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

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

                            for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                              prop = ((Proposition)(iter001.value));
                              if (prop.operator == Logic.SGT_PL_KERNEL_KB_SUBSET_OF) {
                                if (collect001 == null) {
                                  {
                                    collect001 = Cons.cons(prop, Stella.NIL);
                                    if (value001 == Stella.NIL) {
                                      value001 = collect001;
                                    }
                                    else {
                                      Cons.addConsToEndOfConsList(value001, collect001);
                                    }
                                  }
                                }
                                else {
                                  {
                                    collect001.rest = Cons.cons(prop, Stella.NIL);
                                    collect001 = collect001.rest;
                                  }
                                }
                              }
                            }
                          }
                          paginglist.theSequence = value001;
                        }
                        list = paginglist;
                      }
                    }
                  }
                }
                return (list);
              }
            }
          }
        }
      }
      else {
        { BacklinksIndex index = Logic.getBacklinksIndex(self);

          if (index == null) {
            return (Logic.NIL_NON_PAGING_INDEX);
          }
          else {
            { HashTable table = index.predicatePropositionsTable;

              if (table != null) {
                { SequenceIndex temp000 = ((SequenceIndex)(table.lookup(Logic.SGT_PL_KERNEL_KB_SUBSET_OF)));

                  { SequenceIndex value002 = ((temp000 != null) ? ((SequenceIndex)(temp000)) : Logic.NIL_NON_PAGING_INDEX);

                    return (((SequenceIndex)(value002)));
                  }
                }
              }
              else {
                return (index.dependentPropositionsList);
              }
            }
          }
        }
      }
    }
  }