public static boolean helpCollectSkolemizedExistsVariablesP(Proposition proposition, List result) {
    { Vector arguments = proposition.arguments;
      int argumentcount = arguments.length();

      if (proposition.kind == Logic.KWD_FUNCTION) {
        argumentcount = argumentcount - 1;
      }
      { Stella_Object arg = null;
        Vector vector000 = arguments;
        int index000 = 0;
        int length000 = vector000.length();
        int i = Stella.NULL_INTEGER;
        int iter000 = 1;
        int upperBound000 = argumentcount;
        boolean unboundedP000 = upperBound000 == Stella.NULL_INTEGER;

        for (;(index000 < length000) &&
                  (unboundedP000 ||
                   (iter000 <= upperBound000)); index000 = index000 + 1, iter000 = iter000 + 1) {
          arg = (vector000.theArray)[index000];
          i = iter000;
          i = i;
          { Surrogate testValue000 = Stella_Object.safePrimaryType(arg);

            if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_PROPOSITION)) {
              { Proposition arg000 = ((Proposition)(arg));

                if (Proposition.helpCollectSkolemizedExistsVariablesP(arg000, result) &&
                    (result == null)) {
                  return (true);
                }
              }
            }
            else if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_PATTERN_VARIABLE)) {
              { PatternVariable arg000 = ((PatternVariable)(arg));

              }
            }
            else if (Surrogate.subtypeOfP(testValue000, Logic.SGT_LOGIC_SKOLEM)) {
              { Skolem arg000 = ((Skolem)(arg));

                { boolean foundP000 = false;

                  { Proposition prop = null;
                    Iterator iter001 = Logic.unfilteredDependentIsaPropositions(arg000).allocateIterator();

                    loop001 : while (iter001.nextP()) {
                      prop = ((Proposition)(iter001.value));
                      if ((prop.kind == Logic.KWD_ISA) &&
                          (Proposition.trueP(prop) &&
                           BooleanWrapper.coerceWrappedBooleanToBoolean(prop.variableTypeP()))) {
                        foundP000 = true;
                        break loop001;
                      }
                    }
                  }
                  if (foundP000) {
                    if (result != null) {
                      result.insertNew(arg000);
                    }
                    else {
                      return (true);
                    }
                  }
                }
              }
            }
            else {
            }
          }
        }
      }
      if (result != null) {
        return (result.nonEmptyP());
      }
      else {
        return (false);
      }
    }
  }