public static Cons oldRecursiveBuildAntecedent(Symbol inst, int depth) {
    Logic.$VISITED_INSTANCES$.push(inst);
    { Module home = ((Module)(inst.homeContext));
      List facts = List.newList();
      Cons antecedent = Stella.NIL;
      Cons children = Stella.NIL;

      { Object old$Module$000 = Stella.$MODULE$.get();
        Object old$Context$000 = Stella.$CONTEXT$.get();

        try {
          Native.setSpecial(Stella.$MODULE$, home);
          Native.setSpecial(Stella.$CONTEXT$, ((Module)(Stella.$MODULE$.get())));
          facts = Logic.allFactsOfInstance(Logic.getInstance(inst), false, false);

        } finally {
          Stella.$CONTEXT$.set(old$Context$000);
          Stella.$MODULE$.set(old$Module$000);
        }
      }
      { Proposition fact = null;
        Cons iter000 = facts.theConsList;

        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest) {
          fact = ((Proposition)(iter000.value));
          if ((!Logic.$VISITED_PROPOSITIONS$.memberP(fact)) &&
              (!Logic.$TABOO_OPERATORS$.memberP(fact.operator))) {
            Logic.$VISITED_PROPOSITIONS$.push(fact);
            { Cons consProp = Proposition.propositionToCons(fact);

              { Keyword testValue000 = fact.kind;

                if (testValue000 == Logic.KWD_FUNCTION) {
                  if (Logic.$DROP_FUNCTION_VALUESp$) {
                    consProp = Cons.list$(Cons.cons(Logic.SYM_STELLA_e, Cons.cons(consProp.reverse().rest.reverse(), Cons.cons(Stella.NIL, Stella.NIL))));
                  }
                  else {
                    consProp = Cons.list$(Cons.cons(Logic.SYM_STELLA_AND, Cons.cons(consProp, Cons.cons(Stella.NIL, Stella.NIL))));
                  }
                }
                else if (testValue000 == Logic.KWD_ISA) {
                  consProp = Cons.list$(Cons.cons(Logic.SYM_STELLA_AND, Cons.cons(consProp, Cons.cons(Stella.NIL, Stella.NIL))));
                }
                else {
                  if (depth < Logic.$MAX_STRUCTURE_DEPTH$) {
                    consProp = Cons.list$(Cons.cons(Logic.SYM_STELLA_AND, Cons.cons(consProp, Cons.cons(Stella.NIL, Stella.NIL))));
                  }
                  else {
                    consProp = Stella.NIL;
                  }
                }
              }
              if (!(consProp == Stella.NIL)) {
                antecedent = Cons.cons(consProp, antecedent);
                { Stella_Object ele = null;
                  Cons iter001 = ((Cons)(consProp.rest.value)).rest;

                  for (;!(iter001 == Stella.NIL); iter001 = iter001.rest) {
                    ele = iter001.value;
                    if (Stella_Object.isaP(ele, Logic.SGT_STELLA_SYMBOL) &&
                        ((!Logic.$VISITED_INSTANCES$.memberP(ele)) &&
                         (depth < Logic.$MAX_STRUCTURE_DEPTH$))) {
                      children = Logic.oldRecursiveBuildAntecedent(((Symbol)(ele)), depth + 1).concatenate(children, Stella.NIL);
                    }
                  }
                }
              }
            }
          }
        }
      }
      if (children == Stella.NIL) {
        return (antecedent);
      }
      else {
        return (antecedent.concatenate(children, Stella.NIL));
      }
    }
  }