public static void elaborateInstance(Stella_Object self) {
    if (((Boolean)(Logic.$FILLINGCONSTRAINTPROPAGATIONQUEUESp$.get())).booleanValue()) {
      return;
    }
    if (Logic.$JUST_IN_TIME_FORWARD_INFERENCEp$) {
      if (Surrogate.subtypeOfP(Stella_Object.safePrimaryType(self), Logic.SGT_LOGIC_LOGIC_OBJECT)) {
        { LogicObject self000 = ((LogicObject)(self));

          { PropagationEnvironment environment = Logic.getPropagationEnvironment(((Context)(Stella.$CONTEXT$.get())));

            if (environment.elaboratedObjects.memberP(self000)) {
              return;
            }
            if ((Stella.$TRACED_KEYWORDS$ != null) &&
                Stella.$TRACED_KEYWORDS$.membP(Logic.KWD_ELABORATE)) {
              System.out.println(" ELABORATING:  " + self000 + " in world " + ((Context)(Stella.$CONTEXT$.get())));
            }
            { Object old$Evaluationmode$000 = Logic.$EVALUATIONMODE$.get();
              Object old$InhibitobjectfinalizationP$000 = Logic.$INHIBITOBJECTFINALIZATIONp$.get();
              Object old$Queryiterator$000 = Logic.$QUERYITERATOR$.get();

              try {
                Native.setSpecial(Logic.$EVALUATIONMODE$, Logic.KWD_EXTENSIONAL_ASSERTION);
                Native.setBooleanSpecial(Logic.$INHIBITOBJECTFINALIZATIONp$, true);
                Native.setSpecial(Logic.$QUERYITERATOR$, null);
                try {
                  { Object old$FillingconstraintpropagationqueuesP$000 = Logic.$FILLINGCONSTRAINTPROPAGATIONQUEUESp$.get();

                    try {
                      Native.setBooleanSpecial(Logic.$FILLINGCONSTRAINTPROPAGATIONQUEUESp$, true);
                      Logic.postRelatedFacts(self000, environment);
                      LogicObject.evaluateReachableInequalities(self000, List.list(Stella.NIL));
                      { Object old$DeferingdefaultforwardinferencesP$000 = Logic.$DEFERINGDEFAULTFORWARDINFERENCESp$.get();

                        try {
                          Native.setBooleanSpecial(Logic.$DEFERINGDEFAULTFORWARDINFERENCESp$, true);
                          Logic.executeConstraintPropagationQueues();

                        } finally {
                          Logic.$DEFERINGDEFAULTFORWARDINFERENCESp$.set(old$DeferingdefaultforwardinferencesP$000);
                        }
                      }
                      { Proposition p = null;
                        Cons iter000 = environment.deferredDefaultPropositions.theConsList;

                        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
                          p = ((Proposition)(iter000.value));
                          Proposition.assignTruthValue(p, Logic.DEFAULT_TRUE_TRUTH_VALUE);
                        }
                      }
                      environment.deferredDefaultPropositions.clear();
                      Logic.executeConstraintPropagationQueues();

                    } finally {
                      Logic.$FILLINGCONSTRAINTPROPAGATIONQUEUESp$.set(old$FillingconstraintpropagationqueuesP$000);
                    }
                  }
                } catch (Clash e) {
                  { ExceptionRecord self001 = ExceptionRecord.newExceptionRecord();

                    self001.exception = e;
                    self001.context = ((Context)(Stella.$CONTEXT$.get()));
                    self001.module = ((Module)(Stella.$MODULE$.get()));
                    Logic.$CLASH_EXCEPTIONS$.push(self001);
                  }
                  Stella.STANDARD_ERROR.nativeStream.println(Stella.exceptionMessage(e));
                }

              } finally {
                Logic.$QUERYITERATOR$.set(old$Queryiterator$000);
                Logic.$INHIBITOBJECTFINALIZATIONp$.set(old$InhibitobjectfinalizationP$000);
                Logic.$EVALUATIONMODE$.set(old$Evaluationmode$000);
              }
            }
          }
        }
      }
      else {
      }
    }
  }