public static Stella_Object computeSimpleRelationConstraint(Proposition proposition, MethodSlot computation, boolean errorP, Object [] MV_returnarray) {
    { Vector arguments = proposition.arguments;
      NamedDescription description = Logic.getDescription(((Surrogate)(proposition.operator)));
      List argtypes = description.ioVariableTypes;
      int ninputtypes = argtypes.length();
      List compargtypes = null;
      Stella_Object value = null;
      int nullcount = 0;
      int variableindex = -1;
      Cons boundarguments = Stella.NIL;

      if (computation == null) {
        computation = NamedDescription.lookupConstraintFunction(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;
        Cons collect000 = null;

        for (;index000 < length000; index000 = index000 + 1, iter000 = iter000 + 1) {
          arg = (vector000.theArray)[index000];
          i = iter000;
          value = Logic.safeArgumentBoundTo(arg);
          if (value == null) {
            value = null;
            nullcount = nullcount + 1;
            variableindex = i;
          }
          else if (Logic.checkStrictTypeP(value, Logic.argumentTargetType(argtypes, ninputtypes, i), true) &&
              Surrogate.subtypeOfP(value.primaryType(), Logic.argumentTargetType(compargtypes, ninputtypes + 1, i + 1))) {
          }
          else if (Logic.skolemP(value) &&
              (!Skolem.boundComputationInputSkolemP(((Skolem)(value))))) {
            value = null;
            nullcount = nullcount + 1;
            variableindex = i;
          }
          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-constraint: 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 {
              { Stella_Object _return_temp = null;

                MV_returnarray[0] = IntegerWrapper.wrapInteger(-1);
                return (_return_temp);
              }
            }
          }
          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;
            }
          }
        }
      }
      switch (nullcount) {
        case 0: 
          value = Stella.apply(computation.functionCode, Cons.cons(IntegerWrapper.wrapInteger(variableindex), boundarguments));
        break;
        case 1: 
          if (((Boolean)(Logic.$REVERSEPOLARITYp$.get())).booleanValue()) {
            { Stella_Object _return_temp = null;

              MV_returnarray[0] = IntegerWrapper.wrapInteger(-1);
              return (_return_temp);
            }
          }
          value = Stella.apply(computation.functionCode, Cons.cons(IntegerWrapper.wrapInteger(variableindex), boundarguments));
        break;
        default:
          { Stella_Object _return_temp = null;

            MV_returnarray[0] = IntegerWrapper.wrapInteger(-1);
            return (_return_temp);
          }
      }
      { Stella_Object _return_temp = value;

        MV_returnarray[0] = IntegerWrapper.wrapInteger(variableindex);
        return (_return_temp);
      }
    }
  }