public static void normalizeOrProposition(Proposition self) {
    { Cons propositions = Stella.NIL;
      boolean disjoinP = false;

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

        for (;index000 < length000; index000 = index000 + 1) {
          arg = (vector000.theArray)[index000];
          if (Logic.variableP(arg)) {
            { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

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

                try {
                  Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                  stream000.nativeStream.println("ERROR: Can't yet handle propositional variables within disjunctions.");
                  Logic.helpSignalPropositionError(stream000, Logic.KWD_ERROR);

                } finally {
                  Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                }
              }
              throw ((PropositionError)(PropositionError.newPropositionError(stream000.theStringReader()).fillInStackTrace()));
            }
          }
          { Proposition disjunct = ((Proposition)(arg));

            Proposition.normalizeProposition(disjunct);
            { Keyword testValue000 = disjunct.kind;

              if (testValue000 == Logic.KWD_OR) {
                propositions = Cons.cons(disjunct, propositions);
                disjoinP = true;
              }
              else if (testValue000 == Logic.KWD_CONSTANT) {
                if (disjunct.operator == Logic.SGT_STELLA_FALSE) {
                  disjoinP = true;
                }
                else if (disjunct.operator == Logic.SGT_STELLA_TRUE) {
                  Proposition.overlayWithConstantProposition(self, Logic.TRUE_PROPOSITION);
                  return;
                }
                else {
                  if (propositions.memberP(disjunct)) {
                    disjoinP = true;
                  }
                  else {
                    propositions = Cons.cons(disjunct, propositions);
                  }
                }
              }
              else {
                { boolean testValue001 = false;

                  testValue001 = !disjoinP;
                  if (testValue001) {
                    { boolean foundP000 = false;

                      { Stella_Object prop = null;
                        Cons iter000 = propositions;

                        loop001 : for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                          prop = iter000.value;
                          if (Proposition.duplicateAndOrArgumentsP(((Proposition)(prop)), disjunct)) {
                            foundP000 = true;
                            break loop001;
                          }
                        }
                      }
                      testValue001 = foundP000;
                    }
                  }
                  if (testValue001) {
                    disjoinP = true;
                  }
                  else {
                    propositions = Cons.cons(disjunct, propositions);
                  }
                }
              }
            }
          }
        }
      }
      if (disjoinP ||
          (propositions.length() <= 1)) {
        Proposition.overlayProposition(self, Logic.disjoinPropositions(propositions));
      }
    }
  }