public static boolean unequateConflictingDefaultValuesP(Proposition newequatingprop) {
    { Vector arguments = newequatingprop.arguments;
      Stella_Object firstarg = (arguments.theArray)[0];
      boolean firstargisskolemP = Logic.skolemP(firstarg);
      Stella_Object firstargvalue = Logic.innermostOf(firstarg);
      Stella_Object secondarg = (arguments.theArray)[1];
      boolean secondargisskolemP = Logic.skolemP(secondarg);
      Stella_Object secondargvalue = Logic.innermostOf(secondarg);
      boolean newisdefaultP = Proposition.defaultTrueP(newequatingprop);
      Stella_Object newtruthvalue = null;
      Proposition equatingprop = null;

      if (Stella_Object.eqlP(firstargvalue, secondargvalue)) {
        return (true);
      }
      else if (Logic.skolemP(firstargvalue)) {
        if ((((Skolem)(firstargvalue)).conflictingDefaultValues() == Stella.NIL) ||
            (!newisdefaultP)) {
          return (true);
        }
        else {
          return (false);
        }
      }
      else if (Logic.skolemP(secondargvalue)) {
        if ((((Skolem)(secondargvalue)).conflictingDefaultValues() == Stella.NIL) ||
            (!newisdefaultP)) {
          return (true);
        }
        else {
          return (false);
        }
      }
      if (firstargisskolemP &&
          (secondargisskolemP &&
           newisdefaultP)) {
        { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

          { Object old$PrintreadablyP$000 = Stella.$PRINTREADABLYp$.get();

            try {
              Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
              {
                stream000.nativeStream.println("ERROR: Equating two skolems `" + firstarg + "' and `" + secondarg + "' by default is not yet supported.");
                stream000.nativeStream.println(".");
              }
;
              Logic.helpSignalPropositionError(stream000, Logic.KWD_ERROR);

            } finally {
              Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
            }
          }
          throw ((PropositionError)(PropositionError.newPropositionError(stream000.theStringReader()).fillInStackTrace()));
        }
      }
      newtruthvalue = newequatingprop.truthValue;
      newequatingprop.truthValue = null;
      if (firstargisskolemP) {
        { Object old$DontusedefaultknowledgeP$000 = Logic.$DONTUSEDEFAULTKNOWLEDGEp$.get();

          try {
            Native.setBooleanSpecial(Logic.$DONTUSEDEFAULTKNOWLEDGEp$, true);
            equatingprop = Logic.findEquatingProposition(firstargvalue, ((LogicObject)(firstarg)));

          } finally {
            Logic.$DONTUSEDEFAULTKNOWLEDGEp$.set(old$DontusedefaultknowledgeP$000);
          }
        }
        if (equatingprop == null) {
          equatingprop = Logic.findEquatingProposition(firstargvalue, ((LogicObject)(firstarg)));
          while (!Stella_Object.eqlP(Logic.valueOf(firstarg), firstargvalue)) {
            firstarg = Logic.valueOf(firstarg);
          }
          { Skolem skolem = ((Skolem)(firstarg));

            { Skolem object000 = skolem;
              Stella_Object value000 = null;
              Stella_Object oldValue001 = object000.variableValue;
              Stella_Object newValue000 = Stella_Object.updateInContext(oldValue001, value000, object000.homeContext, false);

              if (!((oldValue001 != null) &&
                  (oldValue001.primaryType() == Logic.SGT_STELLA_CS_VALUE))) {
                object000.variableValue = newValue000;
              }
            }
            KeyValueList.setDynamicSlotValue(skolem.dynamicSlots, Logic.SYM_LOGIC_CONFLICTING_DEFAULT_VALUES, Cons.cons(equatingprop, skolem.conflictingDefaultValues()), null);
            if (newisdefaultP) {
              KeyValueList.setDynamicSlotValue(skolem.dynamicSlots, Logic.SYM_LOGIC_CONFLICTING_DEFAULT_VALUES, Cons.cons(newequatingprop, skolem.conflictingDefaultValues()), null);
            }
          }
        }
      }
      if (secondargisskolemP) {
        { Object old$DontusedefaultknowledgeP$001 = Logic.$DONTUSEDEFAULTKNOWLEDGEp$.get();

          try {
            Native.setBooleanSpecial(Logic.$DONTUSEDEFAULTKNOWLEDGEp$, true);
            equatingprop = Logic.findEquatingProposition(secondargvalue, ((LogicObject)(secondarg)));

          } finally {
            Logic.$DONTUSEDEFAULTKNOWLEDGEp$.set(old$DontusedefaultknowledgeP$001);
          }
        }
        if (equatingprop == null) {
          equatingprop = Logic.findEquatingProposition(firstargvalue, ((LogicObject)(firstarg)));
          while (!Stella_Object.eqlP(Logic.valueOf(secondarg), secondargvalue)) {
            secondarg = Logic.valueOf(secondarg);
          }
          { Skolem skolem = ((Skolem)(secondarg));

            { Skolem object001 = skolem;
              Stella_Object value001 = null;
              Stella_Object oldValue002 = object001.variableValue;
              Stella_Object newValue001 = Stella_Object.updateInContext(oldValue002, value001, object001.homeContext, false);

              if (!((oldValue002 != null) &&
                  (oldValue002.primaryType() == Logic.SGT_STELLA_CS_VALUE))) {
                object001.variableValue = newValue001;
              }
            }
            KeyValueList.setDynamicSlotValue(skolem.dynamicSlots, Logic.SYM_LOGIC_CONFLICTING_DEFAULT_VALUES, Cons.cons(equatingprop, skolem.conflictingDefaultValues()), null);
            if (newisdefaultP) {
              KeyValueList.setDynamicSlotValue(skolem.dynamicSlots, Logic.SYM_LOGIC_CONFLICTING_DEFAULT_VALUES, Cons.cons(newequatingprop, skolem.conflictingDefaultValues()), null);
            }
          }
        }
      }
      newequatingprop.truthValue = ((TruthValue)(newtruthvalue));
      return (((!firstargisskolemP) &&
          (!secondargisskolemP)) ||
          (!newisdefaultP));
    }
  }