public static void transferPropositionsExceptFor(Stella_Object from, Stella_Object to, List exceptpropositions) {
    if (((Boolean)(Logic.$LOADINGREGENERABLEOBJECTSp$.get())).booleanValue()) {
      return;
    }
    { Cons value000 = Stella.NIL;

      { Proposition p = null;
        Iterator iter000 = Logic.unfilteredDependentPropositions(to, null).allocateIterator();
        Cons collect000 = null;

        while (iter000.nextP()) {
          p = ((Proposition)(iter000.value));
          if (collect000 == null) {
            {
              collect000 = Cons.cons(p, Stella.NIL);
              if (value000 == Stella.NIL) {
                value000 = collect000;
              }
              else {
                Cons.addConsToEndOfConsList(value000, collect000);
              }
            }
          }
          else {
            {
              collect000.rest = Cons.cons(p, Stella.NIL);
              collect000 = collect000.rest;
            }
          }
        }
      }
      { Cons topropositions = value000;
        Stella_Object tovalue = null;

        if (exceptpropositions == null) {
          exceptpropositions = Stella.NIL_LIST;
        }
        { Object old$Evaluationmode$000 = Logic.$EVALUATIONMODE$.get();

          try {
            Native.setSpecial(Logic.$EVALUATIONMODE$, Logic.KWD_EXTENSIONAL_ASSERTION);
            { Proposition p = null;
              Iterator iter001 = Logic.unfilteredDependentPropositions(from, null).allocateIterator();

              while (iter001.nextP()) {
                p = ((Proposition)(iter001.value));
                if (!exceptpropositions.memberP(p)) {
                  if (((BooleanWrapper)(KeyValueList.dynamicSlotValue(p.dynamicSlots, Logic.SYM_LOGIC_DESCRIPTIVEp, Stella.FALSE_WRAPPER))).wrapperValue) {
                    Native.setSpecial(Logic.$EVALUATIONMODE$, Logic.KWD_DESCRIPTION);
                  }
                  else {
                    Native.setSpecial(Logic.$EVALUATIONMODE$, Logic.KWD_EXTENSIONAL_ASSERTION);
                  }
                  tovalue = Logic.evaluateTerm(to);
                  { Stella_Object arg = null;
                    Vector vector000 = p.arguments;
                    int index000 = 0;
                    int length000 = vector000.length();
                    int i = Stella.NULL_INTEGER;
                    int iter002 = 0;

                    for (;index000 < length000; index000 = index000 + 1, iter002 = iter002 + 1) {
                      arg = (vector000.theArray)[index000];
                      i = iter002;
                      if (Stella_Object.eqlP(arg, from)) {
                        (p.arguments.theArray)[i] = tovalue;
                      }
                    }
                  }
                  { boolean testValue000 = false;

                    { boolean foundP000 = false;

                      { Stella_Object top = null;
                        Cons iter003 = topropositions;

                        loop003 : for (;!(iter003 == Stella.NIL); iter003 = iter003.rest) {
                          top = iter003.value;
                          if (Proposition.equivalentPropositionsP(p, ((Proposition)(top)), null)) {
                            foundP000 = true;
                            break loop003;
                          }
                        }
                      }
                      testValue000 = foundP000;
                    }
                    testValue000 = !testValue000;
                    if (testValue000) {
                      Logic.removeDependentPropositionLink(from, p);
                      Logic.addDependentPropositionLink(tovalue, p);
                    }
                  }
                }
              }
            }

          } finally {
            Logic.$EVALUATIONMODE$.set(old$Evaluationmode$000);
          }
        }
      }
    }
  }