public static Stella_Object computeRelationValue(Proposition proposition, MethodSlot computation, boolean errorP) {
    { Vector arguments = proposition.arguments;
      NamedDescription description = Logic.getDescription(((Surrogate)(proposition.operator)));
      boolean functionP = NamedDescription.functionDescriptionP(description);
      List argtypes = description.ioVariableTypes;
      int ninputtypes = argtypes.length() - ((functionP ? 1 : 0));
      List compargtypes = null;
      Stella_Object value = null;
      Cons boundarguments = Stella.NIL;
      boolean variablearityP = Description.variableArityP(description);

      if (computation == null) {
        computation = NamedDescription.lookupComputationFunction(description);
      }
      compargtypes = computation.methodParameterTypeSpecifiers();
      { Stella_Object arg = null;
        Vector vector000 = arguments;
        int index000 = 0;
        int length000 = vector000.length();
        int i = Stella.NULL_INTEGER;
        int iter000 = 0;
        int upperBound000 = arguments.length() - ((functionP ? 2 : 1));
        Cons collect000 = null;

        for (;(index000 < length000) &&
                  (iter000 <= upperBound000); index000 = index000 + 1, iter000 = iter000 + 1) {
          arg = (vector000.theArray)[index000];
          i = iter000;
          value = Logic.safeArgumentBoundTo(arg);
          if (value == null) {
            return (null);
          }
          else if (Logic.checkStrictTypeP(value, Logic.argumentTargetType(argtypes, ninputtypes, i), true) &&
              Surrogate.subtypeOfP(value.primaryType(), Logic.argumentTargetType(compargtypes, ninputtypes, i))) {
          }
          else if (Logic.skolemP(value) &&
              (!Skolem.boundComputationInputSkolemP(((Skolem)(value))))) {
            return (null);
          }
          else {
            if (errorP) {
              { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

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

                  try {
                    Native.setBooleanSpecial(Stella.$PRINTREADABLYp$, true);
                    stream000.nativeStream.println("ERROR: compute-relation-value: incorrect argument type for `" + value + "' in `" + proposition + "'.");
                    Logic.helpSignalPropositionError(stream000, Logic.KWD_ERROR);

                  } finally {
                    Stella.$PRINTREADABLYp$.set(old$PrintreadablyP$000);
                  }
                }
                throw ((PropositionError)(PropositionError.newPropositionError(stream000.theStringReader()).fillInStackTrace()));
              }
            }
            else {
              return (null);
            }
          }
          if (collect000 == null) {
            {
              collect000 = Cons.cons(value, Stella.NIL);
              if (boundarguments == Stella.NIL) {
                boundarguments = collect000;
              }
              else {
                Cons.addConsToEndOfConsList(boundarguments, collect000);
              }
            }
          }
          else {
            {
              collect000.rest = Cons.cons(value, Stella.NIL);
              collect000 = collect000.rest;
            }
          }
        }
      }
      if (variablearityP) {
        { int nfixed = argtypes.length() - ((functionP ? 2 : 1));

          if (nfixed == 0) {
            boundarguments = Cons.cons(boundarguments, Stella.NIL);
          }
          else if (boundarguments.length() >= nfixed) {
            boundarguments.nthRestSetter(Cons.cons(boundarguments.nthRest(nfixed), Stella.NIL), nfixed);
          }
          else {
            return (null);
          }
        }
      }
      value = Stella.apply(computation.functionCode, boundarguments);
      return (value);
    }
  }